docker-compose.yml

name: byte-v-forge

x-n8n-environment: &n8n-environment
  DB_TYPE: postgresdb
  DB_POSTGRESDB_HOST: n8n-postgres
  DB_POSTGRESDB_PORT: "5432"
  DB_POSTGRESDB_DATABASE: n8n
  DB_POSTGRESDB_USER: n8n
  DB_POSTGRESDB_PASSWORD: ${N8N_POSTGRES_PASSWORD:-byte_v_forge_n8n}
  DB_TABLE_PREFIX: n8n_
  EXECUTIONS_MODE: queue
  QUEUE_BULL_REDIS_HOST: n8n-redis
  QUEUE_BULL_REDIS_PORT: "6379"
  N8N_ENCRYPTION_KEY: ${N8N_ENCRYPTION_KEY:-byte_v_forge_n8n_encryption_key_change_me_32}
  N8N_EDITOR_BASE_URL: ${N8N_PUBLIC_URL:-http://localhost:5678}
  WEBHOOK_URL: ${WEBHOOK_URL:-http://localhost:8081/}
  N8N_PROXY_HOPS: "1"
  N8N_ENFORCE_SETTINGS_FILE_PERMISSIONS: "true"
  N8N_SECURE_COOKIE: "false"
  N8N_DIAGNOSTICS_ENABLED: "false"
  N8N_VERSION_NOTIFICATIONS_ENABLED: "false"
  N8N_TEMPLATES_ENABLED: "false"
  N8N_BLOCK_ENV_ACCESS_IN_NODE: "false"
  GPT_ACTION_API_BASE_URL: ${GPT_ACTION_API_BASE_URL:-http://gpt-service:8080/api/gpt/actions}
  GOPAY_ACTION_API_BASE_URL: ${GOPAY_ACTION_API_BASE_URL:-http://gopay-app:8080/api/gopay/actions}
  GOPAY_API_BASE_URL: ${GOPAY_API_BASE_URL:-http://gopay-app:8080/api/gopay}
  WA_ACTION_API_BASE_URL: ${WA_ACTION_API_BASE_URL:-http://wa-app-service:8080/api/wa/actions}
  WA_API_BASE_URL: ${WA_API_BASE_URL:-http://wa-app-service:8080/api/wa}
  SMS_API_BASE_URL: ${SMS_API_BASE_URL:-http://sms-service:8080/api/sms}
  PROXY_RUNTIME_API_BASE_URL: ${PROXY_RUNTIME_API_BASE_URL:-http://proxy-runtime:8080/api}
  WORKFLOW_RUNTIME_API_BASE_URL: ${WORKFLOW_RUNTIME_API_BASE_URL:-http://workflow-runtime:8080/api/workflow-runtime}
  WORKFLOW_RUNTIME_STEP_UPDATE_TOKEN: ${WORKFLOW_RUNTIME_STEP_UPDATE_TOKEN:-byte_v_forge_workflow_runtime_step_update_token_change_me_32}
  N8N_INSTANCE_OWNER_MANAGED_BY_ENV: "true"
  N8N_INSTANCE_OWNER_EMAIL: ${N8N_INSTANCE_OWNER_EMAIL:-byte-v-forge@byte-v-forge.local}
  N8N_INSTANCE_OWNER_FIRST_NAME: ${N8N_INSTANCE_OWNER_FIRST_NAME:-Byte}
  N8N_INSTANCE_OWNER_LAST_NAME: ${N8N_INSTANCE_OWNER_LAST_NAME:-Forge}
  N8N_INSTANCE_OWNER_PASSWORD_HASH: ${N8N_INSTANCE_OWNER_PASSWORD_HASH:-$$2b$$10$$j6/JtPvAKtGGGMVOTqIQrOaq3b0.fQyK46ZWQdNN4E4e496n5ToYq}

x-n8n-runner-environment: &n8n-runner-environment
  N8N_RUNNERS_MODE: external
  N8N_RUNNERS_BROKER_LISTEN_ADDRESS: 0.0.0.0
  N8N_RUNNERS_AUTH_TOKEN: ${N8N_RUNNERS_AUTH_TOKEN:-byte_v_forge_n8n_runner_auth_token_change_me_32}
  N8N_NATIVE_PYTHON_RUNNER: "true"

x-n8n-task-runner-environment: &n8n-task-runner-environment
  N8N_RUNNERS_TASK_BROKER_URI: http://n8n-worker:5679
  N8N_RUNNERS_AUTH_TOKEN: ${N8N_RUNNERS_AUTH_TOKEN:-byte_v_forge_n8n_runner_auth_token_change_me_32}
  N8N_RUNNERS_AUTO_SHUTDOWN_TIMEOUT: "0"
  N8N_RUNNERS_MAX_CONCURRENCY: "5"
  N8N_RUNNERS_LAUNCHER_HEALTH_CHECK_PORT: "5680"
  N8N_BLOCK_ENV_ACCESS_IN_NODE: "false"
  GPT_ACTION_API_BASE_URL: ${GPT_ACTION_API_BASE_URL:-http://gpt-service:8080/api/gpt/actions}
  GOPAY_ACTION_API_BASE_URL: ${GOPAY_ACTION_API_BASE_URL:-http://gopay-app:8080/api/gopay/actions}
  GOPAY_API_BASE_URL: ${GOPAY_API_BASE_URL:-http://gopay-app:8080/api/gopay}
  WA_ACTION_API_BASE_URL: ${WA_ACTION_API_BASE_URL:-http://wa-app-service:8080/api/wa/actions}
  WA_API_BASE_URL: ${WA_API_BASE_URL:-http://wa-app-service:8080/api/wa}
  SMS_API_BASE_URL: ${SMS_API_BASE_URL:-http://sms-service:8080/api/sms}
  PROXY_RUNTIME_API_BASE_URL: ${PROXY_RUNTIME_API_BASE_URL:-http://proxy-runtime:8080/api}
  WORKFLOW_RUNTIME_API_BASE_URL: ${WORKFLOW_RUNTIME_API_BASE_URL:-http://workflow-runtime:8080/api/workflow-runtime}
  WORKFLOW_RUNTIME_STEP_UPDATE_TOKEN: ${WORKFLOW_RUNTIME_STEP_UPDATE_TOKEN:-byte_v_forge_workflow_runtime_step_update_token_change_me_32}

services:
  postgres:
    image: docker.m.daocloud.io/library/postgres:15-alpine
    environment:
      - POSTGRES_USER=${POSTGRES_USER:-byte_v_forge}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-byte_v_forge}
      - POSTGRES_DB=${POSTGRES_DB:-byte_v_forge}
    ports:
      - "${POSTGRES_PORT:-5432}:5432"
    volumes:
      - pgdata:/var/lib/postgresql/data
    restart: always

  traefik:
    image: docker.m.daocloud.io/library/traefik:v3.7.1
    command:
      - --api=true
      - --api.insecure=true
      - --ping=true
      - --providers.docker=true
      - --providers.docker.exposedbydefault=false
      - --entrypoints.web.address=:80
      - --entrypoints.webhook.address=:8081
      - --entrypoints.internal.address=:9000
    ports:
      - "${WEBUI_PORT:-8080}:80"
      - "${WEBHOOK_PORT:-8081}:8081"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
    healthcheck:
      test: ["CMD", "traefik", "healthcheck", "--ping"]
      interval: 10s
      timeout: 3s
      retries: 3
    restart: always

  n8n-redis:
    image: docker.m.daocloud.io/library/redis:7-alpine
    command: ["redis-server", "--save", "", "--appendonly", "no"]
    restart: always

  n8n-postgres:
    image: docker.m.daocloud.io/library/postgres:15-alpine
    environment:
      - POSTGRES_USER=n8n
      - POSTGRES_PASSWORD=${N8N_POSTGRES_PASSWORD:-byte_v_forge_n8n}
      - POSTGRES_DB=n8n
      - PGDATA=/var/lib/postgresql/data/pgdata
    volumes:
      - n8n_pgdata:/var/lib/postgresql/data
    restart: always

  platform-redis:
    image: docker.m.daocloud.io/library/redis:7-alpine
    command: ["redis-server", "--save", "", "--appendonly", "no"]
    restart: always

  openai-sso-lite:
    build:
      context: ../openai-sso-lite
      dockerfile: Dockerfile
    ports:
      - "127.0.0.1:${OPENAI_SSO_LITE_HTTP_PORT:-8091}:8080"
    environment:
      - SSO_HTTP_ADDR=:8080
      - SSO_ISSUER=${OPENAI_SSO_LITE_ISSUER:-https://sso.example.invalid}
      - SSO_SQLITE_PATH=/var/lib/openai-sso-lite/openai-sso-lite.db
      - SSO_CLIENT_ID=openai-chatgpt
      - SSO_CLIENT_SECRET=${OPENAI_SSO_LITE_CLIENT_SECRET:-change-me-at-least-32-characters}
      - SSO_ADMIN_TOKEN=${OPENAI_SSO_LITE_ADMIN_TOKEN:-change-me-at-least-32-characters}
      - SSO_RSA_PRIVATE_KEY_B64=${OPENAI_SSO_LITE_RSA_PRIVATE_KEY_B64:-}
      - SSO_ALLOWED_REDIRECT_URI_PREFIXES=${OPENAI_SSO_LITE_ALLOWED_REDIRECT_URI_PREFIXES:-https://external.auth.openai.com/}
    volumes:
      - openai_sso_lite_data:/var/lib/openai-sso-lite
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.openai-sso-lite.rule=Host(`openai-sso-lite.byte-v-forge.localhost`) || Host(`sso.uizsdas.bond`)"
      - "traefik.http.routers.openai-sso-lite.entrypoints=web"
      - "traefik.http.routers.openai-sso-lite.priority=600"
      - "traefik.http.routers.openai-sso-lite.service=openai-sso-lite"
      - "traefik.http.services.openai-sso-lite.loadbalancer.server.port=8080"
      - "traefik.http.services.openai-sso-lite.loadbalancer.healthcheck.path=/readyz"
    restart: always

  openai-sso-discord-bot:
    build:
      context: ../openai-sso-discord-bot
      dockerfile: Dockerfile
    ports:
      - "127.0.0.1:${OPENAI_SSO_DISCORD_BOT_HTTP_PORT:-8092}:8080"
    environment:
      - DISCORD_BOT_TOKEN=${OPENAI_SSO_DISCORD_BOT_TOKEN:-}
      - DISCORD_APPLICATION_ID=${OPENAI_SSO_DISCORD_BOT_APPLICATION_ID:-}
      - DISCORD_GUILD_ID=${OPENAI_SSO_DISCORD_BOT_GUILD_ID:-}
      - DISCORD_SSO_PROXY_URL=${OPENAI_SSO_DISCORD_BOT_PROXY_URL:-}
      - DISCORD_SSO_HTTP_ADDR=:8080
      - DISCORD_SSO_SQLITE_PATH=/var/lib/openai-sso-discord-bot/openai-sso-discord-bot.db
      - SSO_ISSUER=${OPENAI_SSO_LITE_ISSUER:-https://sso.example.invalid}
      - SSO_ADMIN_TOKEN=${OPENAI_SSO_LITE_ADMIN_TOKEN:-change-me-at-least-32-characters}
      - SSO_EMAIL_DOMAIN=${OPENAI_SSO_DISCORD_BOT_EMAIL_DOMAIN:-workspace.example.invalid}
    volumes:
      - openai_sso_discord_bot_data:/var/lib/openai-sso-discord-bot
    restart: always

  team-5000:
    build:
      context: ../team-5000
      dockerfile: Dockerfile
    ports:
      - "127.0.0.1:${TEAM5000_HTTP_PORT:-8093}:8080"
    environment:
      - TEAM5000_HTTP_ADDR=:8080
      - TEAM5000_DOMAIN=${TEAM5000_DOMAIN:-workspace.example.invalid}
      - TEAM5000_SSO_ISSUER=${OPENAI_SSO_LITE_ISSUER:-https://sso.example.invalid}
      - TEAM5000_SSO_ADMIN_TOKEN=${OPENAI_SSO_LITE_ADMIN_TOKEN:-change-me-at-least-32-characters}
      - TEAM5000_WORKSPACE_ID=${TEAM5000_WORKSPACE_ID:-}
      - TEAM5000_PROXY_URL=${TEAM5000_PROXY_URL:-socks5://proxy-runtime:10810}
      - TEAM5000_MODEL=${TEAM5000_MODEL:-gpt-5.5}
      - TEAM5000_MAX_PARENT_HELLO=${TEAM5000_MAX_PARENT_HELLO:-0}
      - TEAM5000_OUTPUT=/var/lib/team-5000/sessions
      - TEAM5000_REPORT=/var/lib/team-5000/logs/team5000-cycle.jsonl
    volumes:
      - team_5000_data:/var/lib/team-5000
    depends_on:
      - proxy-runtime
      - openai-sso-lite
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.team-5000.rule=PathPrefix(`/api/team-5000`)"
      - "traefik.http.routers.team-5000.entrypoints=web"
      - "traefik.http.routers.team-5000.priority=100"
      - "traefik.http.routers.team-5000.service=team-5000"
      - "traefik.http.services.team-5000.loadbalancer.server.port=8080"
      - "traefik.http.services.team-5000.loadbalancer.healthcheck.path=/healthz"
    restart: unless-stopped

  platform-nats:
    image: docker.m.daocloud.io/library/nats:2.14.1
    command: ["-js", "-sd", "/data", "-m", "8222"]
    ports:
      - "127.0.0.1:${PLATFORM_NATS_PORT:-4222}:4222"
      - "127.0.0.1:${PLATFORM_NATS_MONITOR_PORT:-8222}:8222"
    volumes:
      - nats_data:/data
    restart: always

  platform-nats-init:
    image: docker.m.daocloud.io/natsio/nats-box:0.18.0
    environment:
      - PLATFORM_EVENT_STREAM_NAME=${PLATFORM_EVENT_STREAM_NAME:-BYTE_V_FORGE_EVENTS}
    command:
      - sh
      - -ceu
      - |
        nats --server "$${PLATFORM_NATS_URL}" stream add "$${PLATFORM_EVENT_STREAM_NAME}" --subjects 'byte.v.forge.>' --storage file --retention limits --dupe-window 10m --defaults \
          || nats --server "$${PLATFORM_NATS_URL}" stream edit "$${PLATFORM_EVENT_STREAM_NAME}" --subjects 'byte.v.forge.>' --storage file --retention limits --dupe-window 10m --defaults
    depends_on:
      - platform-nats

  platform-db-migrations:
    image: docker.m.daocloud.io/library/postgres:15-alpine
    environment:
      - PGHOST=postgres
      - PGPORT=5432
      - PGDATABASE=${POSTGRES_DB:-byte_v_forge}
      - PGUSER=${POSTGRES_USER:-byte_v_forge}
      - PGPASSWORD=${POSTGRES_PASSWORD:-byte_v_forge}
    volumes:
      - ../sms/migrations:/migrations/sms:ro
      - ../wa-app/migrations:/migrations/wa-app:ro
      - ../mailbox/services/mailbox-api/migrations:/migrations/mailbox:ro
      - ../gpt/orchestrator/migrations:/migrations/gpt-orchestrator:ro
      - ../gpt/gpt-account/migrations:/migrations/gpt-account:ro
    command:
      - sh
      - -ceu
      - |
        for dir in /migrations/gpt-account /migrations/gpt-orchestrator /migrations/mailbox /migrations/sms /migrations/wa-app; do
          for file in "$${dir}"/*.sql; do
            [ -e "$${file}" ] || continue
            psql -v ON_ERROR_STOP=1 -f "$${file}"
          done
        done
    depends_on:
      - postgres

  n8n-main:
    image: docker.n8n.io/n8nio/n8n:2.21.7
    ports:
      - "127.0.0.1:${N8N_EDITOR_PORT:-5678}:5678"
    environment:
      <<: *n8n-environment
      OFFLOAD_MANUAL_EXECUTIONS_TO_WORKERS: "true"
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      n8n-postgres:
        condition: service_started
      n8n-redis:
        condition: service_started
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.n8n-editor.rule=Host(`n8n.byte-v-forge.internal`)"
      - "traefik.http.routers.n8n-editor.entrypoints=web"
      - "traefik.http.routers.n8n-editor.priority=200"
      - "traefik.http.routers.n8n-editor.service=n8n-editor"
      - "traefik.http.services.n8n-editor.loadbalancer.server.port=5678"
      - "traefik.http.services.n8n-editor.loadbalancer.healthcheck.path=/healthz"
    restart: always

  n8n-worker:
    image: docker.n8n.io/n8nio/n8n:2.21.7
    command: ["worker", "--concurrency=5"]
    environment:
      <<: [*n8n-environment, *n8n-runner-environment]
      QUEUE_HEALTH_CHECK_ACTIVE: "true"
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      n8n-postgres:
        condition: service_started
      n8n-redis:
        condition: service_started
    restart: always


  n8n-task-runner:
    image: docker.io/n8nio/runners:2.21.7
    environment: *n8n-task-runner-environment
    depends_on:
      n8n-worker:
        condition: service_started
    restart: always

  n8n-workflow-import:
    image: docker.n8n.io/n8nio/n8n:2.21.7
    environment: *n8n-environment
    volumes:
      - n8n_data:/home/node/.n8n
      - ../gpt/workflows/n8n:/workflow-sources/public:ro
      - ../gpt-private/workflows/n8n:/workflow-sources/private:ro
      - ../gopay-app/workflows/n8n:/workflow-sources/gopay:ro
      - ./iac/helm/byte-v-forge/files/n8n-sync-workflow-folders.js:/opt/byte-v-forge/sync-workflow-folders.js:ro
    command:
      - sh
      - -ceu
      - |
        rm -rf /tmp/n8n-workflows
        mkdir -p /tmp/n8n-workflows
        for source in /workflow-sources/public /workflow-sources/private /workflow-sources/gopay; do
          [ -d "$$source" ] && cp -R "$$source"/. /tmp/n8n-workflows/
        done
        workflow_files() {
          find -L /tmp/n8n-workflows -path '*/..*' -prune -o -type f -name '*.workflow.json' -print | sort
        }
        for attempt in $$(seq 1 60); do
          if workflow_files | while read -r file; do
            n8n import:workflow --input="$$file" --activeState=fromJson
          done; then
            workflow_files | while read -r file; do
              id="$$(node -e "console.log(require(process.argv[1]).id)" "$$file")"
              [ -n "$$id" ] && n8n publish:workflow --id="$$id"
            done
            (cd /usr/local/lib/node_modules/n8n && node /opt/byte-v-forge/sync-workflow-folders.js /tmp/n8n-workflows)
            exit 0
          fi
          sleep 5
        done
        exit 1
    depends_on:
      n8n-main:
        condition: service_started
      n8n-postgres:
        condition: service_started
      n8n-redis:
        condition: service_started
    restart: "no"

  n8n-webhook:
    image: docker.n8n.io/n8nio/n8n:2.21.7
    command: ["webhook"]
    environment: *n8n-environment
    volumes:
      - n8n_data:/home/node/.n8n
    depends_on:
      n8n-postgres:
        condition: service_started
      n8n-redis:
        condition: service_started
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.n8n-webhook.rule=PathPrefix(`/webhook`) || PathPrefix(`/webhook-test`)"
      - "traefik.http.routers.n8n-webhook.entrypoints=webhook"
      - "traefik.http.routers.n8n-webhook.priority=200"
      - "traefik.http.routers.n8n-webhook.service=n8n-webhook"
      - "traefik.http.services.n8n-webhook.loadbalancer.server.port=5678"
      - "traefik.http.services.n8n-webhook.loadbalancer.healthcheck.path=/healthz"
    restart: always


  proxy-runtime:
    build:
      context: ../proxy-runtime
      dockerfile: Dockerfile
    ports:
      - "127.0.0.1:${PROXY_RUNTIME_HTTP_PORT:-8083}:8080"
      - "${PROXY_RUNTIME_GATEWAY_PORT:-30081}:10810"
    environment:
      - PROXY_RUNTIME_ADDR=:8080
      - PROXY_RUNTIME_POSTGRES_DSN=host=postgres user=${POSTGRES_USER:-byte_v_forge} password=${POSTGRES_PASSWORD:-byte_v_forge} dbname=${POSTGRES_DB:-byte_v_forge} port=5432 sslmode=disable
      - PROXY_RUNTIME_DATA_DIR=/var/lib/proxy-runtime
      - PROXY_RUNTIME_MIHOMO_API_ADDR=${PROXY_RUNTIME_MIHOMO_API_ADDR:-127.0.0.1:18901}
      - PROXY_RUNTIME_ENCRYPTION_KEY=${PROXY_RUNTIME_ENCRYPTION_KEY:-byte_v_forge_proxy_runtime_encryption_key_change_me_32}
      - PROXY_RUNTIME_CONTROL_AUTH_TOKEN=${PROXY_RUNTIME_CONTROL_AUTH_TOKEN:-}
      - PROXY_RUNTIME_SERVICE_AUTH_TOKEN=${PROXY_RUNTIME_SERVICE_AUTH_TOKEN:-}
      - PROXY_RUNTIME_LOCAL_ADDR=:10810
      - PROXY_RUNTIME_LOCAL_PROTOCOL=${PROXY_RUNTIME_LOCAL_PROTOCOL:-socks5}
      - PROXY_RUNTIME_LOCAL_PASSWORD=${PROXY_RUNTIME_LOCAL_PASSWORD:-}
      - PROXY_RUNTIME_SESSION_ADVERTISED_HOST=${PROXY_RUNTIME_SESSION_ADVERTISED_HOST:-proxy-runtime}
      - PROXY_RUNTIME_REDIS_URL=${PROXY_RUNTIME_REDIS_URL:-redis://platform-redis:6379/0}
    extra_hosts:
      - "host.docker.internal:host-gateway"
    volumes:
      - proxy_runtime_data:/var/lib/proxy-runtime
    depends_on:
      - postgres
      - platform-redis
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.proxy-runtime-status.rule=Host(`proxy-runtime.byte-v-forge.internal`)"
      - "traefik.http.routers.proxy-runtime-status.entrypoints=internal"
      - "traefik.http.routers.proxy-runtime-status.service=proxy-runtime"
      - "traefik.http.services.proxy-runtime.loadbalancer.server.port=8080"
      - "traefik.http.services.proxy-runtime.loadbalancer.healthcheck.path=/healthz"
      - "traefik.http.routers.proxy-runtime-api.rule=Host(`proxy-runtime.byte-v-forge.internal`) && PathPrefix(`/api`)"
      - "traefik.http.routers.proxy-runtime-api.entrypoints=web"
      - "traefik.http.routers.proxy-runtime-api.priority=200"
      - "traefik.http.routers.proxy-runtime-api.service=proxy-runtime"
      - "traefik.http.routers.proxy-runtime-ui.rule=Host(`proxy-runtime.byte-v-forge.internal`) && PathPrefix(`/`)"
      - "traefik.http.routers.proxy-runtime-ui.entrypoints=web"
      - "traefik.http.routers.proxy-runtime-ui.priority=100"
      - "traefik.http.routers.proxy-runtime-ui.service=proxy-runtime"
    restart: always

  browser-automation:
    build:
      context: ../browser-automation
      dockerfile: Dockerfile
      args:
        BROWSER_AUTOMATION_RUNTIME_IMAGE: ${BROWSER_AUTOMATION_RUNTIME_IMAGE:-browser-automation-runtime:camoufox-cloakbrowser-py3.12-bookworm}
    init: true
    ports:
      - "127.0.0.1:${BROWSER_AUTOMATION_GRPC_PORT:-50062}:50051"
      - "127.0.0.1:${BROWSER_AUTOMATION_HTTP_PORT:-50063}:8080"
      - "${BROWSER_AUTOMATION_WEBRTC_TCP_BIND:-127.0.0.1}:${BROWSER_AUTOMATION_WEBRTC_TCP_PORT:-3479}:3479/tcp"
      - "${BROWSER_AUTOMATION_WEBRTC_UDP_BIND:-127.0.0.1}:${BROWSER_AUTOMATION_WEBRTC_UDP_PORT:-3478}:3478/udp"
    environment:
      - BROWSER_AUTOMATION_LISTEN_ADDR=:50051
      - BROWSER_AUTOMATION_HTTP_LISTEN_ADDR=:8080
      - BROWSER_AUTOMATION_POSTGRES_DSN=host=postgres user=${POSTGRES_USER:-byte_v_forge} password=${POSTGRES_PASSWORD:-byte_v_forge} dbname=${POSTGRES_DB:-byte_v_forge} port=5432 sslmode=disable
      - BROWSER_AUTOMATION_APPLY_MIGRATIONS=${BROWSER_AUTOMATION_APPLY_MIGRATIONS:-true}
      - BROWSER_AUTOMATION_RUNTIME=${BROWSER_AUTOMATION_RUNTIME:-camoufox}
      - BROWSER_AUTOMATION_MAX_CONCURRENT_SESSIONS=${BROWSER_AUTOMATION_MAX_CONCURRENT_SESSIONS:-0}
      - BROWSER_AUTOMATION_WEBRTC_TCP_LISTEN_ADDR=:3479
      - BROWSER_AUTOMATION_WEBRTC_UDP_LISTEN_ADDR=:3478
      - BROWSER_AUTOMATION_WEBRTC_PUBLIC_IPS=${BROWSER_AUTOMATION_WEBRTC_PUBLIC_IPS:-127.0.0.1}
      - BROWSER_AUTOMATION_PROXY_REFS_JSON=${BROWSER_AUTOMATION_PROXY_REFS_JSON:-{}}
      - BROWSER_AUTOMATION_PROXY_RUNTIME_BASE_URL=${BROWSER_AUTOMATION_PROXY_RUNTIME_BASE_URL:-http://proxy-runtime:8080/api}
      - BROWSER_AUTOMATION_PROXY_RUNTIME_TIMEOUT_SECONDS=${BROWSER_AUTOMATION_PROXY_RUNTIME_TIMEOUT_SECONDS:-10}
      - BROWSER_AUTOMATION_PROXY_RUNTIME_ACCOUNT_ID=${BROWSER_AUTOMATION_PROXY_RUNTIME_ACCOUNT_ID:-}
      - BROWSER_AUTOMATION_PROXY_RUNTIME_PURPOSE=${BROWSER_AUTOMATION_PROXY_RUNTIME_PURPOSE:-browser-automation}
    extra_hosts:
      - "host.docker.internal:host-gateway"
    shm_size: "2gb"
    depends_on:
      postgres:
        condition: service_started
      platform-nats:
        condition: service_started
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.browser-automation-status.rule=Host(`browser-automation.byte-v-forge.internal`)"
      - "traefik.http.routers.browser-automation-status.entrypoints=internal"
      - "traefik.http.routers.browser-automation-status.service=browser-automation"
      - "traefik.http.services.browser-automation.loadbalancer.server.port=50051"
      - "traefik.http.services.browser-automation.loadbalancer.server.scheme=h2c"
      - "traefik.http.services.browser-automation.loadbalancer.healthcheck.mode=grpc"
      - "traefik.http.routers.browser-automation-ui.rule=Host(`browser-automation.byte-v-forge.internal`) || Host(`browser-automation.byte-v-forge.localhost`)"
      - "traefik.http.routers.browser-automation-ui.entrypoints=web"
      - "traefik.http.routers.browser-automation-ui.service=browser-automation-ui"
      - "traefik.http.services.browser-automation-ui.loadbalancer.server.port=8080"
    restart: always

  mailbox:
    build:
      context: ../mailbox
      dockerfile: Dockerfile
    init: true
    ports:
      - "${MAILBOX_GRPC_PORT:-50058}:50051"
    environment:
      - MAILBOX_LISTEN_ADDR=:50051
      - MAILBOX_WEBHOOK_HTTP_ADDR=:8082
      - MAILBOX_DASHBOARD_HTTP_ADDR=:8080
      - MAILBOX_DASHBOARD_STATIC_DIR=/app/dashboard/mailbox
      - MAILBOX_WEBHOOK_TOKEN=${MAILBOX_WEBHOOK_TOKEN:-}
      - MAILBOX_CLOUDFLARE_EMAIL_CONFIG_FILE=/etc/mailbox/cloudflare-email/cloudflare-email.json
      - MAILBOX_CLOUDFLARE_API_TOKEN=${MAILBOX_CLOUDFLARE_API_TOKEN:-}
      - MAILBOX_CLOUDFLARE_RELAY_PULL_URL=${MAILBOX_CLOUDFLARE_RELAY_PULL_URL:-}
      - MAILBOX_CLOUDFLARE_RELAY_PULL_TOKEN=${MAILBOX_CLOUDFLARE_RELAY_PULL_TOKEN:-}
      - MAILBOX_CLOUDFLARE_MAX_MESSAGES_PER_DOMAIN=${MAILBOX_CLOUDFLARE_MAX_MESSAGES_PER_DOMAIN:-500}
      - MAILBOX_OUTLOOK_MAX_MESSAGES_PER_MAILBOX=${MAILBOX_OUTLOOK_MAX_MESSAGES_PER_MAILBOX:-100}
      - MAILBOX_COORDINATION_REDIS_URL=${MAILBOX_COORDINATION_REDIS_URL:-redis://platform-redis:6379/0}
      - MAILBOX_RECENT_EMAIL_REDIS_URL=${MAILBOX_RECENT_EMAIL_REDIS_URL:-redis://platform-redis:6379/0}
      - MAILBOX_NATS_URL=${MAILBOX_NATS_URL:-nats://platform-nats:4222}
      - MAILBOX_EVENT_STREAM_NAME=${MAILBOX_EVENT_STREAM_NAME:-BYTE_V_FORGE_EVENTS}
      - PLATFORM_REDIS_URL=${PLATFORM_REDIS_URL:-redis://platform-redis:6379/0}
      - PLATFORM_NATS_URL=${PLATFORM_NATS_URL:-nats://platform-nats:4222}
      - PLATFORM_EVENT_STREAM_NAME=${PLATFORM_EVENT_STREAM_NAME:-BYTE_V_FORGE_EVENTS}
      - MAILBOX_RECENT_EMAIL_CACHE_KEY_PREFIX=${MAILBOX_RECENT_EMAIL_CACHE_KEY_PREFIX:-byte-v-forge:mailbox:recent-email}
      - MAILBOX_RECENT_EMAIL_CACHE_TTL_SECONDS=${MAILBOX_RECENT_EMAIL_CACHE_TTL_SECONDS:-3600}
      - MAILBOX_RECENT_EMAIL_CACHE_MAX_MESSAGES=${MAILBOX_RECENT_EMAIL_CACHE_MAX_MESSAGES:-20}
      - MAILBOX_INBOX_LOCK_KEY_PREFIX=${MAILBOX_INBOX_LOCK_KEY_PREFIX:-byte-v-forge:mailbox:locks}
      - MAILBOX_INBOX_LOCK_TTL_SECONDS=${MAILBOX_INBOX_LOCK_TTL_SECONDS:-600}
      - MAILBOX_INBOX_LOCK_RETRY_SECONDS=${MAILBOX_INBOX_LOCK_RETRY_SECONDS:-1}
      - MAILBOX_PG_DSN=${MAILBOX_PG_DSN:-host=postgres user=byte_v_forge password=byte_v_forge dbname=byte_v_forge port=5432 sslmode=disable}
      - MAILBOX_BROWSER_AUTOMATION_ADDR=${MAILBOX_BROWSER_AUTOMATION_ADDR:-}
    volumes:
      - ./mailbox/cloudflare-email.compose.json:/etc/mailbox/cloudflare-email/cloudflare-email.json:ro
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.mailbox-webhook.rule=PathPrefix(`/webhooks/email`)"
      - "traefik.http.routers.mailbox-webhook.entrypoints=webhook"
      - "traefik.http.routers.mailbox-webhook.priority=100"
      - "traefik.http.routers.mailbox-webhook.service=mailbox-webhook"
      - "traefik.http.services.mailbox-webhook.loadbalancer.server.port=8082"
      - "traefik.http.services.mailbox-webhook.loadbalancer.healthcheck.path=/healthz"
      - "traefik.http.routers.mailbox-status.rule=Host(`mailbox.byte-v-forge.internal`)"
      - "traefik.http.routers.mailbox-status.entrypoints=internal"
      - "traefik.http.routers.mailbox-status.service=mailbox"
      - "traefik.http.services.mailbox.loadbalancer.server.port=50051"
      - "traefik.http.services.mailbox.loadbalancer.server.scheme=h2c"
      - "traefik.http.services.mailbox.loadbalancer.healthcheck.mode=grpc"
      - "traefik.http.routers.mailbox-api.rule=PathPrefix(`/api/mailbox`)"
      - "traefik.http.routers.mailbox-api.entrypoints=web"
      - "traefik.http.routers.mailbox-api.priority=100"
      - "traefik.http.routers.mailbox-api.service=mailbox-dashboard"
      - "traefik.http.routers.mailbox-dashboard.rule=PathPrefix(`/dashboard/mailbox`)"
      - "traefik.http.routers.mailbox-dashboard.entrypoints=web"
      - "traefik.http.routers.mailbox-dashboard.priority=100"
      - "traefik.http.routers.mailbox-dashboard.service=mailbox-dashboard"
      - "traefik.http.services.mailbox-dashboard.loadbalancer.server.port=8080"
      - "traefik.http.services.mailbox-dashboard.loadbalancer.healthcheck.path=/healthz"
    restart: always

  gpt-service:
    build:
      context: ..
      dockerfile: gpt/gpt-service/Dockerfile
      target: gpt_service_runtime
    init: true
    ports:
      - "${GPT_SERVICE_GRPC_PORT:-50055}:50051"
      - "127.0.0.1:${GPT_ACCOUNT_GRPC_PORT:-50052}:50052"
    environment:
      - GPT_SERVICE_LISTEN_ADDR=:50051
      - GPT_DASHBOARD_HTTP_ADDR=:8080
      - GPT_N8N_WEBHOOK_BASE_URL=${GPT_N8N_WEBHOOK_BASE_URL:-http://n8n-webhook:5678/webhook}
      - GPT_ACCOUNT_INTERNAL_ADDR=127.0.0.1:50052
      - GPT_PAYMENT_INTERNAL_ADDR=gpt-checkout:50054
      - GPT_PRIVATE_APP_INTERNAL_ADDR=gopay-app:50051
      - GPT_SERVICE_PG_DSN=host=postgres user=${POSTGRES_USER:-byte_v_forge} password=${POSTGRES_PASSWORD:-byte_v_forge} dbname=${POSTGRES_DB:-byte_v_forge} port=5432 sslmode=disable
      - GPT_RUNTIME_SECRET_REDIS_URL=${PLATFORM_REDIS_URL:-redis://platform-redis:6379/0}
      - GPT_OTP_RELAY_REDIS_URL=${PLATFORM_REDIS_URL:-redis://platform-redis:6379/0}
      - PLATFORM_EVENT_STREAM_NAME=${PLATFORM_EVENT_STREAM_NAME:-BYTE_V_FORGE_EVENTS}
      - GPT_RUNTIME_SECRET_KEY_PREFIX=${GPT_RUNTIME_SECRET_KEY_PREFIX:-byte-v-forge:gpt:runtime-secrets}
      - GPT_RUNTIME_SECRET_TTL_SECONDS=${GPT_RUNTIME_SECRET_TTL_SECONDS:-86400}
      - BROWSER_AUTOMATION_ADDR=browser-automation:50051
      - SMS_ADDR=sms-service:50051
      - PROXY_RUNTIME_HTTP_ADDR=${PROXY_RUNTIME_HTTP_ADDR:-http://proxy-runtime:8080}
    extra_hosts:
      - "host.docker.internal:host-gateway"
    depends_on:
      postgres:
        condition: service_started
      platform-db-migrations:
        condition: service_completed_successfully
      platform-redis:
        condition: service_started
      platform-nats:
        condition: service_started
      platform-nats-init:
        condition: service_completed_successfully
      browser-automation:
        condition: service_started
      mailbox:
        condition: service_started
      sms-service:
        condition: service_started
      proxy-runtime:
        condition: service_started
      gpt-checkout:
        condition: service_started
      gopay-app:
        condition: service_started
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.gpt-service-status.rule=Host(`gpt-service.byte-v-forge.internal`)"
      - "traefik.http.routers.gpt-service-status.entrypoints=internal"
      - "traefik.http.routers.gpt-service-status.service=gpt-service"
      - "traefik.http.services.gpt-service.loadbalancer.server.port=50051"
      - "traefik.http.services.gpt-service.loadbalancer.server.scheme=h2c"
      - "traefik.http.services.gpt-service.loadbalancer.healthcheck.mode=grpc"
      - "traefik.http.routers.gpt-api.rule=PathPrefix(`/api/gpt`)"
      - "traefik.http.routers.gpt-api.entrypoints=web"
      - "traefik.http.routers.gpt-api.priority=100"
      - "traefik.http.routers.gpt-api.service=gpt-service-dashboard"
      - "traefik.http.routers.gpt-mf.rule=PathPrefix(`/mf/gpt`)"
      - "traefik.http.routers.gpt-mf.entrypoints=web"
      - "traefik.http.routers.gpt-mf.priority=100"
      - "traefik.http.routers.gpt-mf.service=gpt-service-dashboard"
      - "traefik.http.services.gpt-service-dashboard.loadbalancer.server.port=8080"
      - "traefik.http.services.gpt-service-dashboard.loadbalancer.healthcheck.path=/healthz"
    restart: always

  gpt-checkout:
    build:
      context: ..
      dockerfile: gpt-private/gopay/Dockerfile
    environment:
      - GOPAY_PAYMENT_LISTEN_ADDR=:50054
      - GOPAY_ALLOW_NONZERO_EXPECTED_AMOUNT=${GOPAY_ALLOW_NONZERO_EXPECTED_AMOUNT:-true}
      - GOPAY_CHECKOUT_PROFILE_JSON=${GOPAY_CHECKOUT_PROFILE_JSON:-}
      - GOPAY_PAYMENT_PROFILE_JSON=${GOPAY_PAYMENT_PROFILE_JSON:-}
    depends_on:
      proxy-runtime:
        condition: service_started
    restart: always

  gopay-app:
    build:
      context: ..
      dockerfile: gopay-app/Dockerfile
    environment:
      - GOPAY_APP_PORT=50051
      - GOPAY_HTTP_LISTEN_ADDR=:8080
      - GOPAY_DASHBOARD_STATIC_DIR=/app/dashboard/gopay
      - GOPAY_N8N_WEBHOOK_BASE_URL=${GOPAY_N8N_WEBHOOK_BASE_URL:-http://n8n-webhook:5678/webhook}
      - GOPAY_STATE_REDIS_URL=${PLATFORM_REDIS_URL:-redis://platform-redis:6379/0}
      - GOPAY_STATE_KEY_PREFIX=${GOPAY_STATE_KEY_PREFIX:-byte-v-forge:gopay-app:state}
      - GOPAY_STATE_TTL_SECONDS=${GOPAY_STATE_TTL_SECONDS:-604800}
      - PROXY_RUNTIME_HTTP_ADDR=${PROXY_RUNTIME_HTTP_ADDR:-http://proxy-runtime:8080}
      - GOPAY_SIGNUP_INITIATE_JITTER_MIN_SECONDS=${GOPAY_SIGNUP_INITIATE_JITTER_MIN_SECONDS:-8}
      - GOPAY_SIGNUP_INITIATE_JITTER_MAX_SECONDS=${GOPAY_SIGNUP_INITIATE_JITTER_MAX_SECONDS:-25}
      - GOPAY_SIGNUP_RATE_LIMIT_COOLDOWN_SECONDS=${GOPAY_SIGNUP_RATE_LIMIT_COOLDOWN_SECONDS:-900}
      - GOPAY_OTP_WEBHOOK_LISTEN_ADDR=:8081
      - GOPAY_OTP_SUBMIT_URL=${GOPAY_OTP_SUBMIT_URL:-http://gopay-app:8080/api/gopay/otp/submit}
      - GOTO_SSO_CLIENT_SECRET=${GOTO_SSO_CLIENT_SECRET:-}
    depends_on:
      platform-redis:
        condition: service_started
      proxy-runtime:
        condition: service_started
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.gopay-otp-webhook.rule=PathPrefix(`/`)"
      - "traefik.http.routers.gopay-otp-webhook.entrypoints=webhook"
      - "traefik.http.routers.gopay-otp-webhook.priority=1"
      - "traefik.http.routers.gopay-otp-webhook.service=gopay-app-webhook"
      - "traefik.http.services.gopay-app-webhook.loadbalancer.server.port=8081"
      - "traefik.http.routers.gopay-api.rule=PathPrefix(`/api/gopay`) || PathPrefix(`/mf/gopay`)"
      - "traefik.http.routers.gopay-api.entrypoints=web"
      - "traefik.http.routers.gopay-api.priority=100"
      - "traefik.http.routers.gopay-api.service=gopay-app-api"
      - "traefik.http.services.gopay-app-api.loadbalancer.server.port=8080"
      - "traefik.http.services.gopay-app-api.loadbalancer.healthcheck.path=/api/gopay/health"
      - "traefik.http.routers.gopay-app-status.rule=Host(`gopay-app.byte-v-forge.internal`)"
      - "traefik.http.routers.gopay-app-status.entrypoints=internal"
      - "traefik.http.routers.gopay-app-status.service=gopay-app"
      - "traefik.http.services.gopay-app.loadbalancer.server.port=50051"
      - "traefik.http.services.gopay-app.loadbalancer.server.scheme=h2c"
      - "traefik.http.services.gopay-app.loadbalancer.healthcheck.mode=grpc"
    restart: always

  sms-service:
    build:
      context: ../sms
      dockerfile: Dockerfile
    ports:
      - "127.0.0.1:${SMS_SERVICE_GRPC_PORT:-50061}:50051"
    environment:
      - SMS_LISTEN_ADDR=:50051
      - SMS_DASHBOARD_HTTP_ADDR=:8080
      - SMS_DASHBOARD_STATIC_DIR=/app/dashboard/sms
      - SMS_PG_DSN=${SMS_PG_DSN:-host=postgres user=byte_v_forge password=byte_v_forge dbname=byte_v_forge port=5432 sslmode=disable}
      - SMS_REDIS_URL=${SMS_REDIS_URL:-redis://platform-redis:6379/0}
      - SMS_NATS_URL=${SMS_NATS_URL:-nats://platform-nats:4222}
      - SMS_EVENT_STREAM_NAME=${SMS_EVENT_STREAM_NAME:-BYTE_V_FORGE_EVENTS}
      - PLATFORM_REDIS_URL=${PLATFORM_REDIS_URL:-redis://platform-redis:6379/0}
      - PLATFORM_NATS_URL=${PLATFORM_NATS_URL:-nats://platform-nats:4222}
      - PLATFORM_EVENT_STREAM_NAME=${PLATFORM_EVENT_STREAM_NAME:-BYTE_V_FORGE_EVENTS}
      - SMS_PROVIDER_HTTP_PROXY=${SMS_PROVIDER_HTTP_PROXY:-socks5://sms:sms@proxy-runtime:10810}
    extra_hosts:
      - "host.docker.internal:host-gateway"
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.sms-service-status.rule=Host(`sms-service.byte-v-forge.internal`)"
      - "traefik.http.routers.sms-service-status.entrypoints=internal"
      - "traefik.http.routers.sms-service-status.service=sms-service"
      - "traefik.http.services.sms-service.loadbalancer.server.port=50051"
      - "traefik.http.services.sms-service.loadbalancer.server.scheme=h2c"
      - "traefik.http.services.sms-service.loadbalancer.healthcheck.mode=grpc"
      - "traefik.http.routers.sms-api.rule=PathPrefix(`/api/sms`)"
      - "traefik.http.routers.sms-api.entrypoints=web"
      - "traefik.http.routers.sms-api.priority=100"
      - "traefik.http.routers.sms-api.service=sms-service-dashboard"
      - "traefik.http.routers.sms-app.rule=Host(`sms.byte-v-forge.localhost`) && PathPrefix(`/`)"
      - "traefik.http.routers.sms-app.entrypoints=web"
      - "traefik.http.routers.sms-app.priority=500"
      - "traefik.http.routers.sms-app.service=sms-service-dashboard"
      - "traefik.http.services.sms-service-dashboard.loadbalancer.server.port=8080"
      - "traefik.http.services.sms-service-dashboard.loadbalancer.healthcheck.path=/healthz"
    restart: always

  wa-app-service:
    build:
      context: ..
      dockerfile: wa-app/Dockerfile
    ports:
      - "127.0.0.1:${WA_APP_GRPC_PORT:-50091}:50051"
    environment:
      - WA_APP_LISTEN_ADDR=:50051
      - WA_APP_DASHBOARD_HTTP_ADDR=:8080
      - WA_APP_DASHBOARD_STATIC_DIR=/app/dashboard/wa
      - WA_APP_AUTH_PASSWORD=${WA_APP_AUTH_PASSWORD:-}
      - WA_APP_DATA_DIR=${WA_APP_DATA_DIR:-/var/lib/wa-app}
      - WA_APP_PG_DSN=${WA_APP_PG_DSN:-}
      - WA_APP_REDIS_URL=${WA_APP_REDIS_URL:-}
      - WA_COMMON_PROXY=${WA_COMMON_PROXY:-}
      - WA_REGISTRATION_PROXY_LEASE_MODE=${WA_REGISTRATION_PROXY_LEASE_MODE:-optional}
      - WA_REGISTRATION_PROXY_LEASE_API_BASE_URL=${WA_REGISTRATION_PROXY_LEASE_API_BASE_URL:-http://proxy-runtime:8080/api}
      - WA_REGISTRATION_PROXY_LEASE_AUTH_TOKEN=${WA_REGISTRATION_PROXY_LEASE_AUTH_TOKEN:-}
    volumes:
      - wa_app_data:/var/lib/wa-app
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.wa-app-service-status.rule=Host(`wa-app-service.byte-v-forge.internal`)"
      - "traefik.http.routers.wa-app-service-status.entrypoints=internal"
      - "traefik.http.routers.wa-app-service-status.service=wa-app-service"
      - "traefik.http.services.wa-app-service.loadbalancer.server.port=50051"
      - "traefik.http.services.wa-app-service.loadbalancer.server.scheme=h2c"
      - "traefik.http.services.wa-app-service.loadbalancer.healthcheck.mode=grpc"
      - "traefik.http.routers.wa-app.rule=Host(`wa.byte-v-forge.localhost`)"
      - "traefik.http.routers.wa-app.entrypoints=web"
      - "traefik.http.routers.wa-app.priority=500"
      - "traefik.http.routers.wa-app.service=wa-app-dashboard"
      - "traefik.http.services.wa-app-dashboard.loadbalancer.server.port=8080"
      - "traefik.http.services.wa-app-dashboard.loadbalancer.healthcheck.path=/healthz"
    restart: always

  workflow-runtime:
    build:
      context: ..
      dockerfile: workflow-runtime/Dockerfile
    environment:
      - WORKFLOW_RUNTIME_HTTP_ADDR=:8080
      - WORKFLOW_RUNTIME_DASHBOARD_STATIC_DIR=/app/dashboard/workflow-runtime
      - WORKFLOW_RUNTIME_DATABASE_URL=host=postgres user=${POSTGRES_USER:-byte_v_forge} password=${POSTGRES_PASSWORD:-byte_v_forge} dbname=${POSTGRES_DB:-byte_v_forge} port=5432 sslmode=disable
      - WORKFLOW_RUNTIME_STEP_UPDATE_TOKEN=${WORKFLOW_RUNTIME_STEP_UPDATE_TOKEN:-byte_v_forge_workflow_runtime_step_update_token_change_me_32}
      - N8N_INTERNAL_URL=http://n8n-main:5678
      - N8N_PUBLIC_URL=${N8N_PUBLIC_URL:-http://localhost:5678}
      - N8N_API_KEY=${N8N_API_KEY:-}
    depends_on:
      postgres:
        condition: service_started
      n8n-main:
        condition: service_started
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.workflow-runtime-api.rule=PathPrefix(`/api/workflow-runtime`)"
      - "traefik.http.routers.workflow-runtime-api.entrypoints=web"
      - "traefik.http.routers.workflow-runtime-api.priority=100"
      - "traefik.http.routers.workflow-runtime-api.service=workflow-runtime"
      - "traefik.http.routers.workflow-runtime-mf.rule=PathPrefix(`/mf/workflow-runtime`)"
      - "traefik.http.routers.workflow-runtime-mf.entrypoints=web"
      - "traefik.http.routers.workflow-runtime-mf.priority=100"
      - "traefik.http.routers.workflow-runtime-mf.service=workflow-runtime"
      - "traefik.http.services.workflow-runtime.loadbalancer.server.port=8080"
      - "traefik.http.services.workflow-runtime.loadbalancer.healthcheck.path=/healthz"
    restart: always

  webui:
    build:
      context: ..
      dockerfile: webui/Dockerfile
    environment:
      - LISTEN_ADDR=:8080
      - TRAEFIK_API_ADDR=http://traefik:8080
    depends_on:
      - traefik
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.webui.rule=PathPrefix(`/`)"
      - "traefik.http.routers.webui.entrypoints=web"
      - "traefik.http.routers.webui.priority=1"
      - "traefik.http.routers.webui.service=webui"
      - "traefik.http.services.webui.loadbalancer.server.port=8080"
      - "traefik.http.services.webui.loadbalancer.healthcheck.path=/api/health"
    restart: always

volumes:
  pgdata:
  n8n_pgdata:
  n8n_data:
  nats_data:
  proxy_runtime_data:
  openai_sso_lite_data:
  openai_sso_discord_bot_data:
  team_5000_data:
  wa_app_data: