docker-compose.local.yml

# Run the Railway-equivalent Docker image for every showcase package locally.
# Ports come from shared/local-ports.json; internal port is always 10000 (Railway convention).

x-integration-defaults: &integration-defaults
  env_file: .env
  environment:
    - OPENAI_API_KEY=${OPENAI_API_KEY:-sk-mock}
    - OPENAI_BASE_URL=http://aimock:4010/v1
    - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY:-sk-mock-anthropic}
    - ANTHROPIC_BASE_URL=http://aimock:4010
    - GOOGLE_API_KEY=${GOOGLE_API_KEY:-fake-gemini-key}
    - GOOGLE_GEMINI_BASE_URL=${GOOGLE_GEMINI_BASE_URL-http://aimock:4010}
    - SPRING_AI_OPENAI_BASE_URL=http://aimock:4010
    - AIMOCK_URL=http://aimock:4010
    - GitHubToken=${GitHubToken:-gh-mock-local-dev}
    - LANGGRAPH_HTTP={"configurable_headers":{"include":["x-*"]}}
  depends_on:
    aimock:
      condition: service_healthy
  restart: unless-stopped
  healthcheck:
    test: ["CMD", "curl", "-f", "http://localhost:10000/api/health"]
    interval: 5s
    timeout: 3s
    retries: 5
    start_period: 15s

services:
  ###########################################################################
  # WARNING: DEV ONLY — DO NOT USE FROM CI/TESTS.
  #
  # This aimock service runs WITHOUT `--proxy-only` (see `command:` below): a
  # request with no matching fixture FAILS LOUDLY rather than falling through
  # to a real provider, so a fixture gap surfaces immediately and no real
  # provider tokens are ever billed. The provider URLs in `command:` only tell
  # aimock which provider a request targets; without `--proxy-only` no traffic
  # leaves the container.
  #
  # (Proxy-only mode — where unmatched requests FALL THROUGH to real
  # OpenAI / Anthropic / Gemini via the .env API keys — is the INTERACTIVE
  # fixture-capture workflow and is DANGEROUS in any automated context: a
  # missing fixture would produce a real LLM response, a green check that is a
  # false positive, and a real provider bill. This compose file deliberately
  # does NOT enable it.)
  #
  # Still DEV-ONLY: the volume-mounted fixtures + always-on infra profile are
  # for interactive local work, not a deterministic CI image. Do NOT wire this
  # compose file into CI, e2e suites, or any non-interactive test pipeline.
  ###########################################################################
  aimock:
    # Local aimock so the 17 integration containers can hit a stable LLM mock
    # on the compose network at http://aimock:4010 instead of the prod Railway
    # aimock (which can OOM) or direct-to-OpenAI (which costs).
    #
    # Local vs. production parity: local uses volume mounts (below) so fixture
    # edits take effect on container restart without rebuilding. Production
    # bakes fixtures into the image via showcase/aimock/Dockerfile. When adding
    # a new fixture file, add it to BOTH the volumes list here AND the COPY
    # lines in showcase/aimock/Dockerfile.
    image: ghcr.io/copilotkit/aimock:latest
    container_name: showcase-aimock
    env_file: .env
    ports:
      - "4010:4010"
    profiles: ["infra", "all"]
    restart: unless-stopped
    volumes:
      # Directory mounts — each depth/shared dir is mounted wholesale so new
      # fixture files are picked up without editing this file.
      - ./aimock/shared:/showcase-fixtures/shared:ro
      - ./aimock/d4:/showcase-fixtures/d4:ro
      - ./aimock/d5-recorded:/showcase-fixtures/d5-recorded:ro
      - ./aimock/d6:/showcase-fixtures/d6:ro
    # In test mode aimock must NOT proxy to real providers — unmatched
    # requests should fail so fixture gaps are caught immediately instead
    # of silently falling through to real OpenAI/Anthropic/Gemini.
    # Provider URLs are still declared so aimock knows which provider a
    # request targets, but without --proxy-only no traffic leaves the
    # container.
    command: [
        "--port",
        "4010",
        "--host",
        "0.0.0.0",
        "--provider-openai",
        "https://api.openai.com",
        "--provider-anthropic",
        "https://api.anthropic.com",
        "--provider-gemini",
        "https://generativelanguage.googleapis.com",
        # Natural-feel streaming so demos look like a real LLM rather than
        # an instant dump. 8 chars/chunk × 60 ms = ~130 chars/sec ≈ 30-40
        # tokens/sec, the lower end of Gemini 2.5-flash's real streaming
        # rate. Total wall-clock for a 500-char response is ~4s, well
        # inside the 30s default test timeout. Tune here if specific
        # demos feel sluggish; CI doc-tests intentionally don't slow.
        "--chunk-size",
        "8",
        "--latency",
        "60",
        # Directory-based fixture loading (one --fixtures per directory)
        "--fixtures",
        "/showcase-fixtures/shared",
        "--fixtures",
        "/showcase-fixtures/d4",
        "--fixtures",
        "/showcase-fixtures/d5-recorded",
        "--fixtures",
        "/showcase-fixtures/d6",
        "--validate-on-load",
      ]
    healthcheck:
      test:
        [
          "CMD",
          "node",
          "-e",
          "fetch('http://localhost:4010/health').then(r=>{if(!r.ok)process.exit(1)}).catch(()=>process.exit(1))",
        ]
      interval: 5s
      timeout: 3s
      retries: 5
      start_period: 10s

  pocketbase:
    build: ./pocketbase
    image: showcase-pocketbase:local
    container_name: showcase-pocketbase
    environment:
      - POCKETBASE_SUPERUSER_EMAIL=admin@example.com
      - POCKETBASE_SUPERUSER_PASSWORD=showcase-local-dev
    ports:
      - "8090:8090"
    volumes:
      - showcase-pb-data:/pb_data
    profiles: ["infra", "all"]
    restart: unless-stopped
    healthcheck:
      test:
        ["CMD", "wget", "-q", "--spider", "http://localhost:8090/api/health"]
      interval: 5s
      timeout: 3s
      retries: 5
      start_period: 10s

  dashboard:
    build:
      context: ../
      dockerfile: showcase/shell-dashboard/Dockerfile
      args:
        # PocketBase URL the browser hits at runtime — pinned to the host
        # binding so the user's browser (not the container) can resolve it.
        NEXT_PUBLIC_POCKETBASE_URL: http://localhost:8090
        # Showcase shell URL the dashboard links to for Demo / Code /
        # docs-shell jumps. Points at the langgraph-python integration's
        # host port for now (no shared "shell" service in the local stack).
        NEXT_PUBLIC_SHELL_URL: http://localhost:3100
        # Ops proxy target for the dashboard's /api/ops/* Route Handler
        # (shell-dashboard/src/app/api/ops/[...path]/route.ts), which
        # forwards /api/ops/probes -> ${OPS_BASE_URL}/api/probes. It MUST
        # point at the showcase-harness HTTP origin (the service that serves
        # /api/probes), reached over the compose network by its container
        # name on the harness's internal port 8080 (harness/Dockerfile
        # EXPOSEs 8080; orchestrator.ts binds PORT ?? 8080). Mirrors staging,
        # where the dashboard's OPS_BASE_URL points at the harness origin.
        # Run the harness on this compose network (container_name:
        # showcase-harness) for the Ops tab's live-probe grid to resolve;
        # without it the proxy returns 502 (unreachable upstream) rather than
        # the previous self-referential 500. NOTE: OPS_BASE_URL is read at
        # REQUEST time by the Route Handler, so it does not need to resolve
        # at build time — this build arg only seeds the runtime default.
        OPS_BASE_URL: http://showcase-harness:8080
    image: showcase-dashboard:local
    container_name: showcase-dashboard
    environment:
      # The dashboard injects POCKETBASE_URL into window.__SHOWCASE_CONFIG__ and
      # the live-status subscription fetches it FROM THE BROWSER (the host),
      # which cannot resolve the compose-internal hostname `pocketbase`. Use the
      # host-published binding so the browser-side live grid actually loads (this
      # matches the NEXT_PUBLIC_POCKETBASE_URL build arg). Mirrors staging, where
      # this points at PocketBase's public domain, not its private hostname.
      - POCKETBASE_URL=http://localhost:8090
      - SHOWCASE_LOCAL=1
    ports:
      - "3200:10000"
    depends_on:
      pocketbase:
        condition: service_healthy
    profiles: ["infra", "all"]
    restart: unless-stopped
    healthcheck:
      test:
        [
          "CMD",
          "node",
          "-e",
          "fetch('http://localhost:10000/').then(r=>{if(!r.ok)process.exit(1)}).catch(()=>process.exit(1))",
        ]
      interval: 5s
      timeout: 3s
      retries: 5
      start_period: 10s

  ###########################################################################
  # POOL FLEET — control-plane + worker(s), ONE image, role-selected by env.
  #
  # PARITY GOAL: the local docker stack runs the SAME topology as prod. At
  # N=1 that is a control-plane container PLUS one worker container talking
  # over the same protocol prod uses — NOT an in-process pool shortcut. The
  # only thing that changes between local and staging/prod is
  # HARNESS_POOL_COUNT (local=1, staging/prod=2) and the number of worker
  # replicas brought up; the images, env contract, and wiring are identical.
  #
  # ONE IMAGE, TWO ROLES: both services build/run showcase/harness/Dockerfile.
  # The role is selected at runtime via HARNESS_ROLE:
  #   - control-plane: scheduler/queue/aggregator + HTTP API (/api/probes,
  #     /health). Runs NO Chromium.
  #   - worker:        runs the BrowserPool (Chromium) and pulls work from the
  #     PocketBase-backed queue. Reachable on the private compose network.
  #
  # ROLE-SELECT DISPATCH (live): the harness entrypoint branches on
  # HARNESS_ROLE — bootFleet dispatches to the control-plane or worker role
  # based on the env value, so both services boot the correct role purely
  # from the env below with no per-service `command:` override. This compose
  # PASSES HARNESS_ROLE / HARNESS_POOL_COUNT and wires both services for
  # their roles; no compose-level bypass is needed.
  ###########################################################################
  harness-control-plane:
    build:
      context: ../
      dockerfile: showcase/harness/Dockerfile
    image: showcase-harness:local
    # container_name preserved as `showcase-harness` so the dashboard's
    # OPS_BASE_URL (http://showcase-harness:8080, see the `dashboard` build
    # arg above) resolves the control-plane's HTTP origin over the compose
    # network — the control-plane is the service that serves /api/probes.
    container_name: showcase-harness
    env_file: .env
    environment:
      # Role-select contract (consumed by the image entrypoint's bootFleet
      # role dispatch; see the header note above).
      - HARNESS_ROLE=control-plane
      # Fleet size driver. Local=1 worker; staging/prod set this to 2 (and
      # bring up matching worker replicas). The control-plane reads this to
      # know how many workers to expect in the pool.
      - HARNESS_POOL_COUNT=${HARNESS_POOL_COUNT:-1}
      # Control-plane needs PocketBase (the work queue + status store) but
      # runs no Chromium, so it does not need demo reachability for browsing.
      - POCKETBASE_URL=http://pocketbase:8090
      - POCKETBASE_SUPERUSER_EMAIL=admin@example.com
      - POCKETBASE_SUPERUSER_PASSWORD=showcase-local-dev
      # LOCAL SERVICE CATALOG (parity seam). The control-plane enumerates the
      # showcase service set via the railway-services discovery source; locally
      # there are no Railway creds, so LOCAL_SERVICES_JSON injects the IDENTICAL
      # RailwayServiceInfo[] shape (only the URLs differ — local container host
      # vs Railway public domain). Without it the enumerator queries Railway and
      # the local N=1 run enqueues nothing. The demos[] is load-bearing: it
      # drives the d6 feature matrix (demosToFeatureTypes). Scoped here to the
      # langgraph-python demo's agentic-chat cell for a fast N=1 ramp; add
      # entries to widen the local fleet.
      - >-
        LOCAL_SERVICES_JSON=[{"name":"showcase-langgraph-python","publicUrl":"http://langgraph-python:10000","demos":["agentic-chat"]}]
      # Producer cron cadence. Default is hourly-at-:40 (prod rhythm). Locally we
      # drive the SAME enqueue path every minute so an N=1 run doesn't wait up to
      # an hour for the first tick.
      - FLEET_PRODUCER_CRON=* * * * *
      # Heartbeat staleness window fleet-health uses to declare a worker dead and
      # reclaim its in-flight jobs (REQ-B). Defaults to 180s (prod); locally we
      # shrink it so a killed worker is detected in seconds during a demo/test.
      - WORKER_STALE_AFTER_MS=${WORKER_STALE_AFTER_MS:-20000}
      # LLM mock wiring (parity with the integration defaults) so any
      # control-plane-side probe that touches an LLM hits aimock, not a real
      # provider.
      - OPENAI_BASE_URL=http://aimock:4010/v1
      - ANTHROPIC_BASE_URL=http://aimock:4010
      - AIMOCK_URL=http://aimock:4010
      - PORT=8080
    ports:
      # Host-exposed so the dashboard's /api/ops/* proxy and local curls can
      # reach the control-plane HTTP API. 8081 host → 8080 container (8080 is
      # the harness/Dockerfile EXPOSE + orchestrator default).
      - "8081:8080"
    depends_on:
      aimock:
        condition: service_healthy
      pocketbase:
        condition: service_healthy
    profiles: ["infra", "all"]
    restart: unless-stopped
    healthcheck:
      test:
        [
          "CMD",
          "node",
          "-e",
          "require('http').get('http://127.0.0.1:8080/health',r=>process.exit(r.statusCode>=200&&r.statusCode<300?0:1)).on('error',()=>process.exit(1))",
        ]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s

  harness-pool-worker:
    build:
      context: ../
      dockerfile: showcase/harness/Dockerfile
    image: showcase-harness:local
    # NO fixed container_name: the worker is the scalable unit of the fleet
    # (`--scale harness-pool-worker=N`, N from HARNESS_POOL_COUNT). A fixed
    # container_name would make Docker refuse to create the 2nd+ replica
    # ("Conflict. The container name is already in use"). Compose auto-names
    # replicas `<project>-harness-pool-worker-1`, `-2`, … instead.
    env_file: .env
    environment:
      # Same image, worker role. Runs the BrowserPool (Chromium) and pulls
      # work from the PB-backed queue — the pull-queue model means the worker
      # mainly needs PocketBase + demo-network reachability, not an inbound
      # control-plane connection.
      - HARNESS_ROLE=worker
      - HARNESS_POOL_COUNT=${HARNESS_POOL_COUNT:-1}
      - POCKETBASE_URL=http://pocketbase:8090
      - POCKETBASE_SUPERUSER_EMAIL=admin@example.com
      - POCKETBASE_SUPERUSER_PASSWORD=showcase-local-dev
      # Self-register heartbeat cadence. Defaults to 75s (prod); locally we beat
      # faster so fleet-health's (shrunk) staleness window is meaningful when a
      # worker is killed mid-run during a demo/test (REQ-B).
      - WORKER_HEARTBEAT_MS=${WORKER_HEARTBEAT_MS:-5000}
      # The worker drives Chromium against the demo services and any LLM
      # calls those demos make resolve through aimock on the compose network.
      - OPENAI_BASE_URL=http://aimock:4010/v1
      - ANTHROPIC_BASE_URL=http://aimock:4010
      - AIMOCK_URL=http://aimock:4010
      - PORT=8080
    depends_on:
      aimock:
        condition: service_healthy
      pocketbase:
        condition: service_healthy
    profiles: ["infra", "all"]
    restart: unless-stopped
    healthcheck:
      test:
        [
          "CMD",
          "node",
          "-e",
          "require('http').get('http://127.0.0.1:8080/health',r=>process.exit(r.statusCode>=200&&r.statusCode<300?0:1)).on('error',()=>process.exit(1))",
        ]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s

  langgraph-python:
    <<: *integration-defaults
    build: ./integrations/langgraph-python
    image: showcase-langgraph-python:local
    container_name: showcase-langgraph-python
    ports:
      - "3100:10000"
    profiles: ["langgraph-python", "all"]
    volumes:
      - ./integrations/langgraph-python/src:/app/src

  langgraph-typescript:
    <<: *integration-defaults
    build: ./integrations/langgraph-typescript
    image: showcase-langgraph-typescript:local
    container_name: showcase-langgraph-typescript
    ports:
      - "3101:10000"
    profiles: ["langgraph-typescript", "all"]
    volumes:
      - ./integrations/langgraph-typescript/src:/app/src
      # Preserve the agent's node_modules from the Docker image.  The bind
      # mount above overlays the host's src/ (no node_modules) on top of the
      # container's /app/src, which clobbers src/agent/node_modules installed
      # during the build.  This anonymous volume pins the image's copy so
      # `node --import tsx` can resolve tsx at runtime.
      - /app/src/agent/node_modules

  langgraph-fastapi:
    <<: *integration-defaults
    build: ./integrations/langgraph-fastapi
    image: showcase-langgraph-fastapi:local
    container_name: showcase-langgraph-fastapi
    ports:
      - "3102:10000"
    profiles: ["langgraph-fastapi", "all"]
    volumes:
      - ./integrations/langgraph-fastapi/src:/app/src

  google-adk:
    <<: *integration-defaults
    build: ./integrations/google-adk
    image: showcase-google-adk:local
    container_name: showcase-google-adk
    ports:
      - "3103:10000"
    profiles: ["google-adk", "all"]
    volumes:
      - ./integrations/google-adk/src:/app/src

  mastra:
    <<: *integration-defaults
    build: ./integrations/mastra
    image: showcase-mastra:local
    container_name: showcase-mastra
    ports:
      - "3104:10000"
    profiles: ["mastra", "all"]
    volumes:
      - ./integrations/mastra/src:/app/src

  crewai-crews:
    <<: *integration-defaults
    build: ./integrations/crewai-crews
    image: showcase-crewai-crews:local
    container_name: showcase-crewai-crews
    ports:
      - "3105:10000"
    profiles: ["crewai-crews", "all"]
    volumes:
      - ./integrations/crewai-crews/src:/app/src

  pydantic-ai:
    <<: *integration-defaults
    build: ./integrations/pydantic-ai
    image: showcase-pydantic-ai:local
    container_name: showcase-pydantic-ai
    ports:
      - "3106:10000"
    profiles: ["pydantic-ai", "all"]
    volumes:
      - ./integrations/pydantic-ai/src:/app/src

  claude-sdk-python:
    <<: *integration-defaults
    build: ./integrations/claude-sdk-python
    image: showcase-claude-sdk-python:local
    container_name: showcase-claude-sdk-python
    ports:
      - "3107:10000"
    profiles: ["claude-sdk-python", "all"]
    volumes:
      - ./integrations/claude-sdk-python/src:/app/src

  claude-sdk-typescript:
    <<: *integration-defaults
    build: ./integrations/claude-sdk-typescript
    image: showcase-claude-sdk-typescript:local
    container_name: showcase-claude-sdk-typescript
    ports:
      - "3108:10000"
    profiles: ["claude-sdk-typescript", "all"]
    volumes:
      - ./integrations/claude-sdk-typescript/src:/app/src

  agno:
    <<: *integration-defaults
    build: ./integrations/agno
    image: showcase-agno:local
    container_name: showcase-agno
    ports:
      - "3109:10000"
    profiles: ["agno", "all"]
    volumes:
      - ./integrations/agno/src:/app/src

  ag2:
    <<: *integration-defaults
    build: ./integrations/ag2
    image: showcase-ag2:local
    container_name: showcase-ag2
    ports:
      - "3110:10000"
    profiles: ["ag2", "all"]
    volumes:
      - ./integrations/ag2/src:/app/src

  llamaindex:
    <<: *integration-defaults
    build: ./integrations/llamaindex
    image: showcase-llamaindex:local
    container_name: showcase-llamaindex
    ports:
      - "3111:10000"
    profiles: ["llamaindex", "all"]
    volumes:
      - ./integrations/llamaindex/src:/app/src

  strands:
    <<: *integration-defaults
    build: ./integrations/strands
    image: showcase-strands:local
    container_name: showcase-strands
    ports:
      - "3112:10000"
    profiles: ["strands", "all"]
    volumes:
      - ./integrations/strands/src:/app/src

  langroid:
    <<: *integration-defaults
    build: ./integrations/langroid
    image: showcase-langroid:local
    container_name: showcase-langroid
    ports:
      - "3113:10000"
    profiles: ["langroid", "all"]
    volumes:
      - ./integrations/langroid/src:/app/src

  ms-agent-python:
    <<: *integration-defaults
    build: ./integrations/ms-agent-python
    image: showcase-ms-agent-python:local
    container_name: showcase-ms-agent-python
    ports:
      - "3114:10000"
    profiles: ["ms-agent-python", "all"]
    volumes:
      - ./integrations/ms-agent-python/src:/app/src

  ms-agent-dotnet:
    <<: *integration-defaults
    build: ./integrations/ms-agent-dotnet
    image: showcase-ms-agent-dotnet:local
    container_name: showcase-ms-agent-dotnet
    ports:
      - "3115:10000"
    profiles: ["ms-agent-dotnet", "all"]
    volumes:
      - ./integrations/ms-agent-dotnet/src:/app/src

  ms-agent-harness-dotnet:
    <<: *integration-defaults
    build: ./integrations/ms-agent-harness-dotnet
    image: showcase-ms-agent-harness-dotnet:local
    container_name: showcase-ms-agent-harness-dotnet
    ports:
      - "3118:10000"
    profiles: ["ms-agent-harness-dotnet", "all"]
    volumes:
      - ./integrations/ms-agent-harness-dotnet/src:/app/src

  spring-ai:
    <<: *integration-defaults
    build: ./integrations/spring-ai
    image: showcase-spring-ai:local
    container_name: showcase-spring-ai
    ports:
      - "3116:10000"
    profiles: ["spring-ai", "all"]
    volumes:
      - ./integrations/spring-ai/src:/app/src

  built-in-agent:
    <<: *integration-defaults
    build: ./integrations/built-in-agent
    image: showcase-built-in-agent:local
    container_name: showcase-built-in-agent
    ports:
      - "3117:10000"
    profiles: ["built-in-agent", "all"]
    volumes:
      - ./integrations/built-in-agent/src:/app/src

volumes:
  showcase-pb-data: