Taskfile.yml

version: "3"

vars:
  SOLUTION: Seed.slnx
  ENGINE: src/Seed.Engine/Seed.Engine.csproj
  APP: src/Seed.Engine.App/Seed.Engine.App.csproj
  TESTS: src/Seed.Engine.Tests/Seed.Engine.Tests.csproj
  BENCHMARKS: src/Seed.Engine.Benchmarks/Seed.Engine.Benchmarks.csproj
  SHARED: src/Seed.Shared/Seed.Shared.csproj
  WORKER: src/Seed.Engine.Worker/Seed.Engine.Worker.csproj
  ANDROID_APP: src/Seed.Engine.App.Android/Seed.Engine.App.Android.csproj
  LAUNCHER: src/Seed.Launcher/Seed.Launcher.csproj
  CONFIG: Release
  SHADER_DIR: src/Seed.Engine/Shaders

tasks:
  default:
    desc: Build and test
    cmds:
      - task: test

  build:
    desc: Build all projects
    cmds:
      - dotnet build {{.SOLUTION}} -c {{.CONFIG}}

  test:
    desc: Run all tests
    deps: [build]
    cmds:
      - dotnet test {{.TESTS}} -c {{.CONFIG}} --no-build

  bench:
    desc: Run benchmarks
    cmds:
      - dotnet run --project {{.BENCHMARKS}} -c {{.CONFIG}} -- --filter "{{.CLI_ARGS | default "*"}}"

  clean:
    desc: Remove bin/obj directories
    cmds:
      - dotnet clean {{.SOLUTION}} -c {{.CONFIG}}
      - rm -rf src/*/bin src/*/obj

  restore:
    desc: Restore NuGet packages
    cmds:
      - dotnet restore {{.SOLUTION}}

  shader-compile:
    desc: Compile HLSL shaders to SPIR-V
    cmds:
      - glslc -fshader-stage=vert {{.SHADER_DIR}}/triangle.vert.glsl -o {{.SHADER_DIR}}/triangle.vert.spv
      - glslc -fshader-stage=frag {{.SHADER_DIR}}/triangle.frag.glsl -o {{.SHADER_DIR}}/triangle.frag.spv
      - glslc -fshader-stage=vert {{.SHADER_DIR}}/gbuffer.vert.glsl -o {{.SHADER_DIR}}/gbuffer.vert.spv
      - glslc -fshader-stage=frag {{.SHADER_DIR}}/gbuffer.frag.glsl -o {{.SHADER_DIR}}/gbuffer.frag.spv
      - glslc -fshader-stage=vert {{.SHADER_DIR}}/lighting.vert.glsl -o {{.SHADER_DIR}}/lighting.vert.spv
      - glslc -fshader-stage=frag {{.SHADER_DIR}}/lighting.frag.glsl -o {{.SHADER_DIR}}/lighting.frag.spv
      - glslc -fshader-stage=vert {{.SHADER_DIR}}/shadow.vert.glsl -o {{.SHADER_DIR}}/shadow.vert.spv
      - glslc -fshader-stage=frag {{.SHADER_DIR}}/shadow.frag.glsl -o {{.SHADER_DIR}}/shadow.frag.spv
      - glslc -fshader-stage=vert {{.SHADER_DIR}}/pointlight.vert.glsl -o {{.SHADER_DIR}}/pointlight.vert.spv
      - glslc -fshader-stage=frag {{.SHADER_DIR}}/pointlight.frag.glsl -o {{.SHADER_DIR}}/pointlight.frag.spv
      - glslc -fshader-stage=vert {{.SHADER_DIR}}/spotlight.vert.glsl -o {{.SHADER_DIR}}/spotlight.vert.spv
      - glslc -fshader-stage=frag {{.SHADER_DIR}}/spotlight.frag.glsl -o {{.SHADER_DIR}}/spotlight.frag.spv
      - glslc -fshader-stage=vert {{.SHADER_DIR}}/boundary.vert.glsl -o {{.SHADER_DIR}}/boundary.vert.spv
      - glslc -fshader-stage=frag {{.SHADER_DIR}}/boundary.frag.glsl -o {{.SHADER_DIR}}/boundary.frag.spv
      - glslc -fshader-stage=vert {{.SHADER_DIR}}/fp_depth.vert.glsl -o {{.SHADER_DIR}}/fp_depth.vert.spv
      - glslc -fshader-stage=frag {{.SHADER_DIR}}/fp_depth.frag.glsl -o {{.SHADER_DIR}}/fp_depth.frag.spv
      - glslc -fshader-stage=comp {{.SHADER_DIR}}/fp_lightcull.comp.glsl -o {{.SHADER_DIR}}/fp_lightcull.comp.spv
      - glslc -fshader-stage=vert {{.SHADER_DIR}}/fp_opaque.vert.glsl -o {{.SHADER_DIR}}/fp_opaque.vert.spv
      - glslc -fshader-stage=frag {{.SHADER_DIR}}/fp_opaque.frag.glsl -o {{.SHADER_DIR}}/fp_opaque.frag.spv
      - glslc -fshader-stage=vert {{.SHADER_DIR}}/fp_transparent.vert.glsl -o {{.SHADER_DIR}}/fp_transparent.vert.spv
      - glslc -fshader-stage=frag {{.SHADER_DIR}}/fp_transparent.frag.glsl -o {{.SHADER_DIR}}/fp_transparent.frag.spv
      - glslc -fshader-stage=comp {{.SHADER_DIR}}/skinning.comp.glsl -o {{.SHADER_DIR}}/skinning.comp.spv

  run:
    desc: Run the triangle demo application
    deps: [shader-compile, build]
    cmds:
      - dotnet run --project {{.APP}} -c {{.CONFIG}} --no-build

  proto:format:
    desc: Format proto files with buf
    cmds:
      - buf format -w proto

  proto:gen:
    desc: Generate code from proto files (Go + C#)
    cmds:
      - task: proto:format
      - task: proto:go
      - task: proto:csharp

  proto:go:
    desc: Generate Go code from proto files
    cmds:
      - mkdir -p server/pkg/proto/seedpb
      - >-
        protoc --proto_path=proto
        --go_out=server/pkg/proto/seedpb --go_opt=paths=source_relative
        --go-grpc_out=server/pkg/proto/seedpb --go-grpc_opt=paths=source_relative
        proto/*.proto

  proto:csharp:
    desc: Generate C# code from proto files
    cmds:
      - dotnet build {{.SHARED}} -c {{.CONFIG}}

  proto:check:
    desc: Verify generated code is up to date
    cmds:
      - task: proto:gen
      - git diff --exit-code -- server/pkg/proto/ src/Seed.Shared/Proto/

  go:build:
    desc: Build Go server
    dir: server
    cmds:
      - go build ./...

  go:test:
    desc: Run Go server tests
    dir: server
    cmds:
      - go test ./... -v

  go:build:auth:
    desc: Build auth server binary
    dir: server
    cmds:
      - go build -o bin/auth ./cmd/auth/

  go:build:world:
    desc: Build world server binary
    dir: server
    cmds:
      - go build -o bin/world ./cmd/world/

  go:build:lobby:
    desc: Build lobby server binary
    dir: server
    cmds:
      - go build -o bin/lobby ./cmd/lobby/

  go:build:sfu:
    desc: Build SFU server binary
    dir: server
    cmds:
      - go build -o bin/sfu ./cmd/sfu/

  go:build:parcel:
    desc: Build parcel server binary
    dir: server
    cmds:
      - go build -o bin/parcel ./cmd/parcel/

  go:build:social:
    desc: Build social server binary
    dir: server
    cmds:
      - go build -o bin/social ./cmd/social/

  go:run:social:
    desc: Run social server locally (requires infra:up + dev:keygen)
    deps: [dev:keygen]
    dir: server
    env:
      DATABASE_URL: postgres://seed:seed@localhost:5432/seed_auth?sslmode=disable
      REDIS_URL: "redis://localhost:6379"
      LISTEN_ADDR: ":8084"
      ED25519_PRIVATE_KEY_FILE: "{{.ROOT_DIR}}/.dev/ed25519.seed"
    cmds:
      - go run ./cmd/social/

  go:build:avatarstore:
    desc: Build avatarstore server binary
    dir: server
    cmds:
      - go build -o bin/avatarstore ./cmd/avatarstore/

  go:run:avatarstore:
    desc: Run avatarstore server locally (requires infra:up + dev:keygen)
    deps: [dev:keygen]
    dir: server
    env:
      DATABASE_URL: postgres://seed:seed@localhost:5432/seed_auth?sslmode=disable
      REDIS_URL: "redis://localhost:6379"
      LISTEN_ADDR: ":8085"
      ED25519_PRIVATE_KEY_FILE: "{{.ROOT_DIR}}/.dev/ed25519.seed"
      ASSET_STORE_DIR: "{{.ROOT_DIR}}/.dev/assets"
      ASSET_BASE_URL: "http://localhost:8085/assets"
    cmds:
      - go run ./cmd/avatarstore/

  go:run:parcel:
    desc: Run parcel server locally (requires infra:up + dev:keygen)
    deps: [dev:keygen]
    dir: server
    env:
      DATABASE_URL: postgres://seed:seed@localhost:5432/seed_auth?sslmode=disable
      LISTEN_ADDR: ":8082"
      ED25519_PRIVATE_KEY_FILE: "{{.ROOT_DIR}}/.dev/ed25519.seed"
    cmds:
      - go run ./cmd/parcel/

  compile:build:
    desc: Build Seed.Compile script compiler binary
    cmds:
      - dotnet build src/Seed.Compile/Seed.Compile.csproj -c Release

  compile:run:
    desc: Run Seed.Compile locally (listens on COMPILE_SOCKET_PATH)
    env:
      COMPILE_SOCKET_PATH: "/tmp/seed-compile.sock"
    cmds:
      - dotnet run --project src/Seed.Compile/Seed.Compile.csproj -c Release --no-build

  go:build:parcelcontroller:
    desc: Build parcel controller server binary
    dir: server
    cmds:
      - go build -o bin/parcelcontroller ./cmd/parcelcontroller/

  go:run:parcelcontroller:
    desc: Run parcel controller server locally (requires infra:up + WORKER_IMAGE)
    dir: server
    env:
      LISTEN_ADDR: ":50052"
      REDIS_URL: "redis://localhost:6379"
      K8S_NAMESPACE: "default"
      WORKER_IMAGE: "seed-worker:latest"
    cmds:
      - go run ./cmd/parcelcontroller/

  go:build:orchestrator:
    desc: Build orchestrator server binary
    dir: server
    cmds:
      - go build -o bin/orchestrator ./cmd/orchestrator/

  go:run:orchestrator:
    desc: Run orchestrator server locally (requires dev:keygen + PARCEL_ID)
    deps: [dev:keygen]
    dir: server
    env:
      LISTEN_ADDR: ":8083"
      DB_URL: "postgres://seed:seed@localhost:5432/seed?sslmode=disable"
      ED25519_PRIVATE_KEY_FILE: "{{.ROOT_DIR}}/.dev/ed25519.seed"
    cmds:
      - go run ./cmd/orchestrator/

  go:loadtest:parcel:
    desc: Run parcel instance 50-client load test (5 min, pass criteria tick p99 < 40ms + RSS < 512MB)
    cmds:
      - bash server/scripts/loadtest-parcel.sh {{.CLI_ARGS}}

  infra:up:
    desc: Start PostgreSQL and Redis via docker compose
    cmds:
      - docker compose up -d

  infra:down:
    desc: Stop PostgreSQL and Redis
    cmds:
      - docker compose down

  infra:reset:
    desc: Stop and remove volumes (wipes data)
    cmds:
      - docker compose down -v

  dev:keygen:
    desc: Generate Ed25519 key pair for local development
    cmds:
      - mkdir -p .dev
      - >-
        go run -C server ./cmd/keygen/ > .dev/ed25519.seed
    status:
      - test -f .dev/ed25519.seed

  dev:certgen:
    desc: Generate self-signed Ed25519 certificate for DTLS (dev only)
    cmds:
      - mkdir -p .dev
      - >-
        openssl req -x509 -newkey ed25519 -nodes
        -keyout .dev/dtls.key -out .dev/dtls.crt
        -days 3650
        -subj "/CN=seed-world-dev"
    status:
      - test -f .dev/dtls.crt
      - test -f .dev/dtls.key

  go:run:auth:
    desc: Run auth server locally (requires infra:up + dev:keygen)
    deps: [dev:keygen]
    dir: server
    env:
      DATABASE_URL: postgres://seed:seed@localhost:5432/seed_auth?sslmode=disable
      REDIS_ADDR: localhost:6379
      LISTEN_ADDR: ":8080"
      ED25519_PRIVATE_KEY_FILE: "{{.ROOT_DIR}}/.dev/ed25519.seed"
    cmds:
      - go run ./cmd/auth/

  go:run:lobby:
    desc: Run lobby server locally (requires dev:keygen)
    deps: [dev:keygen]
    dir: server
    env:
      LISTEN_ADDR: ":8070"
      REDIS_ADDR: "localhost:6379"
      ED25519_PRIVATE_KEY_FILE: "{{.ROOT_DIR}}/.dev/ed25519.seed"
    cmds:
      - go run ./cmd/lobby/

  go:run:world:
    desc: Run world server locally (requires dev:keygen)
    deps: [dev:keygen]
    dir: server
    env:
      LISTEN_ADDR: ":9000"
      ED25519_PRIVATE_KEY_FILE: "{{.ROOT_DIR}}/.dev/ed25519.seed"
      WORLD_NAME: "default-world"
      WORLD_UDP_ADDR: "localhost:9000"
      WORLD_SFU_ADDR: "localhost:8080"
    cmds:
      - go run ./cmd/world/

  go:loadtest:sfu:
    desc: Run SFU 50-client load test (requires docker, builds loadtest-sfu if needed)
    cmds:
      - bash server/scripts/loadtest-sfu.sh

  go:run:sfu:
    desc: Run SFU server locally (requires infra:up + dev:keygen)
    deps: [dev:keygen]
    dir: server
    env:
      LISTEN_ADDR: ":8081"
      ED25519_PRIVATE_KEY_FILE: "{{.ROOT_DIR}}/.dev/ed25519.seed"
      STUN_ADDR: "localhost:3478"
    cmds:
      - go run ./cmd/sfu/

  audio:build-native:
    desc: Build miniaudio native shared library
    cmds:
      - |
        if [ "$(uname)" = "Darwin" ]; then
          cc -shared -o native/miniaudio/libminiaudio.dylib native/miniaudio/miniaudio_impl.c native/miniaudio/miniaudio_wrapper.c -framework CoreAudio -framework AudioToolbox -lpthread
        else
          cc -shared -fPIC -o native/miniaudio/libminiaudio.so native/miniaudio/miniaudio_impl.c native/miniaudio/miniaudio_wrapper.c -lpthread -ldl -lm
        fi

  opus:build-native:
    desc: Build libopus native shared library from source (requires native/opus/src submodule)
    cmds:
      - |
        if [ ! -d native/opus/src ]; then
          echo "ERROR: native/opus/src not found. Run: git submodule add https://gitlab.xiph.org/xiph/opus.git native/opus/src" >&2
          exit 1
        fi
        cd native/opus/src
        if [ ! -f configure ]; then
          ./autogen.sh
        fi
        ./configure --prefix="$(pwd)/../install" --enable-shared --disable-static --disable-doc --disable-extra-programs
        make -j$(nproc 2>/dev/null || sysctl -n hw.logicalcpu)
        make install
        if [ "$(uname)" = "Darwin" ]; then
          cp ../install/lib/libopus.dylib ../../native/opus/libopus.dylib 2>/dev/null || \
            cp ../install/lib/libopus.0.dylib ../../native/opus/libopus.dylib
        else
          cp ../install/lib/libopus.so ../../native/opus/libopus.so 2>/dev/null || \
            cp ../install/lib/libopus.so.* ../../native/opus/
        fi

  android:build:
    desc: Build Android APK (net10.0-android, arm64-v8a only)
    cmds:
      - dotnet build {{.ANDROID_APP}} -c {{.CONFIG}} -r android-arm64

  android:deploy:
    desc: Deploy Android APK to connected device via adb
    deps: [android:build]
    cmds:
      - adb install -r src/Seed.Engine.App.Android/bin/{{.CONFIG}}/net10.0-android/android-arm64/com.hmasataka.seed-Signed.apk

  ios:build:
    desc: Build iOS application (net10.0-ios, arm64)
    cmds:
      - dotnet build src/Seed.Engine.App.Ios/Seed.Engine.App.Ios.csproj -c {{.CONFIG}} -r ios-arm64

  parcel:collect-fees:
    desc: Collect monthly maintenance fees for all OWNED parcels (idempotent)
    dir: server
    env:
      DATABASE_URL: postgres://seed:seed@localhost:5432/seed_auth?sslmode=disable
    cmds:
      - go run ./cmd/parcel-maintenance collect

  parcel:reclaim:
    desc: Reclaim DELINQUENT parcels whose grace period (30 days) has expired
    dir: server
    env:
      DATABASE_URL: postgres://seed:seed@localhost:5432/seed_auth?sslmode=disable
    cmds:
      - go run ./cmd/parcel-maintenance reclaim

  worker:build:
    desc: Build Worker project (Release)
    cmds:
      - dotnet build {{.WORKER}} -c {{.CONFIG}}

  worker:run:
    desc: Run Worker project (Release)
    cmds:
      - dotnet run --project {{.WORKER}} -c {{.CONFIG}}

  worker:publish:
    desc: Publish Worker as NativeAOT self-contained binary (Release, macOS arm64)
    cmds:
      - dotnet publish {{.WORKER}} -c {{.CONFIG}} --self-contained -r osx-arm64 -p:PublishAot=true

  go:loadtest:db:
    desc: Run DB transaction throughput load test (100 concurrent connections, >= 1000 tx/sec, p99 < 100ms)
    cmds:
      - ./server/scripts/loadtest-db.sh {{.CLI_ARGS}}

  go:loadtest:world:
    desc: Run shared world load test (10→50→100 clients, 60s each step)
    cmds:
      - bash server/scripts/loadtest-world.sh {{.CLI_ARGS}}

  go:loadtest:lobby:
    desc: Run lobby horizontal scaling load test on a local kind cluster (2 replicas, p99 < 500ms)
    cmds:
      - bash server/scripts/loadtest-lobby.sh {{.CLI_ARGS}}

  docs:build:
    desc: Build UGC API reference site with docfx
    cmds:
      - dotnet build src/Seed.Scripting.Api/Seed.Scripting.Api.csproj -c {{.CONFIG}}
      - docfx docs/docfx/docfx.json

  docs:check:
    desc: Verify docfx build succeeds and all public APIs have XMLdoc (CI gate)
    cmds:
      - dotnet build src/Seed.Scripting.Api/Seed.Scripting.Api.csproj -c {{.CONFIG}} /warnaserror:CS1591
      - task: docs:build
      - test -d docs/docfx/_site

  launcher:build:
    desc: Build the Seed Launcher (.NET MAUI, Windows + macOS only)
    cmds:
      - dotnet workload install maui --skip-sign-check
      - dotnet restore {{.LAUNCHER}}
      - |
        if [ "$(uname)" = "Darwin" ]; then
          dotnet build {{.LAUNCHER}} -c {{.CONFIG}} -f net10.0-maccatalyst
        else
          dotnet build {{.LAUNCHER}} -c {{.CONFIG}} -f net10.0-windows10.0.19041.0
        fi

  launcher:publish:
    desc: Publish the Seed Launcher as a self-contained binary
    cmds:
      - dotnet workload install maui --skip-sign-check
      - dotnet restore {{.LAUNCHER}}
      - |
        if [ "$(uname)" = "Darwin" ]; then
          dotnet publish {{.LAUNCHER}} -c {{.CONFIG}} -f net10.0-maccatalyst -r maccatalyst-arm64 --self-contained -o artifacts/launcher/macos
        else
          dotnet publish {{.LAUNCHER}} -c {{.CONFIG}} -f net10.0-windows10.0.19041.0 -r win-x64 --self-contained -o artifacts/launcher/windows
        fi

  ci:
    desc: Run full CI pipeline (build + test)
    cmds:
      - task: clean
      - task: shader-compile
      - task: build
      - task: test