@agent-compose/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,979 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/index.ts
+import { program } from "commander";
+
+// src/commands/register.ts
+import { Command } from "commander";
+import { existsSync as existsSync2 } from "node:fs";
+import { resolve, basename } from "node:path";
+import { bundleWorkflow } from "@agent-compose/sdk";
+
+// src/config.ts
+import { AgentComposeClient, AgentComposeError } from "@agent-compose/sdk";
+import { InvalidArgumentError } from "commander";
+import { existsSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+function parseUrlFlag(v) {
+  if (!v || !v.trim())
+    throw new InvalidArgumentError("Server URL is empty — set AGENT_COMPOSE_URL or pass --url https://...");
+  try {
+    new URL(v);
+  } catch {
+    throw new InvalidArgumentError(`"${v}" is not a valid URL.`);
+  }
+  if (!/^https?:/.test(v))
+    throw new InvalidArgumentError(`Server URL must be http(s), got "${v}".`);
+  return v;
+}
+var CONFIG_DIR_NAME = ".agentc";
+var SETTINGS_FILE = "settings.json";
+var LOCAL_SETTINGS_FILE = "settings.local.json";
+var GLOBAL_CONFIG_DIR = join(homedir(), ".config", "agentc");
+var GLOBAL_CONFIG_FILE = join(GLOBAL_CONFIG_DIR, SETTINGS_FILE);
+function loadGlobalSettings() {
+  for (const name of [SETTINGS_FILE, "config.json"]) {
+    const path = join(GLOBAL_CONFIG_DIR, name);
+    try {
+      if (existsSync(path))
+        return JSON.parse(readFileSync(path, "utf-8"));
+    } catch {}
+  }
+  return {};
+}
+async function saveGlobalSettings(config) {
+  await Bun.spawn(["mkdir", "-p", GLOBAL_CONFIG_DIR]).exited;
+  await Bun.write(GLOBAL_CONFIG_FILE, JSON.stringify(config, null, 2) + `
+`);
+  await Bun.spawn(["chmod", "600", GLOBAL_CONFIG_FILE]).exited;
+}
+function migrateLegacyConfig(dir, legacyPath) {
+  const { mkdirSync, writeFileSync, unlinkSync } = __require("node:fs");
+  const legacy = JSON.parse(readFileSync(legacyPath, "utf-8"));
+  const newDir = join(dir, CONFIG_DIR_NAME);
+  mkdirSync(newDir, { recursive: true });
+  const envs = {};
+  const keys = {};
+  if (legacy.envs) {
+    for (const [name, def] of Object.entries(legacy.envs)) {
+      if (def.url)
+        envs[name] = { url: def.url, ...def.dashboardUrl ? { dashboardUrl: def.dashboardUrl } : {} };
+      if (def.apiKey)
+        keys[name] = def.apiKey;
+    }
+  }
+  if (Object.keys(envs).length) {
+    writeFileSync(join(newDir, SETTINGS_FILE), JSON.stringify({ envs }, null, 2) + `
+`);
+  }
+  const local = {};
+  if (legacy.env)
+    local.env = legacy.env;
+  if (Object.keys(keys).length)
+    local.keys = keys;
+  if (Object.keys(local).length) {
+    writeFileSync(join(newDir, LOCAL_SETTINGS_FILE), JSON.stringify(local, null, 2) + `
+`);
+  }
+  unlinkSync(legacyPath);
+  console.error(`✓ Migrated .agentc.json → .agentc/  (${dir})
+`);
+}
+function findProjectRoot() {
+  let dir = process.cwd();
+  const root = homedir();
+  while (dir !== root && dir !== dirname(dir)) {
+    const candidate = join(dir, CONFIG_DIR_NAME, SETTINGS_FILE);
+    if (existsSync(candidate)) {
+      try {
+        return [JSON.parse(readFileSync(candidate, "utf-8")), dir];
+      } catch {
+        break;
+      }
+    }
+    const legacyPath = join(dir, ".agentc.json");
+    if (existsSync(legacyPath)) {
+      try {
+        migrateLegacyConfig(dir, legacyPath);
+      } catch {}
+      if (existsSync(candidate)) {
+        try {
+          return [JSON.parse(readFileSync(candidate, "utf-8")), dir];
+        } catch {
+          break;
+        }
+      }
+      break;
+    }
+    dir = dirname(dir);
+  }
+  return [{}, null];
+}
+function loadLocalSettings(projectDir) {
+  if (!projectDir)
+    return {};
+  const path = join(projectDir, CONFIG_DIR_NAME, LOCAL_SETTINGS_FILE);
+  try {
+    if (!existsSync(path))
+      return {};
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+async function saveLocalSettings(projectDir, settings) {
+  const dir = join(projectDir, CONFIG_DIR_NAME);
+  const path = join(dir, LOCAL_SETTINGS_FILE);
+  await Bun.spawn(["mkdir", "-p", dir]).exited;
+  await Bun.write(path, JSON.stringify(settings, null, 2) + `
+`);
+  await Bun.spawn(["chmod", "600", path]).exited;
+}
+var [_project, _projectDir] = findProjectRoot();
+var _local = loadLocalSettings(_projectDir);
+var _global = loadGlobalSettings();
+var _activeEnv = _local.env ?? (_project.envs?.["prod"] ? "prod" : undefined);
+var _envUrl = _activeEnv ? _project.envs?.[_activeEnv]?.url : undefined;
+var _envDashboardUrl = _activeEnv ? _project.envs?.[_activeEnv]?.dashboardUrl : undefined;
+var _envKey = _activeEnv ? _local.keys?.[_activeEnv] : undefined;
+var _envFactory = _activeEnv ? _local.factories?.[_activeEnv] : undefined;
+function fallbackDashboardUrl(env) {
+  return env === "local" ? "http://localhost:3000" : "https://platform.agentcompose.ai";
+}
+var defaultUrl = process.env.AGENT_COMPOSE_URL ?? _envUrl ?? _global.url ?? "https://agent-compose-server.fly.dev";
+var defaultDashboardUrl = process.env.AGENT_COMPOSE_DASHBOARD_URL ?? _envDashboardUrl ?? _global.dashboardUrl ?? fallbackDashboardUrl(_activeEnv);
+var defaultApiKey = process.env.AGENT_COMPOSE_API_KEY ?? _envKey ?? _global.apiKey ?? "";
+var defaultFactory = process.env.AGENT_COMPOSE_FACTORY ?? _envFactory ?? "default";
+var projectDir = _projectDir;
+var projectSettings = _project;
+var localSettings = _local;
+var activeEnv = _activeEnv;
+function makeClient({ url, apiKey }) {
+  if (!apiKey) {
+    console.error(`API key required. Provide via:
+` + `  • Project:     .agentc/settings.local.json
+` + `  • Auth:        agentc auth login YOUR_KEY
+` + `  • Environment: export AGENT_COMPOSE_API_KEY=YOUR_KEY
+` + "  • Flag:        --api-key YOUR_KEY");
+    process.exit(1);
+  }
+  return new AgentComposeClient(url, apiKey);
+}
+function reportSdkError(err) {
+  const msg = err instanceof AgentComposeError ? err.message : err instanceof Error ? err.message : String(err);
+  console.error(`Error: ${msg}`);
+  process.exit(1);
+}
+
+// src/commands/register.ts
+var registerCommand = new Command("register").description("Register a workflow with the server").argument("<workflow>", "Path to the workflow .ts file").option("-n, --name <name>", "Template name (default: workflow filename without extension)").option("-v, --version <version>", "Version tag").option("--schedule <cron>", "Cron expression to run on a schedule (e.g. '*/30 * * * *')").option("--build", "After register, invoke once and wait so a snapshot exists for referencing workflows").option("--build-timeout <minutes>", "Minutes to wait for --build invoke to finish (default 30)", (v) => {
+  const n = Number.parseInt(v, 10);
+  if (!Number.isFinite(n) || n <= 0)
+    throw new Error(`--build-timeout must be a positive integer (got "${v}")`);
+  return n;
+}).option("--factory <slug>", `Factory to register into (default: ${defaultFactory})`, defaultFactory).option("--url <url>", "Server URL", parseUrlFlag, defaultUrl).option("--api-key <key>", "API key", defaultApiKey).action(async (workflowArg, opts) => {
+  const workflowPath = resolve(workflowArg);
+  const name = opts.name ?? basename(workflowPath).replace(/\.(ts|js)$/, "");
+  if (!existsSync2(workflowPath)) {
+    console.error(`Error: workflow not found at ${workflowPath}`);
+    process.exit(1);
+  }
+  const { source, networkPolicy, placeholders, snapshot, saveSnapshot } = await bundleWorkflow(workflowPath);
+  if (networkPolicy)
+    console.log(`[register] Network policy detected — credentials will be brokered via Vercel firewall`);
+  if (snapshot)
+    console.log(`[register] Boots from snapshot: ${snapshot}`);
+  if (saveSnapshot)
+    console.log(`[register] Captures snapshot on success (saveSnapshot: true)`);
+  const client = makeClient(opts);
+  console.log(`[register] Registering "${name}" → factory "${opts.factory}"…`);
+  const result = await client.register({
+    name,
+    source,
+    factorySlug: opts.factory,
+    ...opts.version ? { version: opts.version } : {},
+    ...opts.schedule ? { schedule: opts.schedule } : {},
+    ...networkPolicy ? { networkPolicy } : {},
+    ...placeholders ? { placeholders } : {},
+    ...snapshot ? { snapshot } : {},
+    ...saveSnapshot !== undefined ? { saveSnapshot } : {}
+  });
+  const scheduleNote = opts.schedule ? ` — schedule: ${opts.schedule}` : "";
+  console.log(`✓ Workflow:  ${result.name}@${result.version} (${result.id})${scheduleNote}`);
+  if (!opts.build)
+    return;
+  console.log(`[build] Invoking "${name}" with saveSnapshot:true to capture a snapshot…`);
+  const { id: runId } = await client.invoke(name, {}, { saveSnapshot: true, factorySlug: opts.factory });
+  console.log(`[build] Run: ${runId} — waiting for completion…`);
+  const pollIntervalMs = 2000;
+  const timeoutMinutes = opts.buildTimeout ?? 30;
+  const timeoutMs = timeoutMinutes * 60 * 1000;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const { status } = await client.getStatus(runId);
+    if (status === "success") {
+      console.log(`✓ Snapshot ready — other workflows can now reference \`snapshot: "${name}"\``);
+      return;
+    }
+    if (status === "failed" || status === "abandoned") {
+      console.error(`✗ Build run ${status}: ${runId}`);
+      process.exit(1);
+    }
+    await new Promise((r) => setTimeout(r, pollIntervalMs));
+  }
+  console.error(`✗ Build timed out after ${timeoutMs / 60000}m (run ${runId} still running)`);
+  process.exit(1);
+});
+
+// src/commands/invoke.ts
+import { Command as Command3 } from "commander";
+
+// src/commands/logs.ts
+import { Command as Command2 } from "commander";
+import pc from "picocolors";
+import { AgentComposeError as AgentComposeError2 } from "@agent-compose/sdk";
+function fmt(ms) {
+  if (ms < 60000)
+    return `${(ms / 1000).toFixed(1)}s`;
+  return `${Math.floor(ms / 60000)}m ${Math.floor(ms % 60000 / 1000)}s`;
+}
+function extractToolSnippet(toolInput) {
+  const raw = toolInput ? String(toolInput) : "";
+  return raw.match(/"(?:command|file_path|url|query|pattern)":"([^"]{1,80})/)?.[1] ?? "";
+}
+function printEvent(event, data, state) {
+  switch (event) {
+    case "step_started":
+      process.stdout.write(`
+${pc.dim(`● ${data.step}`)}
+`);
+      break;
+    case "step_completed": {
+      const dur = data.durationMs ? pc.dim(` (${fmt(Number(data.durationMs))})`) : "";
+      process.stdout.write(`  ${pc.green("✓")} ${data.step}${dur}
+`);
+      break;
+    }
+    case "step_failed":
+      process.stdout.write(`  ${pc.red("✗")} ${data.step}: ${pc.dim(String(data.reason ?? ""))}
+`);
+      break;
+    case "agent_spawned": {
+      const name = String(data.agentName ?? data.label ?? "agent");
+      const id = String(data.agentId ?? "");
+      const sbId = data.sandboxId ? String(data.sandboxId).slice(-8) : "";
+      state.agentStart.set(id, Date.now());
+      state.agentLabel.set(id, name);
+      const tag = sbId ? `  ${pc.dim(`[${sbId}]`)}` : "";
+      process.stdout.write(`
+${pc.bold(pc.magenta(`▶ ${name}`))}${tag}
+`);
+      break;
+    }
+    case "agent_settled": {
+      const ok = data.outcome === "success" || data.outcome === "done";
+      const id = String(data.agentId ?? "");
+      const ms = data.durationMs ? Number(data.durationMs) : state.agentStart.get(id) ? Date.now() - state.agentStart.get(id) : 0;
+      const name = state.agentLabel.get(id) ?? String(data.label ?? "agent");
+      const dur = ms > 0 ? `  ${pc.dim(fmt(ms))}` : "";
+      if (ok) {
+        process.stdout.write(`${pc.green(`✓ ${name}`)}${dur}
+`);
+      } else {
+        const reason = data.failureReason ? `
+  ${pc.dim(String(data.failureReason).slice(0, 120))}` : "";
+        process.stdout.write(`${pc.red(`✗ ${name}`)}${dur}${reason}
+`);
+      }
+      break;
+    }
+    case "agent_event": {
+      const { toolName } = data;
+      if (toolName) {
+        const snippet = extractToolSnippet(data.toolInput);
+        const detail = snippet ? `  ${pc.dim(snippet)}` : "";
+        process.stdout.write(`  ${pc.cyan("→")} ${pc.bold(String(toolName))}${detail}
+`);
+      }
+      break;
+    }
+    case "workflow_log": {
+      const msg = String(data.msg ?? "").trim();
+      if (!msg || msg === ".")
+        break;
+      if (/^\[.+\]\[(cwd|init|RAW):/.test(msg))
+        break;
+      if (/^\[.+\]\[stderr\]/.test(msg))
+        break;
+      if (/^\[.+\] iteration \d+\/\d+ · \d+ turns/.test(msg)) {
+        const m = msg.match(/iteration (\d+)\/(\d+)/);
+        if (m)
+          process.stdout.write(`  ${pc.dim(`iteration ${m[1]}/${m[2]}`)}
+`);
+        break;
+      }
+      if (/^\[.+\]\[result:\d+\/\d+\/\w+\]/.test(msg)) {
+        const m = msg.match(/\[result:(\d+)\/(\d+)\/(\w+)\]/);
+        if (m)
+          process.stdout.write(`  ${pc.dim(`${m[3]}  ${m[1]}/${m[2]} turns`)}
+`);
+        break;
+      }
+      if (/^\[.+\] iteration \d+ status:/.test(msg)) {
+        const m = msg.match(/blockers=\[([^\]]+)\]/);
+        if (m?.[1]) {
+          const blockers = m[1].replace(/^"|"$/g, "").trim();
+          if (blockers)
+            process.stdout.write(`  ${pc.yellow(`⚠ ${blockers.slice(0, 120)}`)}
+`);
+        }
+        break;
+      }
+      if (/^\[.+\] (Bash|Read|Write|Edit|Glob|Grep|Agent|TodoWrite|ToolSearch|WebFetch|WebSearch)\(/.test(msg))
+        break;
+      if (/^\[.+\] (iteration|continuing|done after|stalled|exhausted|circuit break)/.test(msg))
+        break;
+      const lvl = String(data.level ?? "info");
+      const color = lvl === "error" ? pc.red : lvl === "warn" ? pc.yellow : pc.dim;
+      process.stdout.write(`${color(msg)}
+`);
+      break;
+    }
+    case "run_complete": {
+      const elapsed = fmt(Date.now() - state.startedAt);
+      process.stdout.write(`
+${pc.bold(pc.green("✓ Run complete"))}  ${pc.dim(elapsed)}
+`);
+      break;
+    }
+    case "run_failed": {
+      const reason = data.reason ? `
+${pc.dim(String(data.reason).slice(0, 200))}` : "";
+      process.stdout.write(`
+${pc.bold(pc.red("✗ Run failed"))}${reason}
+`);
+      break;
+    }
+    case "run_canceled":
+      process.stdout.write(`
+${pc.bold(pc.yellow("⊘ Run canceled"))}
+`);
+      break;
+  }
+}
+var TERMINAL_EVENTS = new Set(["run_complete", "run_failed", "run_canceled"]);
+async function streamLogs(runId, opts) {
+  const client = makeClient(opts);
+  const state = {
+    agentStart: new Map,
+    agentLabel: new Map,
+    startedAt: Date.now()
+  };
+  let lastSeq = 0;
+  const MAX_RETRIES = 5;
+  for (let attempt = 0;attempt <= MAX_RETRIES; attempt++) {
+    let settled = false;
+    try {
+      for await (const ev of client.streamRunLogs(runId, { lastEventId: lastSeq })) {
+        const seq = ev.seq ?? 0;
+        if (seq > 0)
+          lastSeq = seq;
+        printEvent(ev.event, ev, state);
+        if (TERMINAL_EVENTS.has(ev.event)) {
+          settled = true;
+          break;
+        }
+      }
+    } catch (err) {
+      if (err instanceof AgentComposeError2) {
+        console.error(`Error: failed to connect to log stream (${err.status})`);
+        process.exit(1);
+      }
+      throw err;
+    }
+    if (settled)
+      return;
+    if (attempt < MAX_RETRIES)
+      await new Promise((r) => setTimeout(r, 200));
+  }
+  console.error("Error: stream closed without terminal event after retries");
+  process.exit(1);
+}
+var logsCommand = new Command2("logs").description("Stream logs for a run").argument("<run-id>", "Run ID").option("--url <url>", "Server URL", parseUrlFlag, defaultUrl).option("--api-key <key>", "API key", defaultApiKey).action(async (runId, opts) => {
+  await streamLogs(runId, opts);
+});
+
+// src/commands/invoke.ts
+var invokeCommand = new Command3("invoke").description("Invoke a registered workflow template").argument("<template>", "Template name").option("-i, --input <json>", "Input as JSON string").option("-f, --follow", "Stream logs after invoking").option("--factory <slug>", `Factory the template lives in (default: ${defaultFactory})`, defaultFactory).option("--url <url>", "Server URL", parseUrlFlag, defaultUrl).option("--api-key <key>", "API key", defaultApiKey).action(async (template, opts) => {
+  let input;
+  if (opts.input) {
+    try {
+      input = JSON.parse(opts.input);
+    } catch {
+      console.error("Error: --input must be valid JSON");
+      process.exit(1);
+    }
+  }
+  const client = makeClient(opts);
+  const { id } = await client.invoke(template, input, { factorySlug: opts.factory });
+  console.log(`Run started: ${id}`);
+  if (opts.follow)
+    await streamLogs(id, opts);
+});
+
+// src/commands/list.ts
+import { Command as Command4 } from "commander";
+var listCommand = new Command4("list").description("List registered workflow templates").option("--factory <slug>", "Scope to a factory (default: every factory in your team)").option("--url <url>", "Server URL", parseUrlFlag, defaultUrl).option("--api-key <key>", "API key", defaultApiKey).action(async (opts) => {
+  const factorySlug = opts.factory ?? (defaultFactory !== "default" ? defaultFactory : undefined);
+  const templates = await makeClient(opts).listTemplates(factorySlug ? { factorySlug } : undefined);
+  if (templates.length === 0) {
+    const scope = factorySlug ? ` in factory "${factorySlug}"` : "";
+    console.log(`No templates registered${scope}.`);
+    return;
+  }
+  for (const t of templates)
+    console.log(`${t.name}  ${t.version}`);
+});
+
+// src/commands/init.ts
+import { Command as Command5 } from "commander";
+import {
+  existsSync as existsSync3,
+  mkdirSync,
+  copyFileSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  appendFileSync,
+  unlinkSync,
+  rmSync,
+  statSync
+} from "node:fs";
+import { resolve as resolve2, join as join2, dirname as dirname2 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir as homedir2 } from "node:os";
+var BUN_PATH_LINE = 'export PATH="$HOME/.bun/bin:$PATH"';
+function shellConfigFile() {
+  const shell = process.env.SHELL ?? "";
+  if (shell.includes("zsh"))
+    return join2(homedir2(), ".zshrc");
+  if (shell.includes("fish"))
+    return join2(homedir2(), ".config", "fish", "config.fish");
+  return join2(homedir2(), ".bashrc");
+}
+function ensureBunInPath() {
+  const configFile = shellConfigFile();
+  try {
+    const content = existsSync3(configFile) ? readFileSync2(configFile, "utf-8") : "";
+    if (content.includes(".bun/bin")) {
+      console.log(`✓ ~/.bun/bin already in PATH  (${configFile})`);
+      return;
+    }
+    appendFileSync(configFile, `
+${BUN_PATH_LINE}
+`);
+    console.log(`✓ Added ~/.bun/bin to PATH  →  ${configFile}`);
+    console.log("  Run: source " + configFile);
+  } catch {
+    console.warn(`  Could not update ${configFile} — add this manually:`);
+    console.warn(`  ${BUN_PATH_LINE}`);
+  }
+}
+function readDescription(filePath) {
+  const content = readFileSync2(filePath, "utf-8");
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/m);
+  if (!fmMatch)
+    return;
+  const descMatch = fmMatch[1].match(/^description:\s*(.+)$/m);
+  return descMatch?.[1].trim();
+}
+function locateSkillsDir(name) {
+  const here = dirname2(fileURLToPath(import.meta.url));
+  const candidates = [
+    resolve2(here, "..", "..", name),
+    resolve2(here, "..", name)
+  ];
+  return candidates.find(existsSync3) ?? null;
+}
+function cleanupLegacyCommands() {
+  const legacyDir = join2(homedir2(), ".claude", "commands");
+  if (!existsSync3(legacyDir))
+    return 0;
+  let removed = 0;
+  for (const entry of readdirSync(legacyDir)) {
+    if (entry.startsWith("ac:") && entry.endsWith(".md")) {
+      try {
+        unlinkSync(join2(legacyDir, entry));
+        removed++;
+      } catch {}
+    }
+  }
+  return removed;
+}
+function loadSource(dir) {
+  if (!dir)
+    return null;
+  const files = readdirSync(dir).filter((f) => f.endsWith(".md"));
+  return { dir, files };
+}
+var initCommand = new Command5("init").description("Install agentc Claude Code skills and ensure PATH is configured").option("--dev", "Also install dev-only skills from cli/skills-dev/ (clone install only)").action((opts) => {
+  ensureBunInPath();
+  const publicSrc = loadSource(locateSkillsDir("skills"));
+  if (!publicSrc) {
+    console.error("Error: skills directory not found — reinstall agentc");
+    process.exit(1);
+  }
+  const devSrc = opts.dev ? loadSource(locateSkillsDir("skills-dev")) : null;
+  if (opts.dev && !devSrc) {
+    console.log(`
+Note: --dev passed but cli/skills-dev/ is not present. Dev skills ` + "are not bundled with npm installs of @agent-compose/cli — clone the " + "repo (https://github.com/Layr-Labs/agent-compose) and re-run from there " + "to install them.");
+  }
+  const targetRoot = join2(homedir2(), ".claude", "skills");
+  mkdirSync(targetRoot, { recursive: true });
+  const wanted = [
+    ...publicSrc.files.map((file) => ({ src: publicSrc, file })),
+    ...(devSrc?.files ?? []).map((file) => ({ src: devSrc, file }))
+  ];
+  const wantedNames = new Set(wanted.map((w) => w.file.replace(".md", "")));
+  for (const existing of readdirSync(targetRoot)) {
+    if (!existing.startsWith("ac:"))
+      continue;
+    const path = join2(targetRoot, existing);
+    if (!statSync(path).isDirectory())
+      continue;
+    if (wantedNames.has(existing))
+      continue;
+    rmSync(path, { recursive: true, force: true });
+    console.log(`✗ Removed  /${existing}`);
+  }
+  console.log(`
+Installed skills${opts.dev ? " (dev mode)" : ""}:`);
+  for (const { src, file } of [...wanted].sort((a, b) => a.file.localeCompare(b.file))) {
+    const name = file.replace(".md", "");
+    const dir = join2(targetRoot, name);
+    mkdirSync(dir, { recursive: true });
+    copyFileSync(join2(src.dir, file), join2(dir, "SKILL.md"));
+    const description = readDescription(join2(src.dir, file)) ?? "";
+    console.log(`  ${("/" + name).padEnd(28)} ${description}`);
+  }
+  const legacyRemoved = cleanupLegacyCommands();
+  if (legacyRemoved > 0) {
+    console.log(`
+  Cleaned up ${legacyRemoved} legacy ac:* file${legacyRemoved > 1 ? "s" : ""} from ~/.claude/commands/`);
+  }
+  const inactiveDev = !opts.dev ? loadSource(locateSkillsDir("skills-dev"))?.files.length ?? 0 : 0;
+  const note = inactiveDev > 0 ? ` (${inactiveDev} dev-only skill${inactiveDev > 1 ? "s" : ""} available — re-run with --dev to include)` : "";
+  console.log(`
+${wanted.length} skill(s) installed to ${targetRoot}${note}`);
+  console.log("  Run /reload-plugins in Claude Code to pick them up immediately.");
+});
+
+// src/commands/keys.ts
+import { Command as Command6 } from "commander";
+import { AgentComposeClient as AgentComposeClient2 } from "@agent-compose/sdk";
+var DURATION_UNITS = {
+  s: 1000,
+  m: 60000,
+  h: 3600000,
+  d: 86400000,
+  w: 86400000 * 7
+};
+function parseDuration(s) {
+  if (!/^(\d+[smhdw])+$/.test(s))
+    throw new Error(`Invalid duration "${s}". Expected e.g. "30d", "2h", "7d12h".`);
+  let total = 0;
+  for (const m of s.matchAll(/(\d+)([smhdw])/g))
+    total += parseInt(m[1], 10) * DURATION_UNITS[m[2]];
+  return total;
+}
+function requireAdminKey(adminKey) {
+  if (adminKey)
+    return;
+  console.error(`Admin-scoped ac_… key required. Provide via:
+` + `  • Flag:        --admin-key ac_…
+` + `  • Environment: export AGENT_COMPOSE_ADMIN_KEY=ac_…
+` + "Mint your first admin key by signing into the dashboard.");
+  process.exit(1);
+}
+var keysCommand = new Command6("keys").description("Manage API keys");
+keysCommand.command("create <name>").description("Create a new API key (requires admin-scoped ac_… key)").option("--url <url>", "Server URL", parseUrlFlag, defaultUrl).option("--admin-key <key>", "Admin-scoped ac_… key (or AGENT_COMPOSE_ADMIN_KEY env var)", process.env.AGENT_COMPOSE_ADMIN_KEY ?? "").option("--scopes <list>", "Comma-separated scope list: read, invoke, admin. Default (empty) = full team access.").option("--expires-in <duration>", `Expire the key after this duration — e.g. "30d", "2h", "7d12h", "1w", "90m". Default: never.`).option("--factory <slug>", "Restrict the key to a single factory (slug). Default: team-wide.").action(async (name, opts) => {
+  requireAdminKey(opts.adminKey);
+  const scopes = opts.scopes ? opts.scopes.split(",").map((s) => s.trim()).filter(Boolean) : undefined;
+  let expiresAt;
+  if (opts.expiresIn) {
+    try {
+      expiresAt = new Date(Date.now() + parseDuration(opts.expiresIn)).toISOString();
+    } catch (err) {
+      console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+  }
+  const client = new AgentComposeClient2(opts.url, opts.adminKey);
+  const created = await client.createApiKey({
+    name,
+    ...scopes && { scopes },
+    ...expiresAt && { expiresAt },
+    ...opts.factory && { factorySlug: opts.factory }
+  }).catch(reportSdkError);
+  console.log(`
+API key created for "${name}":
+`);
+  console.log(`  ${created.key}
+`);
+  console.log(`  id:         ${created.id}`);
+  console.log(`  preview:    ac_…${created.last4 ?? "????"}`);
+  console.log(`  scopes:     ${scopes?.join(", ") || "(full team access)"}`);
+  console.log(`  factory:    ${opts.factory ?? "(team-wide)"}`);
+  console.log(`  expires:    ${created.expiresAt ? new Date(created.expiresAt).toISOString() : "never"}
+`);
+  console.log(`Share this with the user. They can save it permanently with:`);
+  console.log(`  agentc auth login ${created.key}
+`);
+});
+keysCommand.command("list").description("List API keys for your team (requires admin-scoped ac_… key)").option("--url <url>", "Server URL", parseUrlFlag, defaultUrl).option("--admin-key <key>", "Admin-scoped ac_… key", process.env.AGENT_COMPOSE_ADMIN_KEY ?? "").action(async (opts) => {
+  requireAdminKey(opts.adminKey);
+  const client = new AgentComposeClient2(opts.url, opts.adminKey);
+  const data = await client.listApiKeys().catch(reportSdkError);
+  if (!data.length) {
+    console.log("No API keys.");
+    return;
+  }
+  const fmt2 = (d) => d ? new Date(d).toISOString().slice(0, 10) : "—";
+  for (const k of data) {
+    const status = k.revokedAt ? "revoked" : k.expiresAt && new Date(k.expiresAt) < new Date ? "expired" : "active";
+    const scopes = k.scopes.length > 0 ? k.scopes.join(",") : "full";
+    const id = `ac_…${k.last4 ?? "????"}`;
+    const factory = k.factoryId ? `factory:${k.factoryId}` : "factory:team-wide";
+    console.log(`${k.name ?? "(unnamed)"}  ${id}  ${k.id}  [${scopes}]  ${factory}  ${status}  created:${fmt2(k.createdAt)}  last_used:${fmt2(k.lastUsedAt)}  expires:${fmt2(k.expiresAt)}`);
+  }
+});
+
+// src/commands/auth.ts
+import { Command as Command7 } from "commander";
+var authCommand = new Command7("auth").description("Manage authentication");
+authCommand.command("login <key>").description("Save an API key for the active environment").action(async (key) => {
+  if (projectDir && activeEnv) {
+    if (!projectSettings.envs?.[activeEnv]) {
+      console.error(`Environment "${activeEnv}" is not defined in .agentc/settings.json`);
+      process.exit(1);
+    }
+    await saveLocalSettings(projectDir, {
+      ...localSettings,
+      keys: { ...localSettings.keys, [activeEnv]: key }
+    });
+    console.log(`
+✓ API key saved for "${activeEnv}" in .agentc/settings.local.json
+`);
+  } else if (projectDir) {
+    console.error(`No active environment. Set "env" in .agentc/settings.local.json first.
+` + `Available: ${Object.keys(projectSettings.envs ?? {}).join(", ") || "(none)"}`);
+    process.exit(1);
+  } else {
+    const existing = loadGlobalSettings();
+    await saveGlobalSettings({ ...existing, apiKey: key });
+    console.log(`
+✓ API key saved to ${GLOBAL_CONFIG_FILE}
+`);
+  }
+});
+authCommand.command("logout").description("Remove the API key for the active environment").action(async () => {
+  if (projectDir && activeEnv) {
+    if (!localSettings.keys?.[activeEnv]) {
+      console.log(`No API key stored for "${activeEnv}".`);
+      return;
+    }
+    const { [activeEnv]: _, ...rest } = localSettings.keys;
+    await saveLocalSettings(projectDir, { ...localSettings, keys: rest });
+    console.log(`✓ API key removed for "${activeEnv}".`);
+  } else {
+    const existing = loadGlobalSettings();
+    const { apiKey: _, ...rest } = existing;
+    await saveGlobalSettings(rest);
+    console.log(`✓ API key removed from ${GLOBAL_CONFIG_FILE}.`);
+  }
+});
+authCommand.command("status").description("Show the resolved configuration").action(() => {
+  if (activeEnv) {
+    console.log(`Env:     ${activeEnv}`);
+  }
+  if (process.env.AGENT_COMPOSE_URL) {
+    console.log(`Server:    ${defaultUrl}  ($AGENT_COMPOSE_URL)`);
+  } else if (activeEnv && projectSettings.envs?.[activeEnv]?.url) {
+    console.log(`Server:    ${defaultUrl}  (.agentc/settings.json → ${activeEnv})`);
+  } else {
+    console.log(`Server:    ${defaultUrl}`);
+  }
+  if (process.env.AGENT_COMPOSE_DASHBOARD_URL) {
+    console.log(`Dashboard: ${defaultDashboardUrl}  ($AGENT_COMPOSE_DASHBOARD_URL)`);
+  } else if (activeEnv && projectSettings.envs?.[activeEnv]?.dashboardUrl) {
+    console.log(`Dashboard: ${defaultDashboardUrl}  (.agentc/settings.json → ${activeEnv})`);
+  } else {
+    console.log(`Dashboard: ${defaultDashboardUrl}`);
+  }
+  if (process.env.AGENT_COMPOSE_FACTORY) {
+    console.log(`Factory:   ${defaultFactory}  ($AGENT_COMPOSE_FACTORY)`);
+  } else if (activeEnv && localSettings.factories?.[activeEnv]) {
+    console.log(`Factory:   ${defaultFactory}  (.agentc/settings.local.json → ${activeEnv})`);
+  } else {
+    console.log(`Factory:   ${defaultFactory}  (default)`);
+  }
+  if (process.env.AGENT_COMPOSE_API_KEY) {
+    console.log(`API key: set  ($AGENT_COMPOSE_API_KEY)`);
+  } else if (activeEnv && localSettings.keys?.[activeEnv]) {
+    console.log(`API key: set  (.agentc/settings.local.json → ${activeEnv})`);
+  } else if (defaultApiKey) {
+    console.log(`API key: set  (${GLOBAL_CONFIG_FILE})`);
+  } else {
+    console.log("API key: not set");
+    console.log(`
+Run: agentc auth login YOUR_KEY`);
+  }
+});
+
+// src/commands/secrets.ts
+import { Command as Command8 } from "commander";
+var sharedOpts = (cmd) => cmd.option("--factory <slug>", `Factory the workflow lives in (default: ${defaultFactory})`, defaultFactory).option("--url <url>", "Server URL", parseUrlFlag, defaultUrl).option("--api-key <key>", "API key", defaultApiKey);
+var secretsCommand = new Command8("secrets").description("Manage workflow secrets stored in GCP Secret Manager");
+sharedOpts(secretsCommand.command("set <workflow> <key> <value>").description("Create or update a secret for a workflow")).action(async (workflow, key, value, opts) => {
+  const client = makeClient(opts);
+  await client.setSecret(workflow, key, value, { factorySlug: opts.factory });
+  console.log(`✓ Secret "${key}" set for workflow "${workflow}" in factory "${opts.factory}"`);
+});
+sharedOpts(secretsCommand.command("list <workflow>").description("List secrets registered for a workflow (metadata only)")).action(async (workflow, opts) => {
+  const client = makeClient(opts);
+  const secrets = await client.listSecrets(workflow, { factorySlug: opts.factory });
+  if (secrets.length === 0) {
+    console.log(`No secrets registered for workflow "${workflow}" in factory "${opts.factory}"`);
+    return;
+  }
+  console.log(`Secrets for "${workflow}" in factory "${opts.factory}":`);
+  for (const s of secrets) {
+    console.log(`  ${s.key}  (updated ${new Date(s.updatedAt).toLocaleString()})`);
+  }
+});
+sharedOpts(secretsCommand.command("delete <workflow> <key>").description("Delete a secret for a workflow")).action(async (workflow, key, opts) => {
+  const client = makeClient(opts);
+  await client.deleteSecret(workflow, key, { factorySlug: opts.factory });
+  console.log(`✓ Secret "${key}" deleted from workflow "${workflow}" in factory "${opts.factory}"`);
+});
+
+// src/commands/usage.ts
+import { Command as Command9 } from "commander";
+function parseMonth(s) {
+  const m = /^(\d{4})-(\d{1,2})$/.exec(s);
+  if (!m)
+    throw new Error(`--month must be YYYY-MM, got "${s}"`);
+  const year = parseInt(m[1], 10);
+  const month = parseInt(m[2], 10) - 1;
+  if (month < 0 || month > 11)
+    throw new Error(`Invalid month "${s}"`);
+  return { from: new Date(Date.UTC(year, month, 1)), to: new Date(Date.UTC(year, month + 1, 1)) };
+}
+function fmtSeconds(s) {
+  if (s < 60)
+    return `${s.toFixed(1)}s`;
+  if (s < 3600)
+    return `${Math.floor(s / 60)}m ${Math.floor(s % 60)}s`;
+  const h = Math.floor(s / 3600);
+  return `${h}h ${Math.floor(s % 3600 / 60)}m`;
+}
+var usageCommand = new Command9("usage").description("Show billable usage — runs + sandbox seconds — for the current team").option("--url <url>", "Server URL", parseUrlFlag, defaultUrl).option("--api-key <key>", "API key", defaultApiKey).option("--month <yyyy-mm>", "Calendar month to report (default: current month, UTC)").option("--from <iso>", "Window start (ISO 8601) — overrides --month").option("--to <iso>", "Window end (ISO 8601)   — overrides --month").action(async (opts) => {
+  let from, to;
+  if (opts.from || opts.to) {
+    if (!opts.from || !opts.to) {
+      console.error("Error: --from and --to must be provided together");
+      process.exit(1);
+    }
+    from = new Date(opts.from);
+    to = new Date(opts.to);
+    if (Number.isNaN(from.getTime()) || Number.isNaN(to.getTime())) {
+      console.error("Error: --from and --to must be ISO timestamps");
+      process.exit(1);
+    }
+  } else {
+    try {
+      ({ from, to } = opts.month ? parseMonth(opts.month) : (() => {
+        const n = new Date;
+        return { from: new Date(Date.UTC(n.getUTCFullYear(), n.getUTCMonth(), 1)), to: new Date(Date.UTC(n.getUTCFullYear(), n.getUTCMonth() + 1, 1)) };
+      })());
+    } catch (err) {
+      console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(1);
+    }
+  }
+  const client = makeClient(opts);
+  const body = await client.getUsage(from, to).catch(reportSdkError);
+  console.log(`
+Usage ${from.toISOString().slice(0, 10)} → ${to.toISOString().slice(0, 10)}
+`);
+  const runs = body.data.filter((r) => r.eventType === "run.settled");
+  const runsSuccess = runs.filter((r) => r.tags.status === "success").reduce((a, r) => a + r.total, 0);
+  const runsFailed = runs.filter((r) => r.tags.status === "failed").reduce((a, r) => a + r.total, 0);
+  console.log(`  runs completed:  ${String(runsSuccess).padStart(8)}`);
+  console.log(`  runs failed:     ${String(runsFailed).padStart(8)}`);
+  const seconds = body.data.filter((r) => r.eventType === "sandbox.seconds");
+  const totalSec = seconds.reduce((a, r) => a + r.total, 0);
+  if (totalSec > 0) {
+    console.log(`
+  sandbox seconds: ${String(Math.floor(totalSec)).padStart(8)}  (${fmtSeconds(totalSec)})`);
+    const grouped = new Map;
+    for (const r of seconds) {
+      const key = `${r.tags.sandbox_kind ?? "?"} (${r.tags.provider ?? "?"})`;
+      grouped.set(key, (grouped.get(key) ?? 0) + r.total);
+    }
+    for (const [k, v] of [...grouped].sort((a, b) => b[1] - a[1])) {
+      console.log(`    ${k.padEnd(26)} ${String(Math.floor(v)).padStart(8)}  (${fmtSeconds(v)})`);
+    }
+  } else {
+    console.log(`
+  sandbox seconds: 0`);
+  }
+  console.log();
+});
+
+// src/commands/snapshot.ts
+import { Command as Command10 } from "commander";
+var snapshotCommand = new Command10("snapshot").description("Manage captured sandbox snapshots");
+snapshotCommand.command("list").description("List runs that have a captured sandbox snapshot").option("-w, --workflow <name>", "Filter to a single workflow").option("--limit <n>", "Max rows to show (default 50, max 500)", (v) => parseInt(v, 10)).option("--url <url>", "Server URL", parseUrlFlag, defaultUrl).option("--api-key <key>", "API key", defaultApiKey).action(async (opts) => {
+  const rows = await makeClient(opts).listSnapshots({
+    ...opts.workflow ? { workflow: opts.workflow } : {},
+    ...opts.limit != null ? { limit: opts.limit } : {}
+  });
+  if (rows.length === 0) {
+    console.log("No captured snapshots.");
+    return;
+  }
+  for (const r of rows) {
+    const wfRef = r.workflow ? `${r.workflow}${r.version ? `@${r.version}` : ""}` : "-";
+    const when = r.endedAt ?? "-";
+    console.log(`${r.runId}  ${wfRef}  ${when}  ${r.vercelSnapshotId}`);
+  }
+});
+snapshotCommand.command("delete").description("Delete the snapshot captured by a specific run").argument("<run-id>", "Run ID (UUID)").option("--url <url>", "Server URL", parseUrlFlag, defaultUrl).option("--api-key <key>", "API key", defaultApiKey).action(async (runId, opts) => {
+  await makeClient(opts).deleteSnapshot(runId);
+  console.log(`✓ Deleted snapshot for run ${runId}`);
+});
+
+// src/commands/factory.ts
+import { Command as Command11 } from "commander";
+import { AgentComposeError as AgentComposeError3 } from "@agent-compose/sdk";
+var factoryCommand = new Command11("factory").description("Manage factories (projects within your team)");
+var SLUG_PATTERN = /^[a-z][a-z0-9-]*$/;
+var SLUG_MAX_LEN = 64;
+function validateSlugOrExit(slug) {
+  if (!SLUG_PATTERN.test(slug) || slug.length > SLUG_MAX_LEN) {
+    console.error(`Error: slug "${slug}" must be lowercase kebab-case, start with a letter, ` + `max ${SLUG_MAX_LEN} chars (e.g. "mvp-project")`);
+    process.exit(1);
+  }
+}
+factoryCommand.command("list").description("List factories in your team").option("--url <url>", "Server URL", parseUrlFlag, defaultUrl).option("--api-key <key>", "API key", defaultApiKey).action(async (opts) => {
+  const client = makeClient(opts);
+  const factories = await client.listFactories();
+  if (factories.length === 0) {
+    console.log("No factories. Run `agentc factory create <slug> -n <name>` to make one.");
+    return;
+  }
+  const active = defaultFactory;
+  for (const f of factories) {
+    const marker = f.slug === active ? "*" : " ";
+    const desc = f.description ? `  — ${f.description}` : "";
+    console.log(`${marker} ${f.slug.padEnd(24)} ${f.name}${desc}`);
+  }
+  console.log("\n* = active factory (use `agentc factory use <slug>` to change)");
+});
+factoryCommand.command("create <slug>").description("Create a factory").option("-n, --name <name>", "Human-readable name (defaults to the slug)").option("-d, --description <text>", "Optional description").option("--url <url>", "Server URL", parseUrlFlag, defaultUrl).option("--api-key <key>", "API key", defaultApiKey).action(async (slug, opts) => {
+  validateSlugOrExit(slug);
+  const client = makeClient(opts);
+  const created = await client.createFactory({
+    slug,
+    name: opts.name ?? slug,
+    ...opts.description ? { description: opts.description } : {}
+  });
+  console.log(`✓ Factory "${created.slug}" created (${created.id})`);
+});
+factoryCommand.command("use <slug>").description("Set the active factory for the current environment").option("--no-verify", "Skip the server-side existence check (offline workflows)").option("--url <url>", "Server URL", parseUrlFlag, defaultUrl).option("--api-key <key>", "API key", defaultApiKey).action(async (slug, opts) => {
+  if (!projectDir || !activeEnv) {
+    console.error("No active environment. `factory use` writes the active factory to\n" + `.agentc/settings.local.json scoped per env. Set up an env first via
+` + "`agentc auth login <key>` (which assumes the project's settings.json\n" + "defines an `envs` block).");
+    process.exit(1);
+  }
+  if (opts.verify) {
+    try {
+      await makeClient(opts).getFactory(slug);
+    } catch (err) {
+      if (err instanceof AgentComposeError3 && err.status === 404) {
+        console.error(`Error: factory "${slug}" not found on the server.
+` + "  Run `agentc factory list` to see available factories,\n" + "  or `agentc factory create <slug>` to make a new one.\n" + "  Pass --no-verify to pin anyway (e.g. before creating).");
+        process.exit(1);
+      }
+      throw err;
+    }
+  }
+  await saveLocalSettings(projectDir, {
+    ...localSettings,
+    factories: { ...localSettings.factories ?? {}, [activeEnv]: slug }
+  });
+  console.log(`✓ Active factory for "${activeEnv}" set to "${slug}".`);
+});
+factoryCommand.command("delete <slug>").description("Delete a factory (refuses `default` and any factory still containing workflows)").option("--yes", "Skip the confirmation prompt").option("--url <url>", "Server URL", parseUrlFlag, defaultUrl).option("--api-key <key>", "API key", defaultApiKey).action(async (slug, opts) => {
+  if (slug === "default") {
+    console.error("Error: cannot delete the `default` factory — it's the back-compat anchor for legacy callers.");
+    process.exit(1);
+  }
+  if (!opts.yes) {
+    process.stdout.write(`Delete factory "${slug}"? [y/N] `);
+    const answer = await new Promise((resolve3) => {
+      process.stdin.once("data", (b) => resolve3(b.toString().trim().toLowerCase()));
+    });
+    if (answer !== "y" && answer !== "yes") {
+      console.log("Aborted.");
+      process.exit(0);
+    }
+  }
+  await makeClient(opts).deleteFactory(slug);
+  console.log(`✓ Factory "${slug}" deleted.`);
+});
+factoryCommand.command("show").description("Show the active factory + how it's resolved").action(() => {
+  if (process.env.AGENT_COMPOSE_FACTORY) {
+    console.log(`Active factory: ${defaultFactory}  ($AGENT_COMPOSE_FACTORY)`);
+    return;
+  }
+  if (activeEnv && localSettings.factories?.[activeEnv]) {
+    console.log(`Active factory: ${defaultFactory}  (.agentc/settings.local.json → ${activeEnv})`);
+    return;
+  }
+  console.log(`Active factory: ${defaultFactory}  (default fallback)`);
+});
+
+// src/commands/cancel.ts
+import { Command as Command12 } from "commander";
+import pc2 from "picocolors";
+var cancelCommand = new Command12("cancel").description("Cancel an in-progress run").argument("<run-id>", "Run ID").option("--url <url>", "Server URL", parseUrlFlag, defaultUrl).option("--api-key <key>", "API key", defaultApiKey).option("--wait", "Stream the run's events until it terminates").action(async (runId, opts) => {
+  const client = makeClient(opts);
+  const res = await client.cancelRun(runId).catch(reportSdkError);
+  if (res.status === "canceled") {
+    console.log(`${pc2.yellow("⊘")} canceled ${runId} at ${new Date(res.canceledAt).toISOString()}`);
+  } else {
+    console.log(`${pc2.dim("⊘")} run ${runId} already ${res.status} at ${new Date(res.canceledAt).toISOString()}`);
+  }
+  if (opts.wait)
+    await streamLogs(runId, opts);
+});
+
+// src/index.ts
+program.name("agentc").description("CLI for agent-compose — register, invoke, and monitor workflows").version("0.1.0");
+program.addCommand(registerCommand);
+program.addCommand(invokeCommand);
+program.addCommand(listCommand);
+program.addCommand(logsCommand);
+program.addCommand(initCommand);
+program.addCommand(keysCommand);
+program.addCommand(authCommand);
+program.addCommand(secretsCommand);
+program.addCommand(usageCommand);
+program.addCommand(snapshotCommand);
+program.addCommand(factoryCommand);
+program.addCommand(cancelCommand);
+program.parse();