@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/dist/cli-zpep9q5e.js

@@ -0,0 +1,491 @@
+import {
+  ProjectTrustStore,
+  addMcpServerConfig,
+  getMcpToolExposure,
+  loadMcpConfig,
+  openBrowser,
+  removeMcpServerConfig,
+  validateMcpServerConfig
+} from "./cli-0x01kwrd.js";
+import {
+  McpOAuthCredentialStore,
+  McpServerConnection,
+  McpServerLog,
+  McpSignInCancelledError,
+  createDefaultTransport,
+  signInMcpServer
+} from "./cli-v7fn5gms.js";
+import"./cli-447dt1h3.js";
+import {
+  APP_NAME,
+  CONFIG_DIR_NAME,
+  source_default
+} from "./cli-d5czme6m.js";
+import"./cli-5bfdm1ah.js";
+import"./cli-0m7wct0d.js";
+import"./cli-rykfmgwg.js";
+import"./cli-0xqde53b.js";
+import"./cli-pqetb83f.js";
+import"./cli-bc05qbss.js";
+
+// node_modules/@earendil-works/pi-coding-agent/dist/extensions/mcp/cli.js
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline/promises";
+var HELP = `${source_default.bold("Usage:")}
+  ${APP_NAME} mcp add <server> [options] -- <command> [args...]
+  ${APP_NAME} mcp add <server> [options] --url <url>
+  ${APP_NAME} mcp remove <server> [-l]
+  ${APP_NAME} mcp list [--json]
+  ${APP_NAME} mcp login <server> [--timeout <seconds>]
+  ${APP_NAME} mcp logout <server>
+
+Configure and check MCP servers and sign in to OAuth servers without starting a session.
+Reads ~/${CONFIG_DIR_NAME}/agent/mcp.json and, in trusted projects, ${CONFIG_DIR_NAME}/mcp.json.
+
+Commands:
+  add <server>            Add or replace a server in mcp.json
+  remove <server>         Remove a server from mcp.json
+  list                    Show state, tools, and errors (exits 1 on failure)
+  login <server>          Sign in through the browser
+  logout <server>         Delete the stored OAuth credentials
+
+Options for add and remove:
+  -l, --local             Use ${CONFIG_DIR_NAME}/mcp.json in the current project instead of the global file
+
+Options for add:
+  --url <url>             Streamable HTTP server URL (instead of a command)
+  --env <KEY=VALUE>       Environment variable for a stdio server (repeatable)
+  --cwd <dir>             Working directory for a stdio server
+  --header <KEY=VALUE>    HTTP header (repeatable)
+  --bearer-token-env-var <NAME>
+                          Send "Authorization: Bearer \${NAME}"
+  --oauth-client-id <id>  Pre-registered OAuth client id
+  --oauth-client-secret <secret>
+                          OAuth client secret (may be \${NAME} or !command)
+  --oauth-callback-port <port>
+                          Fixed OAuth callback port
+  --oauth-client-name <name>
+                          Client name sent when registering with the OAuth server
+  --exposure <mode>       codemode (default), deferred, direct, or hidden
+  --description <text>    What the server offers, shown in the system prompt
+
+Other options:
+  --json                  Print the list as JSON
+  --timeout <seconds>     How long login waits for the browser (default: 300)`;
+var HELP_HINT = source_default.dim(`Use "${APP_NAME} mcp --help" for usage.`);
+var DEFAULT_LOGIN_TIMEOUT_SECONDS = 300;
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function describeTransport(entry) {
+  const { config } = entry;
+  return "url" in config ? config.url : [config.command, ...config.args ?? []].join(" ");
+}
+function createConnection(entry, options, credentials) {
+  return new McpServerConnection({
+    entry,
+    cwd: options.cwd,
+    createTransport: createDefaultTransport,
+    credentials,
+    log: new McpServerLog(join(options.agentDir, "mcp.log")),
+    onTools: () => {}
+  });
+}
+var OPTION_ALIASES = new Map([["-l", "--local"]]);
+function parseOptions(args, known, error, maxPositionals = Number.POSITIVE_INFINITY) {
+  const positional = [];
+  const values = new Map;
+  const lists = new Map;
+  for (let index = 0;index < args.length; index++) {
+    const arg = OPTION_ALIASES.get(args[index]) ?? args[index];
+    if (arg === "--" || positional.length >= maxPositionals) {
+      positional.push(...args.slice(arg === "--" ? index + 1 : index));
+      break;
+    }
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    const name = arg.slice(2);
+    const kind = known[name];
+    if (!kind) {
+      error(`Unknown option ${arg}.
+${HELP_HINT}`);
+      return;
+    }
+    if (kind === "flag") {
+      values.set(name, true);
+      continue;
+    }
+    const value = args[++index];
+    if (value === undefined) {
+      error(`${arg} needs a value.`);
+      return;
+    }
+    if (kind === "list")
+      lists.set(name, [...lists.get(name) ?? [], value]);
+    else
+      values.set(name, value);
+  }
+  return { positional, values, lists };
+}
+async function runMcpCommand(args, options) {
+  const log = options.log ?? ((line) => console.log(line));
+  const error = options.error ?? ((line) => console.error(line));
+  const [command, ...rest] = args;
+  if (command === undefined || command === "help" || args.includes("--help") || args.includes("-h")) {
+    log(HELP);
+    return 0;
+  }
+  const projectConfig = join(options.cwd, CONFIG_DIR_NAME, "mcp.json");
+  if (command === "add" || command === "remove") {
+    return command === "add" ? add(rest, projectConfig, options, log, error) : remove(rest, projectConfig, options, log, error);
+  }
+  const projectTrusted = new ProjectTrustStore(options.agentDir).get(options.cwd) === true;
+  const loaded = loadMcpConfig({ agentDir: options.agentDir, cwd: options.cwd, projectTrusted });
+  const untrustedNote = !projectTrusted && existsSync(projectConfig) ? `${projectConfig} is ignored because the project is not trusted. Start ${APP_NAME} in the project to trust it.` : undefined;
+  const credentials = options.credentials ?? new McpOAuthCredentialStore;
+  switch (command) {
+    case "list": {
+      const parsed = parseOptions(rest, { json: "flag" }, error);
+      if (!parsed)
+        return 1;
+      if (parsed.positional.length > 0) {
+        error(`Usage: ${APP_NAME} mcp list [--json]
+${HELP_HINT}`);
+        return 1;
+      }
+      return list(loaded, parsed.values.has("json"), untrustedNote, options, credentials, log);
+    }
+    case "login":
+    case "logout": {
+      const parsed = parseOptions(rest, command === "login" ? { timeout: "value" } : {}, error);
+      if (!parsed)
+        return 1;
+      const [name, ...extra] = parsed.positional;
+      if (!name || extra.length > 0) {
+        error(`Usage: ${APP_NAME} mcp ${command} <server>
+${HELP_HINT}`);
+        return 1;
+      }
+      const entry = loaded.servers.find((server) => server.name === name);
+      if (!entry) {
+        error(`No MCP server named "${name}".${untrustedNote ? ` ${untrustedNote}` : ""} Configured: ${loaded.servers.map((server) => server.name).join(", ") || "none"}.`);
+        return 1;
+      }
+      const connection = createConnection(entry, options, credentials);
+      const url = connection.oauthUrl;
+      if (!url) {
+        error(`MCP server "${name}" does not use OAuth. Only HTTP servers without an Authorization header do.`);
+        return 1;
+      }
+      if (command === "logout") {
+        const removed = credentials.remove(url);
+        log(removed ? `Signed out of MCP server "${name}".` : `No stored credentials for MCP server "${name}".`);
+        return 0;
+      }
+      const timeout = Number(parsed.values.get("timeout") ?? DEFAULT_LOGIN_TIMEOUT_SECONDS);
+      if (!Number.isFinite(timeout) || timeout <= 0) {
+        error("--timeout must be a positive number of seconds.");
+        return 1;
+      }
+      try {
+        return await login(entry, connection, url, timeout * 1000, options, credentials, log, error);
+      } finally {
+        await connection.close();
+      }
+    }
+    default:
+      error(`Unknown mcp command "${command}".
+${HELP_HINT}`);
+      return 1;
+  }
+}
+function parsePairs(option, pairs, error) {
+  if (!pairs)
+    return {};
+  const record = {};
+  for (const pair of pairs) {
+    const separator = pair.indexOf("=");
+    if (separator <= 0) {
+      error(`--${option} expects KEY=VALUE, got "${pair}".`);
+      return;
+    }
+    record[pair.slice(0, separator)] = pair.slice(separator + 1);
+  }
+  return record;
+}
+function add(args, projectConfig, options, log, error) {
+  const usage = `Usage: ${APP_NAME} mcp add <server> [options] (--url <url> | -- <command> [args...])
+${HELP_HINT}`;
+  const parsed = parseOptions(args, {
+    local: "flag",
+    url: "value",
+    env: "list",
+    cwd: "value",
+    header: "list",
+    "bearer-token-env-var": "value",
+    "oauth-client-id": "value",
+    "oauth-client-secret": "value",
+    "oauth-callback-port": "value",
+    "oauth-client-name": "value",
+    exposure: "value",
+    description: "value"
+  }, error, 2);
+  if (!parsed)
+    return 1;
+  const { positional, values, lists } = parsed;
+  const [name, ...command] = positional;
+  const url = values.get("url");
+  if (!name || url === undefined === (command.length === 0)) {
+    error(usage);
+    return 1;
+  }
+  const value = (option) => {
+    const found = values.get(option);
+    return typeof found === "string" ? found : undefined;
+  };
+  const exposure = value("exposure");
+  const httpOnly = [
+    "header",
+    "bearer-token-env-var",
+    "oauth-client-id",
+    "oauth-client-secret",
+    "oauth-callback-port",
+    "oauth-client-name"
+  ];
+  const stdioOnly = ["env", "cwd"];
+  const misplaced = (url === undefined ? httpOnly : stdioOnly).find((option) => values.has(option) || lists.has(option));
+  if (misplaced) {
+    error(`--${misplaced} only applies to ${url === undefined ? "HTTP servers (--url)" : "stdio servers"}.`);
+    return 1;
+  }
+  let config;
+  if (typeof url === "string") {
+    const headers = parsePairs("header", lists.get("header"), error);
+    if (!headers)
+      return 1;
+    const bearer = value("bearer-token-env-var");
+    if (bearer !== undefined)
+      headers.Authorization = `Bearer \${${bearer}}`;
+    const port = value("oauth-callback-port");
+    const oauth = {
+      ...value("oauth-client-id") === undefined ? {} : { clientId: value("oauth-client-id") },
+      ...value("oauth-client-secret") === undefined ? {} : { clientSecret: value("oauth-client-secret") },
+      ...port === undefined ? {} : { callbackPort: Number(port) },
+      ...value("oauth-client-name") === undefined ? {} : { clientName: value("oauth-client-name") }
+    };
+    config = {
+      url,
+      ...Object.keys(headers).length > 0 ? { headers } : {},
+      ...Object.keys(oauth).length > 0 ? { oauth } : {}
+    };
+  } else {
+    const env = parsePairs("env", lists.get("env"), error);
+    if (!env)
+      return 1;
+    const [executable, ...commandArgs] = command;
+    config = {
+      command: executable,
+      ...commandArgs.length > 0 ? { args: commandArgs } : {},
+      ...Object.keys(env).length > 0 ? { env } : {},
+      ...value("cwd") === undefined ? {} : { cwd: value("cwd") }
+    };
+  }
+  if (exposure !== undefined)
+    config.exposure = exposure;
+  const description = value("description");
+  if (description !== undefined)
+    config.description = description;
+  const validated = validateMcpServerConfig(name, config);
+  if (typeof validated === "string") {
+    error(validated);
+    return 1;
+  }
+  const project = values.has("local");
+  const path = project ? projectConfig : join(options.agentDir, "mcp.json");
+  const scope = project ? "project" : "global";
+  let replaced;
+  try {
+    replaced = addMcpServerConfig(path, name, validated);
+  } catch (addError) {
+    error(`Could not update ${path}: ${errorMessage(addError)}`);
+    return 1;
+  }
+  log(`${replaced ? "Replaced" : "Added"} ${scope} MCP server "${name}" in ${path}.`);
+  if (project && new ProjectTrustStore(options.agentDir).get(options.cwd) !== true) {
+    log(`The project is not trusted, so ${path} is ignored until you start ${APP_NAME} in the project and trust it.`);
+  }
+  const mayNeedSignIn = "url" in validated && !Object.keys(validated.headers ?? {}).some((header) => header.toLowerCase() === "authorization");
+  log(`Check it with: ${APP_NAME} mcp list${mayNeedSignIn ? `. If it requires sign-in: ${APP_NAME} mcp login ${name}` : ""}`);
+  return 0;
+}
+function remove(args, projectConfig, options, log, error) {
+  const parsed = parseOptions(args, { local: "flag" }, error);
+  if (!parsed)
+    return 1;
+  const [name, ...extra] = parsed.positional;
+  if (!name || extra.length > 0) {
+    error(`Usage: ${APP_NAME} mcp remove <server> [-l]
+${HELP_HINT}`);
+    return 1;
+  }
+  const project = parsed.values.has("local");
+  const globalConfig = join(options.agentDir, "mcp.json");
+  const path = project ? projectConfig : globalConfig;
+  const scope = project ? "project" : "global";
+  let removed;
+  try {
+    removed = removeMcpServerConfig(path, name);
+  } catch (removeError) {
+    error(`Could not update ${path}: ${errorMessage(removeError)}`);
+    return 1;
+  }
+  if (removed) {
+    log(`Removed ${scope} MCP server "${name}" from ${path}.`);
+    return 0;
+  }
+  const other = loadMcpConfig({ agentDir: options.agentDir, cwd: options.cwd, projectTrusted: true }).servers.find((server) => server.name === name && server.scope !== scope);
+  error(`No ${scope} MCP server named "${name}" in ${path}.${other ? ` It is defined in ${other.source}${other.scope === "project" ? "; use --local" : "; omit --local"}.` : ""}`);
+  return 1;
+}
+async function list(loaded, json, untrustedNote, options, credentials, log) {
+  const reports = await Promise.all(loaded.servers.map(async (entry) => {
+    const report = {
+      name: entry.name,
+      scope: entry.scope ?? "global",
+      source: entry.source,
+      enabled: entry.config.enabled !== false,
+      exposure: entry.config.exposure ?? "codemode",
+      transport: describeTransport(entry),
+      state: "disabled",
+      tools: []
+    };
+    if (!report.enabled)
+      return report;
+    const connection = createConnection(entry, options, credentials);
+    try {
+      await connection.getClient();
+    } catch {}
+    report.state = connection.state;
+    report.tools = connection.tools.map((tool) => tool.name);
+    const overrides = connection.tools.flatMap((tool) => {
+      const exposure = getMcpToolExposure(entry.config, tool.name);
+      return exposure === report.exposure ? [] : [[tool.name, exposure]];
+    });
+    if (overrides.length > 0)
+      report.toolExposure = Object.fromEntries(overrides);
+    if (connection.hasResources) {
+      report.resources = connection.resources.length;
+      report.resourceTemplates = connection.resourceTemplates.length;
+    }
+    if (connection.state !== "connected" && connection.error)
+      report.error = connection.error;
+    await connection.close();
+    return report;
+  }));
+  const failed = loaded.errors.length > 0 || reports.some((report) => report.enabled && report.state !== "connected");
+  if (json) {
+    log(JSON.stringify({ servers: reports, errors: loaded.errors, ...untrustedNote ? { note: untrustedNote } : {} }, null, 2));
+    return failed ? 1 : 0;
+  }
+  if (reports.length === 0 && loaded.errors.length === 0) {
+    log(`No MCP servers configured. Add them to ${join(options.agentDir, "mcp.json")} or .pi/mcp.json.`);
+  }
+  for (const report of reports) {
+    const state = report.state === "connected" ? `connected, ${report.tools.length} tool${report.tools.length === 1 ? "" : "s"}` : report.state === "needs-auth" ? "needs sign-in" : report.state;
+    log(`${report.name}: ${state} (${report.exposure}, ${report.scope})`);
+    log(`  ${report.transport}`);
+    if (report.state === "needs-auth")
+      log(`  sign in with: ${APP_NAME} mcp login ${report.name}`);
+    if (report.tools.length > 0) {
+      const tools = report.tools.map((tool) => {
+        const exposure = report.toolExposure?.[tool];
+        return exposure ? `${tool} [${exposure}]` : tool;
+      });
+      log(`  tools: ${tools.join(", ")}`);
+    }
+    if (report.resources !== undefined) {
+      log(`  resources: ${report.resources}, URI templates: ${report.resourceTemplates ?? 0}`);
+    }
+    if (report.error)
+      log(`  ${report.error.split(`
+`).join(`
+  `)}`);
+  }
+  for (const configError of loaded.errors)
+    log(`config error: ${configError}`);
+  if (untrustedNote)
+    log(untrustedNote);
+  return failed ? 1 : 0;
+}
+async function login(entry, connection, url, timeoutMs, options, credentials, log, error) {
+  const { name } = entry;
+  try {
+    await connection.getClient();
+    log(`Already signed in to MCP server "${name}" (${connection.tools.length} tools).`);
+    return 0;
+  } catch {
+    if (connection.state !== "needs-auth") {
+      error(`MCP server "${name}" failed to connect: ${connection.error ?? "unknown error"}`);
+      return 1;
+    }
+  }
+  const openUrl = options.openUrl ?? openBrowser;
+  const interactive = process.stdin.isTTY === true && options.openUrl === undefined;
+  try {
+    await signInMcpServer({
+      serverUrl: url,
+      store: credentials.forServer(url),
+      settings: connection.oauthSettings(),
+      challenge: connection.challenge,
+      prompt: {
+        showAuthorizationUrl: (authorizationUrl) => {
+          log(`Sign in to MCP server "${name}" in your browser:
+${authorizationUrl.href}`);
+          openUrl(authorizationUrl.href);
+        },
+        promptForRedirectUrl: (signal) => waitForRedirectUrl(signal, timeoutMs, interactive)
+      }
+    });
+  } catch (signInError) {
+    error(signInError instanceof McpSignInCancelledError ? `Sign-in to MCP server "${name}" was cancelled or not completed within ${Math.round(timeoutMs / 1000)} seconds.` : `Sign-in to MCP server "${name}" failed: ${errorMessage(signInError)}`);
+    return 1;
+  }
+  connection.challenge = undefined;
+  try {
+    await connection.reconnect();
+  } catch (connectError) {
+    error(`Signed in, but ${errorMessage(connectError)}`);
+    return 1;
+  }
+  log(`Signed in to MCP server "${name}" (${connection.tools.length} tools).`);
+  return 0;
+}
+async function waitForRedirectUrl(signal, timeoutMs, interactive) {
+  const controller = new AbortController;
+  const abort = () => controller.abort();
+  signal.addEventListener("abort", abort, { once: true });
+  const timer = setTimeout(abort, timeoutMs);
+  try {
+    if (!interactive) {
+      await new Promise((resolve) => controller.signal.addEventListener("abort", () => resolve(), { once: true }));
+      return;
+    }
+    const readline = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+      return await readline.question("If the browser cannot reach this machine, paste the URL it was redirected to: ", { signal: controller.signal });
+    } catch {
+      return;
+    } finally {
+      readline.close();
+    }
+  } finally {
+    clearTimeout(timer);
+    signal.removeEventListener("abort", abort);
+  }
+}
+export {
+  runMcpCommand
+};

package/dist/cli.js

@@ -8,24 +8,25 @@ import {
   require_react_development,
   require_react_jsx_dev_runtime_development,
   use_app_default
-} from "./cli-zt1227k1.js";
-import"./cli-pw9rj5t9.js";
+} from "./cli-fkqhbg8g.js";
+import"./cli-0xqde53b.js";
+import"./cli-pqetb83f.js";
 import {
   bedrockProviderModule
-} from "./cli-h38x0qhg.js";
+} from "./cli-et8m9xsv.js";
 import"./cli-yn0a417a.js";
 import"./cli-cgj4hc12.js";
 import"./cli-txgcknmy.js";
 import"./cli-6map995v.js";
-import"./cli-k0g1sjzm.js";
+import"./cli-ybgv4kw2.js";
 import"./cli-y2apkfe2.js";
-import"./cli-vapyk8sw.js";
+import"./cli-7kyk9jr3.js";
 import {
   setBedrockProviderModule
-} from "./cli-5b6b62tz.js";
+} from "./cli-13hw4z91.js";
 import"./cli-btbzvq95.js";
 import"./cli-1m2e086m.js";
-import"./cli-mcnhgnn1.js";
+import"./cli-ykk5jaax.js";
 import"./cli-bzr0ftht.js";
 import"./cli-bd957dgb.js";
 import {
@@ -57,7 +58,7 @@ var import_react = __toESM(require_react(), 1);
 // package.json
 var package_default = {
   name: "@desplega.ai/agent-swarm",
-  version: "1.158.0",
+  version: "1.160.0",
   description: "agent-swarm.dev — an open-source operating system for AI work: a lead agent breaks goals into tasks, routes them to specialized workers such as Claude Code or Codex, runs each worker in an isolated container, and preserves shared memory, tools, schedules, and review gates so delegated work compounds across sessions.",
   keywords: [
     "agent-swarm.dev",
@@ -196,8 +197,8 @@ var package_default = {
     lint: "biome check src apps/evals packages/ui-e2e",
     "lint:fix": "biome check --write src apps/evals packages/ui-e2e",
     format: "biome format --write src",
-    "build:binary": "bun build ./src/cli.tsx --compile --bytecode --format=esm --compile-exec-argv='--expose-gc' --target=bun-linux-x64 --outfile ./dist/agent-swarm",
-    "build:binary:arm64": "bun build ./src/cli.tsx --compile --bytecode --format=esm --compile-exec-argv='--expose-gc' --target=bun-linux-arm64 --outfile ./dist/agent-swarm",
+    "build:binary": "bun build ./src/cli.tsx ./src/providers/pi-binary-root/src/extensions/codemode/worker.ts --root ./src/providers/pi-binary-root --compile --bytecode --format=esm --compile-exec-argv='--expose-gc' --target=bun-linux-x64 --outfile ./dist/agent-swarm",
+    "build:binary:arm64": "bun build ./src/cli.tsx ./src/providers/pi-binary-root/src/extensions/codemode/worker.ts --root ./src/providers/pi-binary-root --compile --bytecode --format=esm --compile-exec-argv='--expose-gc' --target=bun-linux-arm64 --outfile ./dist/agent-swarm",
     "docker:build:api": "docker build -f Dockerfile -t agent-swarm-api:latest .",
     "docker:build:worker": "docker build -f Dockerfile.worker -t agent-swarm-worker:latest .",
     "docker:build:worker:slim": "docker build -f Dockerfile.worker --target worker-slim -t agent-swarm-worker:slim .",
@@ -226,8 +227,9 @@ var package_default = {
   devDependencies: {
     "@biomejs/biome": "^2.3.10",
     "@desplega.ai/slack-mock": "^0.4.0",
+    "@desplega/model-catalog": "workspace:*",
     "@faker-js/faker": "^10.4.0",
-    "@opencode-ai/plugin": "1.17.4",
+    "@opencode-ai/plugin": "1.18.34",
     "@types/bun": "latest",
     "dependency-cruiser": "^18.0.0",
     konsistent: "1.0.0-beta.1",
@@ -242,22 +244,22 @@ var package_default = {
     bun: ">=1.3.12"
   },
   dependencies: {
-    "@agentclientprotocol/sdk": "1.4.0",
+    "@agentclientprotocol/sdk": "1.5.1",
     "@ai-sdk/openai": "^3.0.41",
-    "@anthropic-ai/claude-agent-sdk": "0.3.266",
+    "@anthropic-ai/claude-agent-sdk": "0.3.286",
     "@anthropic-ai/sdk": "^0.93.0",
     "@asteasolutions/zod-to-openapi": "^8.0.0",
     "@aws-sdk/client-bedrock": "3.1048.0",
     "@desplega.ai/business-use": "^0.4.2",
     "@desplega.ai/localtunnel": "^2.2.0",
-    "@earendil-works/pi-agent-core": "^0.87.1",
-    "@earendil-works/pi-ai": "^0.87.1",
-    "@earendil-works/pi-coding-agent": "^0.87.1",
+    "@earendil-works/pi-agent-core": "^0.99.2",
+    "@earendil-works/pi-ai": "^0.99.2",
+    "@earendil-works/pi-coding-agent": "^0.99.2",
     "@inkjs/ui": "^2.0.0",
     "@linear/sdk": "^77.0.0",
     "@modelcontextprotocol/sdk": "1.29.0",
-    "@openai/codex": "0.157.1",
-    "@opencode-ai/sdk": "^1.18.32",
+    "@openai/codex": "0.159.3",
+    "@opencode-ai/sdk": "^1.18.34",
     "@openfort/openfort-node": "^0.9.1",
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/api-logs": "^0.218.0",
@@ -751,7 +753,7 @@ function McpServer({ port, apiKey, dbPath }) {
     if (dbPath) {
       process.env.DATABASE_PATH = dbPath;
     }
-    import("./http-2eqa8t24.js").then(() => {
+    import("./http-3bbb19be.js").then(() => {
       setStatus("running");
     }).catch((err) => {
       setStatus("error");
@@ -837,7 +839,7 @@ function WorkerRunner({
 }) {
   const { exit } = use_app_default();
   import_react.useEffect(() => {
-    import("./worker-6vrxbv41.js").then(({ runWorker }) => runWorker({
+    import("./worker-wmwhxsph.js").then(({ runWorker }) => runWorker({
       prompt: prompt || undefined,
       yolo,
       systemPrompt: systemPrompt || undefined,
@@ -854,7 +856,7 @@ function WorkerRunner({
 function LeadRunner({ prompt, yolo, systemPrompt, systemPromptFile, additionalArgs }) {
   const { exit } = use_app_default();
   import_react.useEffect(() => {
-    import("./lead-h3sp357x.js").then(({ runLead }) => runLead({
+    import("./lead-va0pad2c.js").then(({ runLead }) => runLead({
       prompt: prompt || undefined,
       yolo,
       systemPrompt: systemPrompt || undefined,
@@ -894,8 +896,8 @@ function LazyComponent({
   }
   return import_react.createElement(Component, props);
 }
-var loadOnboard = () => import("./onboard-tmsp0qbz.js").then(({ Onboard }) => Onboard);
-var loadConnect = () => import("./setup-q9720bt6.js").then(({ Setup }) => Setup);
+var loadOnboard = () => import("./onboard-j6ms6d0x.js").then(({ Onboard }) => Onboard);
+var loadConnect = () => import("./setup-8y70ys6t.js").then(({ Setup }) => Setup);
 function UnknownCommand({ command }) {
   const { exit } = use_app_default();
   import_react.useEffect(() => {
@@ -1001,6 +1003,13 @@ if (args.showHelp || args.command === "help" || args.command === undefined) {
 } else if (args.command === "version") {
   console.log(`${binName} v${package_default.version}`);
   process.exit(0);
+} else if (args.command === "onboard" && !process.versions.bun) {
+  const { spawnSync } = await import("child_process");
+  const result = spawnSync("bun", process.argv.slice(1), { stdio: "inherit" });
+  if (result.error) {
+    console.error("Onboarding requires Bun. Install Bun from https://bun.sh, then retry this command.");
+  }
+  process.exit(result.status ?? 1);
 } else if (args.command === "docs") {
   const docsUrl = "https://docs.agent-swarm.dev";
   console.log(`
@@ -1018,14 +1027,14 @@ ${binName} docs \u2014 v${package_default.version}
   }
   process.exit(0);
 } else if (args.command === "hook") {
-  const { runHook } = await import("./hook-ybvmrmhq.js");
+  const { runHook } = await import("./hook-czx13n12.js");
   await runHook();
 } else if (args.command === "codex-hook") {
-  const { handleCodexHook } = await import("./codex-hook-9hptmdhj.js");
+  const { handleCodexHook } = await import("./codex-hook-20me6byw.js");
   await handleCodexHook();
   process.exit(0);
 } else if (args.command === "session-summary-stdin") {
-  const { runSessionSummaryFromStdin } = await import("./hook-7vkskkre.js");
+  const { runSessionSummaryFromStdin } = await import("./hook-r2t4bqfg.js");
   await runSessionSummaryFromStdin();
   process.exit(process.exitCode ?? 0);
 } else if (args.command === "artifact") {
@@ -1046,7 +1055,7 @@ ${binName} docs \u2014 v${package_default.version}
     printHelp("scripts");
     process.exit(scriptsArgs[0] === "reembed" || args.showHelp ? 0 : 1);
   }
-  const { runScriptsMaintenanceCommand } = await import("./maintenance-jzeqtk3q.js");
+  const { runScriptsMaintenanceCommand } = await import("./maintenance-hqewtmyg.js");
   await runScriptsMaintenanceCommand(scriptsArgs);
   console.log("Scripts re-embedded.");
 } else if (args.command === "rbac") {
@@ -1056,21 +1065,21 @@ ${binName} docs \u2014 v${package_default.version}
     printHelp("rbac");
     process.exit(args.showHelp ? 0 : 1);
   }
-  const { runRbacCliCommand } = await import("./rbac-roles-c9wqz83x.js");
+  const { runRbacCliCommand } = await import("./rbac-roles-8tzawacv.js");
   await runRbacCliCommand(rbacArgs);
 } else if (args.command === "codex-login") {
-  const { runCodexLogin } = await import("./codex-login-x3jk4etn.js");
+  const { runCodexLogin } = await import("./codex-login-w6fz4xbz.js");
   const codexLoginArgs = process.argv.slice(process.argv.indexOf("codex-login") + 1);
   await runCodexLogin(codexLoginArgs);
 } else if (args.command === "codex-session-runner") {
-  const { runCodexSessionRunner } = await import("./codex-session-runner-gfg547zj.js");
+  const { runCodexSessionRunner } = await import("./codex-session-runner-90aa80ev.js");
   await runCodexSessionRunner();
 } else if (args.command === "claude-managed-setup") {
-  const { runClaudeManagedSetup } = await import("./claude-managed-setup-60g8aazx.js");
+  const { runClaudeManagedSetup } = await import("./claude-managed-setup-eacvchx0.js");
   const setupArgs = process.argv.slice(process.argv.indexOf("claude-managed-setup") + 1);
   await runClaudeManagedSetup(setupArgs);
 } else if (args.command === "e2b") {
-  const { runE2BCommand } = await import("./e2b-93x1k0j5.js");
+  const { runE2BCommand } = await import("./e2b-ez07znam.js");
   const e2bArgs = process.argv.slice(process.argv.indexOf("e2b") + 1);
   await runE2BCommand(e2bArgs);
 } else {