@desplega.ai/agent-swarm 1.74.2 → 1.74.3

package/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Swarm API",
-    "version": "1.74.2",
+    "version": "1.74.3",
     "description": "Multi-agent orchestration API for Claude Code, Codex, and Gemini CLI. Enables task distribution, agent communication, and service discovery.\n\nMCP tools are documented separately in [MCP.md](./MCP.md)."
   },
   "servers": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.74.2",
+  "version": "1.74.3",
   "description": "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
   "license": "MIT",
   "author": "desplega.sh <contact@desplega.sh>",

package/src/providers/claude-adapter.ts

@@ -91,51 +91,55 @@ export function mergeMcpConfig(
 
 /**
  * Create a per-session MCP config file with X-Source-Task-Id header injected
- * and installed MCP servers merged in.
- * Each session gets its own copy to avoid race conditions when multiple concurrent
- * Claude sessions share the same cwd. The session-specific config is passed to
- * Claude CLI via --mcp-config, so the shared .mcp.json is never modified.
- * Returns the path to the per-session config, or null if no config exists.
+ * and installed MCP servers merged in. Each session gets its own copy at
+ * `/tmp/mcp-<taskId>.json`, passed to Claude via `--mcp-config`, so the shared
+ * `.mcp.json` is never modified. Returns the path, or null if there's nothing
+ * to write.
+ *
+ * Exported for unit testing.
  */
-async function createSessionMcpConfig(
+export async function createSessionMcpConfig(
   cwd: string,
   taskId: string,
   installedServers?: Record<string, Record<string, unknown>> | null,
 ): Promise<string | null> {
-  // Walk up from cwd to find .mcp.json (mirrors Claude CLI's project-level config discovery).
-  // In Docker, .mcp.json lives at /workspace/.mcp.json but tasks often run with cwd set to
-  // a subdirectory like /workspace/repos/<repo>, so a single-directory check misses it.
+  // Collect every .mcp.json from cwd up to filesystem root. Stopping at the first
+  // match silently drops the swarm-managed /workspace/.mcp.json when the cloned
+  // repo ships its own .mcp.json (e.g. Datadog) — so we merge all layers, with
+  // rootmost winning on key conflicts.
+  const mcpJsonPaths: string[] = [];
   let searchDir = cwd;
-  let mcpJsonPath: string | null = null;
   while (true) {
     const candidate = join(searchDir, ".mcp.json");
     if (await Bun.file(candidate).exists()) {
-      mcpJsonPath = candidate;
-      break;
+      mcpJsonPaths.push(candidate);
     }
     const parent = dirname(searchDir);
-    if (parent === searchDir) break; // reached filesystem root
+    if (parent === searchDir) break;
     searchDir = parent;
   }
 
-  if (!mcpJsonPath && !installedServers) return null;
+  if (mcpJsonPaths.length === 0 && !installedServers) return null;
 
-  try {
-    let baseConfig: { mcpServers?: Record<string, unknown> } = { mcpServers: {} };
-    if (mcpJsonPath) {
-      const file = Bun.file(mcpJsonPath);
-      baseConfig = await file.json();
+  // Merge deepest → rootmost so rootmost (swarm) overrides cwd-ward layers.
+  const mergedServers: Record<string, unknown> = {};
+  for (const path of mcpJsonPaths) {
+    try {
+      const layer = (await Bun.file(path).json()) as { mcpServers?: Record<string, unknown> };
+      if (layer?.mcpServers) Object.assign(mergedServers, layer.mcpServers);
+    } catch (err) {
+      console.warn(`\x1b[33m[claude]\x1b[0m Skipping malformed ${path}: ${err}`);
     }
-    if (!baseConfig?.mcpServers && !installedServers) return null;
+  }
 
-    const config = mergeMcpConfig(baseConfig, installedServers ?? null, taskId);
+  if (Object.keys(mergedServers).length === 0 && !installedServers) return null;
 
-    // Write per-session config to /tmp — no race, each session has its own file
+  try {
+    const config = mergeMcpConfig({ mcpServers: mergedServers }, installedServers ?? null, taskId);
     const sessionConfigPath = `/tmp/mcp-${taskId}.json`;
     await writeFile(sessionConfigPath, JSON.stringify(config, null, 2));
     return sessionConfigPath;
   } catch (err) {
-    // Non-fatal — if creation fails, sourceTaskId won't be sent and Slack metadata won't auto-inherit
     console.warn(`\x1b[33m[claude]\x1b[0m Failed to create session MCP config: ${err}`);
     return null;
   }

package/src/tests/claude-adapter.test.ts

@@ -1,5 +1,8 @@
-import { describe, expect, test } from "bun:test";
-import { ClaudeAdapter, mergeMcpConfig } from "../providers/claude-adapter";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { ClaudeAdapter, createSessionMcpConfig, mergeMcpConfig } from "../providers/claude-adapter";
 import type { ProviderSessionConfig } from "../providers/types";
 
 /** Minimal config for testing — sessions won't actually spawn in these unit tests */
@@ -245,6 +248,162 @@ describe("mergeMcpConfig (issue #369)", () => {
   });
 });
 
+describe("createSessionMcpConfig", () => {
+  let sandbox: string;
+
+  beforeEach(async () => {
+    sandbox = await mkdtemp(join(tmpdir(), "mcp-cfg-test-"));
+  });
+
+  afterEach(async () => {
+    await rm(sandbox, { recursive: true, force: true });
+  });
+
+  async function readWritten(path: string) {
+    return JSON.parse(await Bun.file(path).text()) as {
+      mcpServers: Record<string, Record<string, unknown>>;
+    };
+  }
+
+  test("returns null when no .mcp.json found and no installed servers", async () => {
+    const cwd = join(sandbox, "empty");
+    await mkdir(cwd, { recursive: true });
+    const path = await createSessionMcpConfig(cwd, "task-empty");
+    expect(path).toBeNull();
+  });
+
+  test("ancestor-only .mcp.json is found via walk-up (Docker layout)", async () => {
+    await writeFile(
+      join(sandbox, ".mcp.json"),
+      JSON.stringify({
+        mcpServers: {
+          "agent-swarm": {
+            type: "http",
+            url: "http://swarm/mcp",
+            headers: { Authorization: "Bearer SWARM", "X-Agent-ID": "a1" },
+          },
+        },
+      }),
+    );
+    const cwd = join(sandbox, "repos", "foo");
+    await mkdir(cwd, { recursive: true });
+
+    const path = await createSessionMcpConfig(cwd, "task-anc");
+    expect(path).toBe("/tmp/mcp-task-anc.json");
+    const written = await readWritten(path!);
+    expect(written.mcpServers["agent-swarm"]).toBeDefined();
+    expect(
+      (written.mcpServers["agent-swarm"].headers as Record<string, string>)["X-Source-Task-Id"],
+    ).toBe("task-anc");
+  });
+
+  test("merges repo-local + ancestor when server names differ", async () => {
+    await writeFile(
+      join(sandbox, ".mcp.json"),
+      JSON.stringify({
+        mcpServers: {
+          "agent-swarm": {
+            type: "http",
+            url: "http://swarm/mcp",
+            headers: { Authorization: "Bearer SWARM", "X-Agent-ID": "a1" },
+          },
+        },
+      }),
+    );
+    const repo = join(sandbox, "repos", "client-monorepo");
+    await mkdir(repo, { recursive: true });
+    await writeFile(
+      join(repo, ".mcp.json"),
+      JSON.stringify({
+        mcpServers: { Datadog: { command: "npx", args: ["-y", "@winor30/mcp-server-datadog"] } },
+      }),
+    );
+
+    const path = await createSessionMcpConfig(repo, "task-merge");
+    const written = await readWritten(path!);
+    expect(written.mcpServers["agent-swarm"]).toBeDefined();
+    expect(written.mcpServers.Datadog).toBeDefined();
+    expect(Object.keys(written.mcpServers).sort()).toEqual(["Datadog", "agent-swarm"]);
+  });
+
+  test("ancestor wins over repo-local on agent-swarm key conflict", async () => {
+    await writeFile(
+      join(sandbox, ".mcp.json"),
+      JSON.stringify({
+        mcpServers: {
+          "agent-swarm": {
+            type: "http",
+            url: "http://swarm/mcp",
+            headers: { Authorization: "Bearer SWARM", "X-Agent-ID": "a1" },
+          },
+        },
+      }),
+    );
+    const repo = join(sandbox, "repos", "foo");
+    await mkdir(repo, { recursive: true });
+    await writeFile(
+      join(repo, ".mcp.json"),
+      JSON.stringify({
+        mcpServers: {
+          "agent-swarm": {
+            type: "http",
+            url: "http://stale/mcp",
+            headers: { Authorization: "Bearer STALE", "X-Agent-ID": "stale-agent" },
+          },
+        },
+      }),
+    );
+
+    const path = await createSessionMcpConfig(repo, "task-conflict");
+    const written = await readWritten(path!);
+    const swarm = written.mcpServers["agent-swarm"] as Record<string, unknown>;
+    const headers = swarm.headers as Record<string, string>;
+    expect(swarm.url).toBe("http://swarm/mcp");
+    expect(headers.Authorization).toBe("Bearer SWARM");
+    expect(headers["X-Agent-ID"]).toBe("a1");
+    expect(headers["X-Source-Task-Id"]).toBe("task-conflict");
+  });
+
+  test("malformed repo-local .mcp.json is skipped without poisoning ancestor entries", async () => {
+    await writeFile(
+      join(sandbox, ".mcp.json"),
+      JSON.stringify({
+        mcpServers: {
+          "agent-swarm": {
+            type: "http",
+            url: "http://swarm/mcp",
+            headers: { "X-Agent-ID": "a1" },
+          },
+        },
+      }),
+    );
+    const repo = join(sandbox, "repos", "foo");
+    await mkdir(repo, { recursive: true });
+    await writeFile(join(repo, ".mcp.json"), "{ this is not valid json");
+
+    const path = await createSessionMcpConfig(repo, "task-malformed");
+    expect(path).not.toBeNull();
+    const written = await readWritten(path!);
+    expect(written.mcpServers["agent-swarm"]).toBeDefined();
+  });
+
+  test("only installedServers, no .mcp.json on disk", async () => {
+    const cwd = join(sandbox, "no-mcp");
+    await mkdir(cwd, { recursive: true });
+
+    const path = await createSessionMcpConfig(cwd, "task-installed", {
+      "from-api": {
+        type: "http",
+        url: "http://api.test/mcp",
+        headers: { Authorization: "Bearer API" },
+      },
+    });
+    expect(path).toBe("/tmp/mcp-task-installed.json");
+    const written = await readWritten(path!);
+    expect(written.mcpServers["from-api"]).toBeDefined();
+  });
+});
+
 describe("Stale session retry logic", () => {
   test("--resume args are stripped correctly", () => {
     const args = ["--max-turns", "10", "--resume", "session-abc", "--verbose"];