@desplega.ai/agent-swarm 1.158.0 → 1.159.0

package/dist/{cli-c07r9a2m.js → cli-48527fpw.js}

@@ -7,7 +7,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@desplega.ai/agent-swarm",
-    version: "1.158.0",
+    version: "1.159.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",
@@ -176,8 +176,9 @@ var init_package = __esm(() => {
     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.33",
       "@types/bun": "latest",
       "dependency-cruiser": "^18.0.0",
       konsistent: "1.0.0-beta.1",
@@ -194,20 +195,20 @@ var init_package = __esm(() => {
     dependencies: {
       "@agentclientprotocol/sdk": "1.4.0",
       "@ai-sdk/openai": "^3.0.41",
-      "@anthropic-ai/claude-agent-sdk": "0.3.266",
+      "@anthropic-ai/claude-agent-sdk": "0.3.285",
       "@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.1",
+      "@earendil-works/pi-ai": "^0.99.1",
+      "@earendil-works/pi-coding-agent": "^0.99.1",
       "@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.1",
+      "@opencode-ai/sdk": "^1.18.33",
       "@openfort/openfort-node": "^0.9.1",
       "@opentelemetry/api": "^1.9.1",
       "@opentelemetry/api-logs": "^0.218.0",

package/dist/{cli-24k806sc.js → cli-4aj25szq.js}

@@ -10,7 +10,7 @@ import {
   getJsonSchemaToolParameters,
   resolveJsonSchemaStrictSampling,
   transformMessages
-} from "./cli-k0g1sjzm.js";
+} from "./cli-31nkw3g3.js";
 import {
   sanitizeSurrogates
 } from "./cli-y2apkfe2.js";
@@ -18,7 +18,7 @@ import {
   clampThinkingLevel,
   collapseSystemMessages,
   withoutInitialSystemMessage
-} from "./cli-mcnhgnn1.js";
+} from "./cli-ykk5jaax.js";
 import {
   import_websocket
 } from "./cli-76yrvwsa.js";

package/dist/{cli-7gtvvpbh.js → cli-4tvgz99m.js}

@@ -1,13 +1,13 @@
 import {
   runStopHookSessionSummarySubprocess
-} from "./cli-7s3syk22.js";
-import {
-  fetchInstalledMcpServers
-} from "./cli-tng3131n.js";
+} from "./cli-b6thtzac.js";
 import {
   buildOtelTraceparentEnv,
   isHarnessOtelEnabled
 } from "./cli-q2j38vre.js";
+import {
+  fetchInstalledMcpServers
+} from "./cli-tng3131n.js";
 import {
   CTX_MODE_NUDGE_EVERY
 } from "./cli-zm7njwzd.js";
@@ -16,7 +16,7 @@ import {
   clampContextPercent,
   computeContextUsedUnified,
   getContextWindowSize
-} from "./cli-0xjkj1j7.js";
+} from "./cli-wd9hz40d.js";
 import {
   isClaudeBridgeEffective,
   resolveClaudeTransport
@@ -28,7 +28,7 @@ import {
 } from "./cli-npssxgaz.js";
 import {
   applyReasoningEffort
-} from "./cli-h967nb6r.js";
+} from "./cli-ca2w7zv7.js";
 import {
   swarmRuntimeInstanceId
 } from "./cli-re8z5p8p.js";
@@ -822,7 +822,7 @@ class ClaudeAdapter {
     if (transport === "sdk" && isClaudeBridgeEffective(sourceEnv)) {
       throw new Error("CLAUDE_TRANSPORT=sdk cannot run with an effective Claude Bridge configuration. Select CLI transport or disable the bridge.");
     }
-    const claudeSdk = transport === "sdk" ? await import("./claude-sdk-session-t442qz6f.js") : undefined;
+    const claudeSdk = transport === "sdk" ? await import("./claude-sdk-session-zhkyk8yw.js") : undefined;
     claudeSdk?.validateClaudeSdkAdditionalArgs([
       ...claudeBinaryArgv.slice(1),
       ...config.additionalArgs ?? []

package/dist/cli-503ya656.js

@@ -0,0 +1,455 @@
+import {
+  require_proper_lockfile
+} from "./cli-ejpygnqz.js";
+import {
+  CONFIG_DIR_NAME,
+  canonicalizePath,
+  resolvePath,
+  stripBom
+} from "./cli-hj65wsts.js";
+import {
+  __toESM
+} from "./cli-bc05qbss.js";
+
+// node_modules/@earendil-works/pi-coding-agent/dist/core/mcp-servers.js
+var MCP_EXPOSURES = [
+  "codemode",
+  "codemode-deferred",
+  "deferred",
+  "direct",
+  "hidden"
+];
+var LOOPBACK_HOSTS = ["localhost", "127.0.0.1", "[::1]"];
+function isLoopbackRedirectUri(value) {
+  if (!URL.canParse(value))
+    return false;
+  const url = new URL(value);
+  return url.protocol === "http:" && LOOPBACK_HOSTS.includes(url.hostname) && url.search === "" && url.hash === "";
+}
+var SERVER_NAME = /^[A-Za-z0-9_-]+$/;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringRecord(value) {
+  return isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
+}
+function validateOAuth(value) {
+  if (value === undefined)
+    return;
+  if (!isRecord(value))
+    return "oauth must be an object";
+  if (value.clientId !== undefined && typeof value.clientId !== "string")
+    return "oauth.clientId must be a string";
+  if (value.clientSecret !== undefined && typeof value.clientSecret !== "string") {
+    return "oauth.clientSecret must be a string";
+  }
+  const port = value.callbackPort;
+  if (port !== undefined && (typeof port !== "number" || !Number.isInteger(port) || port < 1 || port > 65535)) {
+    return "oauth.callbackPort must be a port number";
+  }
+  if (value.callbackUrl !== undefined) {
+    if (typeof value.callbackUrl !== "string" || !isLoopbackRedirectUri(value.callbackUrl)) {
+      return "oauth.callbackUrl must be an http URI on localhost, 127.0.0.1, or [::1] without query or fragment";
+    }
+    const urlPort = new URL(value.callbackUrl).port;
+    if (urlPort && port !== undefined && Number(urlPort) !== port) {
+      return "oauth.callbackUrl and oauth.callbackPort name different ports";
+    }
+  }
+  if (value.scope !== undefined && typeof value.scope !== "string")
+    return "oauth.scope must be a string";
+  return;
+}
+function isExposure(value) {
+  return typeof value === "string" && MCP_EXPOSURES.includes(value);
+}
+function toolPatternRegExp(pattern) {
+  const source = pattern.split("*").map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+  return new RegExp(`^${source}$`);
+}
+function getMcpToolExposure(config, toolName) {
+  const overrides = config.toolExposure ?? {};
+  const exact = overrides[toolName];
+  if (exact !== undefined)
+    return exact;
+  for (const [pattern, exposure] of Object.entries(overrides)) {
+    if (pattern.includes("*") && toolPatternRegExp(pattern).test(toolName))
+      return exposure;
+  }
+  return config.exposure ?? "codemode";
+}
+function validateMcpServerConfig(name, value) {
+  if (!SERVER_NAME.test(name))
+    return `invalid server name "${name}" (use letters, digits, "_" and "-")`;
+  if (!isRecord(value))
+    return `server "${name}" must be an object`;
+  const { type, exposure, enabled, timeout, toolExposure } = value;
+  const exposures = MCP_EXPOSURES.map((value2) => `"${value2}"`).join(", ");
+  if (exposure !== undefined && !isExposure(exposure)) {
+    return `server "${name}": exposure must be one of ${exposures}`;
+  }
+  if (toolExposure !== undefined) {
+    if (!isRecord(toolExposure))
+      return `server "${name}": toolExposure must map tool names to exposures`;
+    for (const [tool, value2] of Object.entries(toolExposure)) {
+      if (!isExposure(value2))
+        return `server "${name}": toolExposure "${tool}" must be one of ${exposures}`;
+    }
+  }
+  if (enabled !== undefined && typeof enabled !== "boolean")
+    return `server "${name}": enabled must be a boolean`;
+  if (timeout !== undefined && (typeof timeout !== "number" || !(timeout > 0))) {
+    return `server "${name}": timeout must be a positive number of seconds`;
+  }
+  if (type === "sse")
+    return `server "${name}": legacy SSE transport is not supported; use the streamable HTTP URL`;
+  if (typeof value.url === "string" && (type === undefined || type === "http" || type === "streamable-http")) {
+    if (!URL.canParse(value.url) || !/^https?:$/.test(new URL(value.url).protocol)) {
+      return `server "${name}": url must be an http or https URL`;
+    }
+    if (value.headers !== undefined && !isStringRecord(value.headers)) {
+      return `server "${name}": headers must map names to strings`;
+    }
+    const oauthError = validateOAuth(value.oauth);
+    if (oauthError)
+      return `server "${name}": ${oauthError}`;
+    return value;
+  }
+  if (typeof value.command === "string" && (type === undefined || type === "stdio")) {
+    if (value.args !== undefined && !(Array.isArray(value.args) && value.args.every((arg) => typeof arg === "string"))) {
+      return `server "${name}": args must be an array of strings`;
+    }
+    if (value.env !== undefined && !isStringRecord(value.env))
+      return `server "${name}": env must map names to strings`;
+    if (value.cwd !== undefined && typeof value.cwd !== "string")
+      return `server "${name}": cwd must be a string`;
+    return value;
+  }
+  return `server "${name}" needs either "command" (stdio) or "url" (streamable HTTP)`;
+}
+
+class McpServerRegistry {
+  servers = new Map;
+  changeListener;
+  register(server) {
+    this.servers.set(server.name, server);
+    this.changeListener?.();
+  }
+  unregister(name, extensionPath) {
+    if (this.servers.get(name)?.extensionPath !== extensionPath)
+      return;
+    this.servers.delete(name);
+    this.changeListener?.();
+  }
+  get(name) {
+    return this.servers.get(name);
+  }
+  list() {
+    return [...this.servers.values()].map((server) => ({ ...server, config: structuredClone(server.config) }));
+  }
+  setChangeListener(listener) {
+    this.changeListener = listener;
+  }
+}
+
+// node_modules/@earendil-works/pi-coding-agent/dist/core/trust-manager.js
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES = [
+  "settings.json",
+  "mcp.json",
+  "extensions",
+  "skills",
+  "prompts",
+  "themes",
+  "SYSTEM.md",
+  "APPEND_SYSTEM.md"
+];
+function normalizeCwd(cwd) {
+  return canonicalizePath(resolvePath(cwd));
+}
+function findNearestTrustEntry(data, cwd) {
+  let currentDir = normalizeCwd(cwd);
+  while (true) {
+    const value = data[currentDir];
+    if (value === true || value === false) {
+      return { path: currentDir, decision: value };
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+function getProjectTrustParentPath(cwd) {
+  const trustPath = normalizeCwd(cwd);
+  const parentDir = dirname(trustPath);
+  return parentDir === trustPath ? undefined : parentDir;
+}
+function getProjectTrustOptions(cwd, options) {
+  const trustPath = normalizeCwd(cwd);
+  const trustOptions = [
+    { label: "Trust", trusted: true, updates: [{ path: trustPath, decision: true }], savedPath: trustPath }
+  ];
+  const parentPath = getProjectTrustParentPath(cwd);
+  if (parentPath !== undefined) {
+    trustOptions.push({
+      label: `Trust parent folder (${parentPath})`,
+      trusted: true,
+      updates: [
+        { path: parentPath, decision: true },
+        { path: trustPath, decision: null }
+      ],
+      savedPath: parentPath
+    });
+  }
+  if (options?.includeSessionOnly) {
+    trustOptions.push({ label: "Trust (this session only)", trusted: true, updates: [] });
+  }
+  trustOptions.push({
+    label: "Do not trust",
+    trusted: false,
+    updates: [{ path: trustPath, decision: false }],
+    savedPath: trustPath
+  });
+  if (options?.includeSessionOnly) {
+    trustOptions.push({ label: "Do not trust (this session only)", trusted: false, updates: [] });
+  }
+  return trustOptions;
+}
+function readTrustFile(path) {
+  if (!existsSync(path)) {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stripBom(readFileSync(path, "utf-8")));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to read trust store ${path}: ${message}`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`Invalid trust store ${path}: expected an object`);
+  }
+  const data = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (value !== true && value !== false && value !== null) {
+      throw new Error(`Invalid trust store ${path}: value for ${JSON.stringify(key)} must be true, false, or null`);
+    }
+    data[key] = value;
+  }
+  return data;
+}
+function writeTrustFile(path, data) {
+  const sorted = {};
+  for (const key of Object.keys(data).sort()) {
+    const value = data[key];
+    if (value === true || value === false || value === null) {
+      sorted[key] = value;
+    }
+  }
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(sorted, null, 2)}
+`, "utf-8");
+}
+function acquireTrustLockSync(path) {
+  const trustDir = dirname(path);
+  mkdirSync(trustDir, { recursive: true });
+  const maxAttempts = 10;
+  const delayMs = 20;
+  let lastError;
+  for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+    try {
+      return import_proper_lockfile.default.lockSync(trustDir, { realpath: false, lockfilePath: `${path}.lock` });
+    } catch (error) {
+      const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : undefined;
+      if (code !== "ELOCKED" || attempt === maxAttempts) {
+        throw error;
+      }
+      lastError = error;
+      const start = Date.now();
+      while (Date.now() - start < delayMs) {}
+    }
+  }
+  if (lastError instanceof Error) {
+    throw lastError;
+  }
+  throw new Error("Failed to acquire trust store lock");
+}
+function withTrustFileLock(path, fn) {
+  const release = acquireTrustLockSync(path);
+  try {
+    return fn();
+  } finally {
+    release();
+  }
+}
+function hasTrustRequiringProjectResources(cwd) {
+  const homeDir = canonicalizePath(resolvePath(process.env.HOME || homedir()));
+  const userAgentsSkillsDir = join(homeDir, ".agents", "skills");
+  let currentDir = canonicalizePath(resolvePath(cwd));
+  const configDir = join(currentDir, CONFIG_DIR_NAME);
+  if (TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES.some((entry) => existsSync(join(configDir, entry)))) {
+    return true;
+  }
+  while (true) {
+    const agentsSkillsDir = join(currentDir, ".agents", "skills");
+    if (agentsSkillsDir !== userAgentsSkillsDir && existsSync(agentsSkillsDir)) {
+      return true;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return false;
+    }
+    currentDir = parentDir;
+  }
+}
+
+class ProjectTrustStore {
+  trustPath;
+  constructor(agentDir) {
+    this.trustPath = join(resolvePath(agentDir), "trust.json");
+  }
+  get(cwd) {
+    return this.getEntry(cwd)?.decision ?? null;
+  }
+  getEntry(cwd) {
+    return withTrustFileLock(this.trustPath, () => {
+      const data = readTrustFile(this.trustPath);
+      return findNearestTrustEntry(data, cwd);
+    });
+  }
+  set(cwd, decision) {
+    this.setMany([{ path: cwd, decision }]);
+  }
+  setMany(decisions) {
+    withTrustFileLock(this.trustPath, () => {
+      const data = readTrustFile(this.trustPath);
+      for (const { path, decision } of decisions) {
+        const key = normalizeCwd(path);
+        if (decision === null) {
+          delete data[key];
+        } else {
+          data[key] = decision;
+        }
+      }
+      writeTrustFile(this.trustPath, data);
+    });
+  }
+}
+
+// node_modules/@earendil-works/pi-coding-agent/dist/utils/open-browser.js
+import { spawn } from "node:child_process";
+function openBrowser(target) {
+  const [cmd, args] = process.platform === "darwin" ? ["open", [target]] : process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", target]] : ["xdg-open", [target]];
+  spawn(cmd, args, { stdio: "ignore", detached: true }).on("error", () => {}).unref();
+}
+
+// node_modules/@earendil-works/pi-coding-agent/dist/extensions/mcp/config.js
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readConfigFile(path, scope, state) {
+  const { servers, errors } = state;
+  if (!existsSync2(path))
+    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(path, "utf8"));
+  } catch (error) {
+    errors.push(`${path}: ${error instanceof Error ? error.message : String(error)}`);
+    return;
+  }
+  if (!isRecord2(parsed) || parsed.mcpServers !== undefined && !isRecord2(parsed.mcpServers)) {
+    errors.push(`${path}: expected an object with an "mcpServers" object`);
+    return;
+  }
+  if (typeof parsed.autoEnableCodemode === "boolean")
+    state.autoEnableCodemode = parsed.autoEnableCodemode;
+  else if (parsed.autoEnableCodemode !== undefined)
+    errors.push(`${path}: autoEnableCodemode must be a boolean`);
+  for (const [name, value] of Object.entries(parsed.mcpServers ?? {})) {
+    const config = validateMcpServerConfig(name, value);
+    if (typeof config === "string") {
+      errors.push(`${path}: ${config}`);
+      continue;
+    }
+    servers.set(name, { name, config, source: path, scope });
+  }
+}
+function loadMcpConfig(options) {
+  const state = { servers: new Map, errors: [] };
+  readConfigFile(join2(options.agentDir, "mcp.json"), "global", state);
+  if (options.projectTrusted)
+    readConfigFile(join2(options.cwd, CONFIG_DIR_NAME, "mcp.json"), "project", state);
+  return {
+    servers: [...state.servers.values()],
+    ...state.autoEnableCodemode === undefined ? {} : { autoEnableCodemode: state.autoEnableCodemode },
+    errors: state.errors
+  };
+}
+function updateMcpServerConfig(path, name, patch) {
+  editMcpServers(path, (servers) => {
+    const server = servers?.[name];
+    if (!isRecord2(server))
+      throw new Error(`${path} does not define MCP server "${name}"`);
+    if (patch.enabled !== undefined) {
+      if (patch.enabled)
+        delete server.enabled;
+      else
+        server.enabled = false;
+    }
+    if (patch.exposure !== undefined) {
+      if (patch.exposure === "codemode")
+        delete server.exposure;
+      else
+        server.exposure = patch.exposure;
+    }
+    return true;
+  });
+}
+function addMcpServerConfig(path, name, config) {
+  let replaced = false;
+  editMcpServers(path, (servers, parsed) => {
+    const target = servers ?? {};
+    replaced = target[name] !== undefined;
+    target[name] = config;
+    parsed.mcpServers = target;
+    return true;
+  });
+  return replaced;
+}
+function removeMcpServerConfig(path, name) {
+  if (!existsSync2(path))
+    return false;
+  let removed = false;
+  editMcpServers(path, (servers) => {
+    if (!servers || servers[name] === undefined)
+      return false;
+    delete servers[name];
+    removed = true;
+    return true;
+  });
+  return removed;
+}
+function editMcpServers(path, edit) {
+  const text = existsSync2(path) ? readFileSync2(path, "utf8") : undefined;
+  const parsed = text === undefined ? {} : JSON.parse(text);
+  if (!isRecord2(parsed) || parsed.mcpServers !== undefined && !isRecord2(parsed.mcpServers)) {
+    throw new Error(`${path}: expected an object with an "mcpServers" object`);
+  }
+  const servers = isRecord2(parsed.mcpServers) ? parsed.mcpServers : undefined;
+  if (!edit(servers, parsed))
+    return;
+  const indent = text && /^([ \t]+)\S/m.exec(text)?.[1] || "  ";
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync2(path, `${JSON.stringify(parsed, null, indent)}
+`);
+}
+
+export { getMcpToolExposure, validateMcpServerConfig, McpServerRegistry, getProjectTrustOptions, hasTrustRequiringProjectResources, ProjectTrustStore, openBrowser, loadMcpConfig, updateMcpServerConfig, addMcpServerConfig, removeMcpServerConfig };

package/dist/{cli-cw9zck8j.js → cli-5f2hq128.js}

@@ -1,19 +1,23 @@
 import {
   BASE_SUMMARIZE_PROMPT,
   SummaryWithRatingsSchema,
-  buildSummaryWithRatingsPrompt,
+  buildSummaryWithRatingsPrompt
+} from "./cli-cpvsaqsw.js";
+import {
   parseModelStr,
   resolveCredential
-} from "./cli-tt9k8r35.js";
+} from "./cli-rfezr056.js";
 import {
   DEFAULT_OPENROUTER_BASE_URL,
   getOpenRouterBaseUrl
 } from "./cli-3dpj7atn.js";
 import {
   complete,
-  exports_typebox,
   getBuiltinModel
-} from "./cli-aw1jwp1r.js";
+} from "./cli-gzyh0j0g.js";
+import {
+  exports_typebox
+} from "./cli-rb9m6rpe.js";
 import {
   init_zod
 } from "./cli-sd0mxa3c.js";