@bankung/agent-teams 0.1.0

package/cli/lib/docker.js

@@ -0,0 +1,93 @@
+'use strict';
+// cli/lib/docker.js — Docker daemon check + compose runner helpers.
+// Zero runtime dependencies; uses only Node built-ins.
+
+const { spawnSync, spawn } = require('child_process');
+
+/**
+ * Check whether the `git` CLI is on PATH.
+ * Returns { ok: true } or { ok: false, message: string }.
+ */
+function checkGit() {
+  const result = spawnSync('git', ['--version'], { stdio: 'pipe', shell: false });
+  if (result.error || result.status === null) {
+    return {
+      ok: false,
+      message: [
+        'git is not installed or not on PATH.',
+        'Install Git (https://git-scm.com/downloads) and re-run this command.',
+        'git is required to clone the agent-teams repository in standalone mode.',
+      ].join('\n'),
+    };
+  }
+  return { ok: true };
+}
+
+/**
+ * Check whether the Docker CLI is on PATH and the daemon is reachable.
+ * Returns { ok: true } or { ok: false, message: string }.
+ */
+function checkDocker() {
+  // 1. Is `docker` on PATH?
+  const whichResult = spawnSync('docker', ['--version'], { stdio: 'pipe', shell: false });
+  if (whichResult.error || whichResult.status === null) {
+    return {
+      ok: false,
+      message: [
+        'Docker is not installed or not on PATH.',
+        'Install Docker Desktop (https://docs.docker.com/get-docker/) and re-run this command.',
+        'Docker is a required prerequisite — npm does not install it.',
+      ].join('\n'),
+    };
+  }
+
+  // 2. Is the daemon responding? (`docker info` exits non-zero when daemon is down.)
+  // F-04: timeout:10000 prevents a hung daemon from freezing the install indefinitely.
+  const infoResult = spawnSync('docker', ['info'], { stdio: 'pipe', shell: false, timeout: 10000 });
+  if (infoResult.status !== 0) {
+    return {
+      ok: false,
+      message: [
+        'Docker is installed but the daemon is not responding.',
+        'Start Docker Desktop (or run `sudo systemctl start docker` on Linux) and re-run:',
+        '    npx agent-teams up',
+        'Troubleshooting: https://docs.docker.com/get-docker/',
+      ].join('\n'),
+    };
+  }
+
+  return { ok: true };
+}
+
+/**
+ * Run `docker compose -p agent-teams [-f <composeFile>] <args>` with stdio inherited.
+ * Returns exit code (integer). Streams all output directly to the terminal.
+ *
+ * @param {string[]} args        Arguments after the compose preamble
+ * @param {object}   [env]       Additional env vars to merge (e.g. { MIGRATION_TARGET: 'live' })
+ * @param {object}   [spawnOpts] Extra options forwarded to spawn() (e.g. { cwd: repoRoot })
+ * @param {string}   [composeFile] Optional path to an alternate compose file (e.g. docker-compose.images.yml).
+ *                                 When omitted, Docker uses the default docker-compose.yml discovery.
+ */
+function compose(args, env = {}, spawnOpts = {}, composeFile = null) {
+  const fileArgs = composeFile ? ['-f', composeFile] : [];
+  return new Promise((resolve) => {
+    const child = spawn(
+      'docker',
+      ['compose', '-p', 'agent-teams', ...fileArgs, ...args],
+      {
+        stdio: 'inherit',
+        shell: false,
+        env: { ...process.env, ...env },
+        ...spawnOpts,
+      }
+    );
+    child.on('close', (code) => resolve(code ?? 1));
+    child.on('error', (err) => {
+      process.stderr.write(`ERROR: failed to spawn docker: ${err.message}\n`);
+      resolve(1);
+    });
+  });
+}
+
+module.exports = { checkGit, checkDocker, compose };

package/cli/lib/env.js

@@ -0,0 +1,101 @@
+'use strict';
+// cli/lib/env.js — .env scaffold + CREDENTIALS_MASTER_KEY Fernet generation.
+// Zero runtime dependencies; uses only Node built-ins.
+
+const fs   = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+/**
+ * Ensure .env exists (copied from .env.example if absent) and that
+ * CREDENTIALS_MASTER_KEY is set to a valid Fernet key.
+ *
+ * Idempotent: never overwrites an existing non-empty key.
+ *
+ * @param {string} repoRoot  Absolute path to the repo root.
+ */
+function ensureEnv(repoRoot) {
+  const envFile     = path.join(repoRoot, '.env');
+  const envExample  = path.join(repoRoot, '.env.example');
+
+  // ---- scaffold .env from .env.example if missing --------------------------
+  if (!fs.existsSync(envFile)) {
+    if (fs.existsSync(envExample)) {
+      fs.copyFileSync(envExample, envFile);
+      // chmod 0600: no-op on Windows but protects .env on shared POSIX hosts.
+      try { fs.chmodSync(envFile, 0o600); } catch (_) { /* Windows — ignore */ }
+      console.log('==> .env not found — copied from .env.example.');
+    } else {
+      console.warn('WARN: .env.example not found. You may need to create .env manually.');
+    }
+  }
+
+  // ---- CREDENTIALS_MASTER_KEY ----------------------------------------------
+  if (!fs.existsSync(envFile)) return; // nothing to do if we still have no .env
+
+  let content = fs.readFileSync(envFile, 'utf8');
+
+  // Match the line only when the value is non-empty (non-whitespace after '=').
+  const keyPresent = /^CREDENTIALS_MASTER_KEY=\S+/m.test(content);
+
+  if (keyPresent) {
+    console.log('==> CREDENTIALS_MASTER_KEY already set — leaving untouched.');
+    return;
+  }
+
+  // Generate: URL-safe base64 of 32 random bytes.
+  // Node's 'base64url' encoding (available since Node 15) produces the exact
+  // URL-safe alphabet (- and _ instead of + and /) that Python's Fernet expects.
+  // 32 bytes → 44-char base64url string (no padding added by 'base64url').
+  // Fernet requires standard base64 padding; we append '=' to make it 44 chars.
+  //
+  // Actually: 32 bytes → ceil(32/3)*4 = 44 chars in standard base64.
+  // base64url omits the trailing '=' but Fernet checks for it.
+  // We generate via 'base64' then swap +/ → -_ to stay explicit about format.
+  const rawB64 = crypto.randomBytes(32).toString('base64'); // 44 chars, ends with '='
+  const fernetKey = rawB64.replace(/\+/g, '-').replace(/\//g, '_');
+
+  console.log('==> CREDENTIALS_MASTER_KEY is missing/empty — generating a Fernet key...');
+
+  // Replace an existing empty-value line, or append if the line is absent.
+  if (/^CREDENTIALS_MASTER_KEY=/m.test(content)) {
+    content = content.replace(/^CREDENTIALS_MASTER_KEY=.*/m, `CREDENTIALS_MASTER_KEY=${fernetKey}`);
+  } else {
+    content = content.trimEnd() + `\nCREDENTIALS_MASTER_KEY=${fernetKey}\n`;
+  }
+
+  fs.writeFileSync(envFile, content, { encoding: 'utf8', mode: 0o600 });
+  // chmod 0600: defensive belt-and-suspenders in case umask overrode mode above.
+  try { fs.chmodSync(envFile, 0o600); } catch (_) { /* Windows — ignore */ }
+
+  console.log('');
+  console.log('NOTICE: A new CREDENTIALS_MASTER_KEY has been generated and written to .env.');
+  console.log('        Back it up securely (password manager / offline storage). Losing this');
+  console.log('        key makes ALL stored vault credentials permanently unrecoverable.');
+  console.log('');
+}
+
+/**
+ * Read a port from the .env file (if present) with a fallback default.
+ * Used so the health-wait targets the right port when API_PORT / WEB_PORT differ.
+ *
+ * @param {string} repoRoot
+ * @param {string} varName   e.g. 'API_PORT'
+ * @param {string} fallback  e.g. '8456'
+ */
+function readEnvPort(repoRoot, varName, fallback) {
+  const envFile = path.join(repoRoot, '.env');
+  if (!fs.existsSync(envFile)) return fallback;
+  const content = fs.readFileSync(envFile, 'utf8');
+  // Find the line for varName, then strip inline comments before matching digits.
+  // e.g. `API_PORT=8456 # note` — split at first '#', keep left side, then match.
+  // Escape varName to prevent regex injection (caller-controlled string).
+  const safeVarName = varName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const lineMatch = content.match(new RegExp(`^${safeVarName}=(.*)`, 'm'));
+  if (!lineMatch) return fallback;
+  const valueRaw  = lineMatch[1].split('#')[0].trim(); // strip inline comment
+  const digitMatch = valueRaw.match(/^(\d+)/);
+  return digitMatch ? digitMatch[1] : fallback;
+}
+
+module.exports = { ensureEnv, readEnvPort };

package/cli/lib/health.js

@@ -0,0 +1,53 @@
+'use strict';
+// cli/lib/health.js — Poll an HTTP endpoint until it returns 200.
+// Zero runtime dependencies; uses Node built-in `http` module.
+
+const http = require('http');
+
+/**
+ * Poll `url` every `intervalMs` until it returns HTTP 200 or `timeoutMs` elapses.
+ *
+ * @param {string} url
+ * @param {object} opts
+ * @param {number} [opts.timeoutMs=60000]   Total wait budget in ms.
+ * @param {number} [opts.intervalMs=5000]   Polling interval in ms.
+ * @param {number} [opts.probeTimeoutMs=5000] Per-request timeout in ms.
+ * @returns {Promise<boolean>} true if healthy, false if timed out.
+ */
+function waitForHealthy(url, { timeoutMs = 60000, intervalMs = 5000, probeTimeoutMs = 5000 } = {}) {
+  return new Promise((resolve) => {
+    const deadline  = Date.now() + timeoutMs;
+    // F-03: track real wall-clock start so elapsed reflects actual seconds waited.
+    const startedAt = Date.now();
+
+    function probe() {
+      const req = http.get(url, { timeout: probeTimeoutMs }, (res) => {
+        res.resume(); // drain response body
+        if (res.statusCode === 200) {
+          resolve(true);
+        } else {
+          scheduleNext();
+        }
+      });
+      req.on('error', () => scheduleNext());
+      req.on('timeout', () => { req.destroy(); scheduleNext(); });
+    }
+
+    function scheduleNext() {
+      // Use the full budget: only give up AFTER Date.now() has reached the deadline.
+      // The old check (Date.now() + intervalMs > deadline) abandoned the last probe
+      // ~1 interval early (wastes ~5s of a 60s cap).
+      if (Date.now() >= deadline) {
+        resolve(false);
+        return;
+      }
+      const elapsed = Math.round((Date.now() - startedAt) / 1000);
+      process.stdout.write(`    ...still waiting (${elapsed}s elapsed)\n`);
+      setTimeout(probe, intervalMs);
+    }
+
+    probe();
+  });
+}
+
+module.exports = { waitForHealthy };

package/cli/lib/open-url.js

@@ -0,0 +1,60 @@
+'use strict';
+// cli/lib/open-url.js — Best-effort cross-platform browser opener.
+// Always prints the URL; never throws or fails the caller.
+
+const { spawn } = require('child_process');
+
+// Safe URL pattern: only localhost URLs with a numeric port and a restricted path.
+// This guards against metacharacter injection into cmd.exe on Windows even when
+// shell:false is used (cmd /c start re-parses the URL argument).
+// The port is already digit-constrained by readEnvPort, so the risk is low —
+// this is defense-in-depth.
+const SAFE_URL_RE = /^https?:\/\/localhost:\d+\/[A-Za-z0-9/_-]*$/;
+
+/**
+ * Print `url` and attempt to open it in the default browser.
+ * Failure is silently swallowed — this must never block the install.
+ * If the URL does not match the safe pattern, the auto-open is skipped
+ * and only the printed URL is shown.
+ *
+ * SECURITY: This function is only safe for URLs constructed internally by the
+ * CLI (localhost + digit port + restricted path). Never pass user-supplied or
+ * externally-sourced URLs — the SAFE_URL_RE guard is defense-in-depth, not a
+ * general sanitiser.
+ *
+ * @param {string} url  Must be a compiler-controlled localhost URL (see SAFE_URL_RE).
+ */
+function openUrl(url) {
+  console.log(`\nOpen in your browser: ${url}\n`);
+
+  if (!SAFE_URL_RE.test(url)) {
+    // URL contains unexpected characters — skip auto-open, just rely on the print above.
+    return;
+  }
+
+  let cmd, args;
+  switch (process.platform) {
+    case 'win32':
+      // `start` is a cmd.exe builtin; run via cmd /c start
+      cmd  = 'cmd';
+      args = ['/c', 'start', '', url];
+      break;
+    case 'darwin':
+      cmd  = 'open';
+      args = [url];
+      break;
+    default: // Linux + everything else
+      cmd  = 'xdg-open';
+      args = [url];
+      break;
+  }
+
+  try {
+    const child = spawn(cmd, args, { stdio: 'ignore', detached: true, shell: false });
+    child.unref(); // don't keep the Node process alive waiting for the browser
+  } catch (_) {
+    // best-effort — ignore all errors
+  }
+}
+
+module.exports = { openUrl };

package/docker-compose.images.yml

@@ -0,0 +1,177 @@
+# docker-compose.images.yml — pull-based prod stack for agent-teams.
+#
+# Used by `npx @bankung/agent-teams up --images` to pull pre-built images from
+# GHCR instead of building from source. No git clone required — the CLI ships
+# this file and .env.example in the npm package.
+#
+# Usage:
+#   docker compose -p agent-teams -f docker-compose.images.yml pull
+#   docker compose -p agent-teams -f docker-compose.images.yml up -d
+#
+# Images are published by the GitHub Actions workflow
+# .github/workflows/release-images.yml on every `v*` tag push.
+# Set AGENT_TEAMS_VERSION to pin a specific release (default: latest).
+#
+# SYNC NOTICE: Keep env blocks, ports, healthchecks, and depends_on in sync
+# with docker-compose.yml. The two files share the same env contract — any
+# new env var added to docker-compose.yml must also be added here.
+
+services:
+  db:
+    image: postgres:16-alpine
+    container_name: agent-teams-db
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-postgres}
+      POSTGRES_DB: agent_teams
+    ports:
+      - "${POSTGRES_PORT:-5432}:5432"
+    volumes:
+      - agent-teams-pgdata:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres -d agent_teams"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+  api:
+    image: ghcr.io/bankung/agent-teams-api:${AGENT_TEAMS_VERSION:-latest}
+    container_name: agent-teams-api
+    depends_on:
+      db:
+        condition: service_healthy
+    environment:
+      DATABASE_URL: postgresql+asyncpg://postgres:${POSTGRES_PASSWORD:-postgres}@db:5432/agent_teams
+      APP_ENV: ${APP_ENV:-production}
+      APP_DEBUG: ${APP_DEBUG:-false}
+      REPO_ROOT: /repo
+      LANGGRAPH_LLM_PROVIDER: ${LANGGRAPH_LLM_PROVIDER:-anthropic}
+      ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY:-}
+      OPENAI_API_KEY: ${OPENAI_API_KEY:-}
+      ANTHROPIC_MODEL: ${ANTHROPIC_MODEL:-claude-sonnet-4-6}
+      OPENAI_MODEL: ${OPENAI_MODEL:-gpt-4o}
+      BACKUP_S3_BUCKET: ${BACKUP_S3_BUCKET:-}
+      BACKUP_S3_ACCESS_KEY_ID: ${BACKUP_S3_ACCESS_KEY_ID:-}
+      BACKUP_S3_SECRET_ACCESS_KEY: ${BACKUP_S3_SECRET_ACCESS_KEY:-}
+      BACKUP_AGE_PUBKEY: ${BACKUP_AGE_PUBKEY:-}
+      BACKUP_S3_REGION: ${BACKUP_S3_REGION:-us-east-1}
+      BACKUP_S3_ENDPOINT: ${BACKUP_S3_ENDPOINT:-}
+      BACKUP_S3_PREFIX: ${BACKUP_S3_PREFIX:-agent-teams/}
+      SECRET_KEY: ${SECRET_KEY:-}
+      GMAIL_SMTP_HOST: ${GMAIL_SMTP_HOST:-smtp.gmail.com}
+      GMAIL_SMTP_PORT: ${GMAIL_SMTP_PORT:-587}
+      GMAIL_SMTP_USER: ${GMAIL_SMTP_USER:-}
+      GMAIL_SMTP_APP_PASSWORD: ${GMAIL_SMTP_APP_PASSWORD:-}
+      GMAIL_SMTP_FROM: ${GMAIL_SMTP_FROM:-}
+      DIGEST_EMAIL_RECIPIENT: ${DIGEST_EMAIL_RECIPIENT:-}
+      DIGEST_EMAIL_ENABLED: ${DIGEST_EMAIL_ENABLED:-false}
+      WEB_BASE_URL: ${WEB_BASE_URL:-http://localhost:5431}
+      NTFY_BASE_URL: ${NTFY_BASE_URL:-https://ntfy.sh}
+      NTFY_TOPIC: ${NTFY_TOPIC:-}
+      NTFY_ACCESS_TOKEN: ${NTFY_ACCESS_TOKEN:-}
+      PUSH_ENABLED: ${PUSH_ENABLED:-false}
+      BACKUP_CRON_RULE: ${BACKUP_CRON_RULE:-0 3 * * *}
+      BACKUP_TIMEZONE: ${BACKUP_TIMEZONE:-UTC}
+      BACKUP_KEEP_DAILY: ${BACKUP_KEEP_DAILY:-30}
+      BACKUP_KEEP_MONTHLY: ${BACKUP_KEEP_MONTHLY:-12}
+      BACKUP_DRY_RUN: ${BACKUP_DRY_RUN:-false}
+      HEALTH_MONITOR_DISABLED: ${HEALTH_MONITOR_DISABLED:-}
+      HEALTH_MONITOR_INTERVAL_MINUTES: ${HEALTH_MONITOR_INTERVAL_MINUTES:-15}
+      HEALTH_MONITOR_API_BASE: ${HEALTH_MONITOR_API_BASE:-http://localhost:8456}
+      VAPID_PUBLIC_KEY: ${VAPID_PUBLIC_KEY:-}
+      VAPID_PRIVATE_KEY: ${VAPID_PRIVATE_KEY:-}
+      VAPID_SUBJECT: ${VAPID_SUBJECT:-mailto:admin@example.com}
+      PYTEST_DB_PASSWORD: ${PYTEST_DB_PASSWORD:-}
+      CREDENTIALS_MASTER_KEY: ${CREDENTIALS_MASTER_KEY:-}
+      OPERATOR_ACTION_KEY: ${OPERATOR_ACTION_KEY:-}
+      GOOGLE_OAUTH_CLIENT_ID: ${GOOGLE_OAUTH_CLIENT_ID:-}
+      GOOGLE_OAUTH_CLIENT_SECRET: ${GOOGLE_OAUTH_CLIENT_SECRET:-}
+      GOOGLE_OAUTH_REDIRECT_URI: ${GOOGLE_OAUTH_REDIRECT_URI:-http://localhost:8456/api/tools/email/auth/gmail/callback}
+      EMAIL_TOOLS_DAILY_UNITS_CAP: ${EMAIL_TOOLS_DAILY_UNITS_CAP:-5000}
+      EMAIL_TOOLS_BULK_THRESHOLD: ${EMAIL_TOOLS_BULK_THRESHOLD:-100}
+      EMAIL_TOOLS_AUDIT_PATH: ${EMAIL_TOOLS_AUDIT_PATH:-/repo/_scratch/email-tools-audit.jsonl}
+      AZURE_OAUTH_CLIENT_ID: ${AZURE_OAUTH_CLIENT_ID:-}
+      AZURE_OAUTH_CLIENT_SECRET: ${AZURE_OAUTH_CLIENT_SECRET:-}
+      AZURE_OAUTH_TENANT: ${AZURE_OAUTH_TENANT:-consumers}
+      AZURE_OAUTH_REDIRECT_URI: ${AZURE_OAUTH_REDIRECT_URI:-http://localhost:8456/api/tools/email/auth/outlook/callback}
+    ports:
+      - "${API_PORT:-8456}:8456"
+    volumes:
+      # Named volume gives /repo a writable, persisted filesystem so scaffold/
+      # session/resource/audit writes (REPO_ROOT=/repo) succeed without a source
+      # bind-mount. Data persists across restarts; no repo source is exposed.
+      - agent-teams-repo-data:/repo
+    command: ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8456"]
+    healthcheck:
+      test: ["CMD-SHELL", "curl -fsS http://localhost:8456/health || exit 1"]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+      start_period: 10s
+
+  web:
+    image: ghcr.io/bankung/agent-teams-web:${AGENT_TEAMS_VERSION:-latest}
+    container_name: agent-teams-web
+    depends_on:
+      api:
+        condition: service_healthy
+    environment:
+      # NEXT_PUBLIC_* vars are baked at image build time (next build ARGs), not
+      # injected at container runtime — setting them here has no effect on the
+      # client bundle. Only runtime-effective server-side vars belong here.
+      INTERNAL_API_URL: ${INTERNAL_API_URL:-http://api:8456}
+    ports:
+      - "${WEB_PORT:-5431}:5431"
+    # No source bind-mount — standalone bundle is baked into the image.
+    healthcheck:
+      test: ["CMD-SHELL", "wget -q --spider http://localhost:5431 || exit 1"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+      start_period: 30s
+
+  langgraph:
+    image: ghcr.io/bankung/agent-teams-langgraph:${AGENT_TEAMS_VERSION:-latest}
+    container_name: agent-teams-langgraph
+    depends_on:
+      db:
+        condition: service_healthy
+      api:
+        condition: service_healthy
+    environment:
+      DATABASE_URI: postgresql://postgres:${POSTGRES_PASSWORD:-postgres}@db:5432/agent_teams?options=-c%20search_path=langgraph
+      LANGGRAPH_LLM_PROVIDER: ${LANGGRAPH_LLM_PROVIDER:-anthropic}
+      ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY:-}
+      OPENAI_API_KEY: ${OPENAI_API_KEY:-}
+      ANTHROPIC_MODEL: ${ANTHROPIC_MODEL:-claude-sonnet-4-6}
+      OPENAI_MODEL: ${OPENAI_MODEL:-gpt-4o}
+      OPENAI_BASE_URL: ${OPENAI_BASE_URL:-}
+      OLLAMA_MODEL: ${OLLAMA_MODEL:-llama3.2}
+      OLLAMA_BASE_URL: ${OLLAMA_BASE_URL:-http://host.docker.internal:11434}
+      DEEPSEEK_API_KEY: ${DEEPSEEK_API_KEY:-}
+      LANGGRAPH_DEEPSEEK_MODEL: ${LANGGRAPH_DEEPSEEK_MODEL:-deepseek-chat}
+      LANGGRAPH_DEEPSEEK_BASE_URL: ${LANGGRAPH_DEEPSEEK_BASE_URL:-https://api.deepseek.com}
+      LANGGRAPH_PROJECT_ID: ${LANGGRAPH_PROJECT_ID:-1}
+      LANGGRAPH_POLL_INTERVAL_SEC: ${LANGGRAPH_POLL_INTERVAL_SEC:-30}
+      LANGGRAPH_KANBAN_API_BASE: ${LANGGRAPH_KANBAN_API_BASE:-http://api:8456}
+      LANGGRAPH_CONTEXT_TOKEN_BUDGET: ${LANGGRAPH_CONTEXT_TOKEN_BUDGET:-60000}
+      HITL_DEMO_ENABLED: ${HITL_DEMO_ENABLED:-}
+      # REPO_ROOT intentionally absent: langgraph uses baked paths / LANGGRAPH_*
+      # vars and does not write to /repo. No volume mount is needed here.
+    ports:
+      - "${LANGGRAPH_PORT:-8465}:8000"
+    # No source bind-mount — code is baked into the image.
+    command: ["uvicorn", "graph:app", "--host", "0.0.0.0", "--port", "8000"]
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/ok')"]
+      interval: 10s
+      timeout: 3s
+      retries: 3
+      start_period: 30s
+
+volumes:
+  agent-teams-pgdata:
+  # Writable persistence for /repo inside the api container (REPO_ROOT=/repo).
+  # Allows scaffold/session/resource/audit writes without a source bind-mount.
+  agent-teams-repo-data:

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@bankung/agent-teams",
+  "version": "0.1.0",
+  "description": "CLI launcher for the agent-teams AI Kanban platform (pull pre-built images, or clone + build locally).",
+  "license": "MIT",
+  "type": "commonjs",
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "agent-teams": "cli/index.js"
+  },
+  "files": [
+    "cli/",
+    "README.md",
+    "docker-compose.images.yml",
+    ".env.example"
+  ],
+  "keywords": [
+    "agent-teams",
+    "kanban",
+    "claude",
+    "ai",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bankung/agent-teams.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}