@desplega.ai/agent-swarm 1.69.0 → 1.70.0

package/src/tests/additive-buffer.test.ts

@@ -0,0 +1,186 @@
+import { describe, expect, test } from "bun:test";
+import { createAdditiveBuffer } from "../tasks/additive-buffer";
+
+/**
+ * Helper: wait for a timer-based flush. We use tight timeouts (10-30ms) so
+ * tests stay fast — these operate on Bun's event loop, not real time.
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+describe("createAdditiveBuffer", () => {
+  test("rejects non-positive timeoutMs", () => {
+    expect(() => createAdditiveBuffer({ timeoutMs: 0, onFlush: () => {} })).toThrow(
+      /positive number/,
+    );
+    expect(() => createAdditiveBuffer({ timeoutMs: -1, onFlush: () => {} })).toThrow();
+    // biome-ignore lint/suspicious/noExplicitAny: type-guard test
+    expect(() => createAdditiveBuffer({ timeoutMs: NaN as any, onFlush: () => {} })).toThrow();
+  });
+
+  test("enqueue without existing buffer creates one with timer", () => {
+    let flushed: number[] | null = null;
+    const buf = createAdditiveBuffer<number>({
+      timeoutMs: 10_000,
+      onFlush: (items) => {
+        flushed = [...items];
+      },
+    });
+    buf.enqueue("k1", 1);
+    expect(buf.isBuffered("k1")).toBe(true);
+    expect(buf.count("k1")).toBe(1);
+    expect(flushed).toBeNull();
+    buf.cancel("k1");
+  });
+
+  test("three rapid enqueues coalesce into one flush", async () => {
+    const flushes: string[][] = [];
+    const buf = createAdditiveBuffer<string>({
+      timeoutMs: 20,
+      onFlush: (items) => {
+        flushes.push([...items]);
+      },
+      label: "test-coalesce",
+    });
+
+    buf.enqueue("k", "a");
+    await sleep(5);
+    buf.enqueue("k", "b");
+    await sleep(5);
+    buf.enqueue("k", "c");
+    expect(buf.count("k")).toBe(3);
+
+    // Wait for debounce to elapse
+    await sleep(50);
+
+    expect(flushes.length).toBe(1);
+    expect(flushes[0]).toEqual(["a", "b", "c"]);
+    expect(buf.isBuffered("k")).toBe(false);
+  });
+
+  test("enqueue resets the timer", async () => {
+    const flushes: number[][] = [];
+    const buf = createAdditiveBuffer<number>({
+      timeoutMs: 30,
+      onFlush: (items) => {
+        flushes.push([...items]);
+      },
+    });
+
+    buf.enqueue("k", 1);
+    await sleep(20); // 20 < 30, timer would have NOT fired
+    buf.enqueue("k", 2); // resets
+    await sleep(20); // another 20 < 30
+    buf.enqueue("k", 3); // resets again
+
+    expect(flushes.length).toBe(0);
+    await sleep(60);
+    expect(flushes.length).toBe(1);
+    expect(flushes[0]).toEqual([1, 2, 3]);
+  });
+
+  test("instantFlush fires immediately with reason='manual'", async () => {
+    let seenReason: string | null = null;
+    const buf = createAdditiveBuffer<number>({
+      timeoutMs: 10_000,
+      onFlush: (_items, _key, reason) => {
+        seenReason = reason;
+      },
+    });
+    buf.enqueue("k", 1);
+    await buf.instantFlush("k");
+    expect(seenReason).toBe("manual");
+    expect(buf.isBuffered("k")).toBe(false);
+  });
+
+  test("timer flush reports reason='timer'", async () => {
+    let seenReason: string | null = null;
+    const buf = createAdditiveBuffer<number>({
+      timeoutMs: 10,
+      onFlush: (_items, _key, reason) => {
+        seenReason = reason;
+      },
+    });
+    buf.enqueue("k", 1);
+    await sleep(40);
+    expect(seenReason).toBe("timer");
+  });
+
+  test("instantFlush on unknown key is a no-op", async () => {
+    let called = false;
+    const buf = createAdditiveBuffer<number>({
+      timeoutMs: 10_000,
+      onFlush: () => {
+        called = true;
+      },
+    });
+    await buf.instantFlush("nope");
+    expect(called).toBe(false);
+  });
+
+  test("cancel drops the buffer without flushing", async () => {
+    let called = false;
+    const buf = createAdditiveBuffer<number>({
+      timeoutMs: 20,
+      onFlush: () => {
+        called = true;
+      },
+    });
+    buf.enqueue("k", 1);
+    expect(buf.cancel("k")).toBe(true);
+    expect(buf.isBuffered("k")).toBe(false);
+    await sleep(50);
+    expect(called).toBe(false);
+  });
+
+  test("cancel on unknown key returns false", () => {
+    const buf = createAdditiveBuffer<number>({ timeoutMs: 10_000, onFlush: () => {} });
+    expect(buf.cancel("nope")).toBe(false);
+  });
+
+  test("enqueue rejects empty contextKey", () => {
+    const buf = createAdditiveBuffer<number>({ timeoutMs: 10_000, onFlush: () => {} });
+    expect(() => buf.enqueue("", 1)).toThrow(/contextKey/);
+  });
+
+  test("onFlush errors are swallowed (logged, buffer still clears)", async () => {
+    const buf = createAdditiveBuffer<number>({
+      timeoutMs: 10,
+      onFlush: () => {
+        throw new Error("boom");
+      },
+    });
+    buf.enqueue("k", 1);
+    await sleep(40);
+    expect(buf.isBuffered("k")).toBe(false);
+  });
+
+  test("buffers are independent across keys", async () => {
+    const flushes: Record<string, number[][]> = {};
+    const buf = createAdditiveBuffer<number>({
+      timeoutMs: 20,
+      onFlush: (items, key) => {
+        const arr = flushes[key] ?? [];
+        arr.push([...items]);
+        flushes[key] = arr;
+      },
+    });
+    buf.enqueue("a", 1);
+    buf.enqueue("b", 10);
+    buf.enqueue("a", 2);
+    await sleep(50);
+    expect(flushes.a).toEqual([[1, 2]]);
+    expect(flushes.b).toEqual([[10]]);
+  });
+
+  test("keys() returns active buffer keys", () => {
+    const buf = createAdditiveBuffer<number>({ timeoutMs: 10_000, onFlush: () => {} });
+    buf.enqueue("a", 1);
+    buf.enqueue("b", 2);
+    expect(new Set(buf.keys())).toEqual(new Set(["a", "b"]));
+    buf.cancel("a");
+    expect(buf.keys()).toEqual(["b"]);
+    buf.cancel("b");
+  });
+});

package/src/tests/additive-ingress.test.ts

@@ -0,0 +1,111 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { createIngressBuffer } from "../tasks/additive-ingress";
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+const FLAG = "TEST_ADDITIVE_INGRESS";
+
+describe("createIngressBuffer", () => {
+  beforeEach(() => {
+    process.env[FLAG] = "true";
+  });
+  afterEach(() => {
+    process.env[FLAG] = undefined;
+  });
+
+  test("env flag off → maybeBuffer always returns false", () => {
+    process.env[FLAG] = "false";
+    const flushes: string[][] = [];
+    const ib = createIngressBuffer<string>({
+      source: "test",
+      envFlag: FLAG,
+      timeoutMs: 20,
+      onFlush: (items) => {
+        flushes.push([...items]);
+      },
+    });
+    expect(ib.enabled).toBe(false);
+    expect(ib.maybeBuffer("ctx", true, "a")).toBe(false);
+    expect(ib.isBuffered("ctx")).toBe(false);
+  });
+
+  test("no sibling in flight → maybeBuffer returns false", () => {
+    const ib = createIngressBuffer<string>({
+      source: "test",
+      envFlag: FLAG,
+      timeoutMs: 20,
+      onFlush: () => {},
+    });
+    expect(ib.enabled).toBe(true);
+    expect(ib.maybeBuffer("ctx", false, "a")).toBe(false);
+  });
+
+  test("empty contextKey → maybeBuffer returns false", () => {
+    const ib = createIngressBuffer<string>({
+      source: "test",
+      envFlag: FLAG,
+      timeoutMs: 20,
+      onFlush: () => {},
+    });
+    expect(ib.maybeBuffer("", true, "a")).toBe(false);
+  });
+
+  test("enabled + sibling in flight + contextKey → buffers", async () => {
+    const flushes: Array<{ items: string[]; key: string; reason: string }> = [];
+    const ib = createIngressBuffer<string>({
+      source: "test",
+      envFlag: FLAG,
+      timeoutMs: 20,
+      onFlush: (items, key, reason) => {
+        flushes.push({ items: [...items], key, reason });
+      },
+    });
+    expect(ib.maybeBuffer("ctx", true, "one")).toBe(true);
+    expect(ib.maybeBuffer("ctx", true, "two")).toBe(true);
+    expect(ib.maybeBuffer("ctx", true, "three")).toBe(true);
+    expect(ib.count("ctx")).toBe(3);
+
+    await sleep(80);
+    expect(flushes.length).toBe(1);
+    expect(flushes[0]?.items).toEqual(["one", "two", "three"]);
+    expect(flushes[0]?.key).toBe("ctx");
+    expect(flushes[0]?.reason).toBe("timer");
+  });
+
+  test("instantFlush resolves immediately with reason=manual", async () => {
+    const flushes: Array<{ items: string[]; reason: string }> = [];
+    const ib = createIngressBuffer<string>({
+      source: "test",
+      envFlag: FLAG,
+      timeoutMs: 5000, // long
+      onFlush: (items, _key, reason) => {
+        flushes.push({ items: [...items], reason });
+      },
+    });
+    ib.maybeBuffer("k", true, "x");
+    ib.maybeBuffer("k", true, "y");
+    await ib.instantFlush("k");
+    expect(flushes.length).toBe(1);
+    expect(flushes[0]?.items).toEqual(["x", "y"]);
+    expect(flushes[0]?.reason).toBe("manual");
+  });
+
+  test("cancel drops items without flushing", async () => {
+    const flushes: string[][] = [];
+    const ib = createIngressBuffer<string>({
+      source: "test",
+      envFlag: FLAG,
+      timeoutMs: 20,
+      onFlush: (items) => {
+        flushes.push([...items]);
+      },
+    });
+    ib.maybeBuffer("k", true, "a");
+    ib.cancel("k");
+    await sleep(50);
+    expect(flushes.length).toBe(0);
+    expect(ib.isBuffered("k")).toBe(false);
+  });
+});

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

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { ClaudeAdapter } from "../providers/claude-adapter";
+import { ClaudeAdapter, mergeMcpConfig } from "../providers/claude-adapter";
 import type { ProviderSessionConfig } from "../providers/types";
 
 /** Minimal config for testing — sessions won't actually spawn in these unit tests */
@@ -103,6 +103,148 @@ describe("Claude stream-json event parsing", () => {
   });
 });
 
+describe("mergeMcpConfig (issue #369)", () => {
+  const TASK_ID = "task-abc-123";
+
+  test("returns only installed servers when base config is null", () => {
+    const installed = {
+      "my-mcp": {
+        type: "http",
+        url: "https://example.com",
+        headers: { Authorization: "Bearer x" },
+      },
+    };
+    const merged = mergeMcpConfig(null, installed, TASK_ID);
+    expect(merged.mcpServers["my-mcp"]).toEqual(installed["my-mcp"]);
+  });
+
+  test("returns only base servers when installedServers is null", () => {
+    const base = {
+      mcpServers: {
+        "agent-swarm": {
+          type: "http",
+          url: "http://localhost:3013/mcp",
+          headers: { Authorization: "Bearer KEY", "X-Agent-ID": "a1" },
+        },
+      },
+    };
+    const merged = mergeMcpConfig(base, null, TASK_ID);
+    const agentSwarm = merged.mcpServers["agent-swarm"] as Record<string, unknown>;
+    expect(agentSwarm).toBeDefined();
+    // Agent-swarm entry is augmented with X-Source-Task-Id
+    expect((agentSwarm.headers as Record<string, string>)["X-Source-Task-Id"]).toBe(TASK_ID);
+  });
+
+  test("installed servers OVERRIDE stale .mcp.json entries (precedence fix)", () => {
+    // Simulates: /workspace/.mcp.json has an entry baked at container startup with
+    // a stale OAuth Bearer; the per-session fetch returns a freshly-resolved Bearer.
+    // The merged config MUST carry the fresh token — this is the core of issue #369.
+    const base = {
+      mcpServers: {
+        stripe: {
+          type: "http",
+          url: "https://mcp.stripe.com",
+          headers: { Authorization: "Bearer STALE_TOKEN_FROM_STARTUP" },
+        },
+      },
+    };
+    const installed = {
+      stripe: {
+        type: "http",
+        url: "https://mcp.stripe.com",
+        headers: { Authorization: "Bearer FRESH_TOKEN_FROM_API" },
+      },
+    };
+    const merged = mergeMcpConfig(base, installed, TASK_ID);
+    const stripe = merged.mcpServers.stripe as Record<string, unknown>;
+    expect((stripe.headers as Record<string, string>).Authorization).toBe(
+      "Bearer FRESH_TOKEN_FROM_API",
+    );
+  });
+
+  test("installed-server removal is honored (uninstall propagates)", () => {
+    // Previously, if .mcp.json had `stripe` baked in but the server was uninstalled
+    // from the API, the stale entry persisted. With the precedence fix + skeleton
+    // .mcp.json, a server absent from installedServers stays in the merged config
+    // ONLY if it's also in base (e.g., manually-added) — no API-layer override is
+    // issued. This test confirms we don't spontaneously delete base entries; the
+    // docker-entrypoint change (don't bake installed servers) is what prevents
+    // stale uninstalls from persisting.
+    const base = {
+      mcpServers: {
+        "manually-configured": { type: "http", url: "https://x.test" },
+      },
+    };
+    const installed = {}; // Empty — nothing installed via API
+    const merged = mergeMcpConfig(base, installed, TASK_ID);
+    expect(merged.mcpServers["manually-configured"]).toBeDefined();
+  });
+
+  test("agent-swarm server gets X-Source-Task-Id injected", () => {
+    const base = {
+      mcpServers: {
+        "agent-swarm": {
+          type: "http",
+          url: "http://localhost:3013/mcp",
+          headers: { Authorization: "Bearer KEY", "X-Agent-ID": "a1" },
+        },
+      },
+    };
+    const merged = mergeMcpConfig(base, null, TASK_ID);
+    const agentSwarm = merged.mcpServers["agent-swarm"] as Record<string, unknown>;
+    const headers = agentSwarm.headers as Record<string, string>;
+    expect(headers["X-Source-Task-Id"]).toBe(TASK_ID);
+    // Existing headers preserved
+    expect(headers.Authorization).toBe("Bearer KEY");
+    expect(headers["X-Agent-ID"]).toBe("a1");
+  });
+
+  test("X-Source-Task-Id injection works on entry discovered by X-Agent-ID header", () => {
+    // Discovery path for non-standard server names.
+    const base = {
+      mcpServers: {
+        "custom-name-swarm": {
+          type: "http",
+          url: "http://localhost:3013/mcp",
+          headers: { Authorization: "Bearer KEY", "X-Agent-ID": "a1" },
+        },
+      },
+    };
+    const merged = mergeMcpConfig(base, null, TASK_ID);
+    const entry = merged.mcpServers["custom-name-swarm"] as Record<string, unknown>;
+    expect((entry.headers as Record<string, string>)["X-Source-Task-Id"]).toBe(TASK_ID);
+  });
+
+  test("does not mutate the input baseConfig", () => {
+    const base = {
+      mcpServers: {
+        stripe: {
+          type: "http",
+          url: "https://mcp.stripe.com",
+          headers: { Authorization: "Bearer STALE" },
+        },
+      },
+    };
+    const installed = {
+      stripe: {
+        type: "http",
+        url: "https://mcp.stripe.com",
+        headers: { Authorization: "Bearer FRESH" },
+      },
+    };
+    mergeMcpConfig(base, installed, TASK_ID);
+    // Original object should be untouched
+    expect((base.mcpServers.stripe.headers as Record<string, string>).Authorization).toBe(
+      "Bearer STALE",
+    );
+  });
+
+  test("empty base + empty installed yields empty mcpServers", () => {
+    const merged = mergeMcpConfig({ mcpServers: {} }, {}, TASK_ID);
+    expect(Object.keys(merged.mcpServers)).toHaveLength(0);
+  });
+});
+
 describe("Stale session retry logic", () => {
   test("--resume args are stripped correctly", () => {
     const args = ["--max-turns", "10", "--resume", "session-abc", "--verbose"];

package/src/tests/context-key-db.test.ts

@@ -0,0 +1,87 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlinkSync } from "node:fs";
+import {
+  closeDb,
+  completeTask,
+  createAgent,
+  createTaskExtended,
+  getInProgressTasksByContextKey,
+  initDb,
+} from "../be/db";
+import { slackContextKey } from "../tasks/context-key";
+
+const TEST_DB_PATH = "./test-context-key-db.sqlite";
+
+beforeAll(() => {
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(() => {
+  closeDb();
+  try {
+    unlinkSync(TEST_DB_PATH);
+    unlinkSync(`${TEST_DB_PATH}-wal`);
+    unlinkSync(`${TEST_DB_PATH}-shm`);
+  } catch {
+    // ignore
+  }
+});
+
+describe("contextKey persistence + lookup", () => {
+  test("createTaskExtended persists contextKey and getInProgressTasksByContextKey returns it", () => {
+    const agent = createAgent({
+      name: "ctx-key-agent-1",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const key = slackContextKey({ channelId: "C_TEST_1", threadTs: "1700000000.000001" });
+    const task = createTaskExtended("Hello", { agentId: agent.id, contextKey: key });
+
+    expect(task.contextKey).toBe(key);
+
+    const siblings = getInProgressTasksByContextKey(key);
+    expect(siblings.map((t) => t.id)).toContain(task.id);
+  });
+
+  test("getInProgressTasksByContextKey excludes terminal tasks", () => {
+    const agent = createAgent({
+      name: "ctx-key-agent-2",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const key = slackContextKey({ channelId: "C_TEST_2", threadTs: "1700000000.000002" });
+    const done = createTaskExtended("Done task", { agentId: agent.id, contextKey: key });
+    const pending = createTaskExtended("Pending task", { agentId: agent.id, contextKey: key });
+
+    completeTask(done.id, "ok");
+
+    const siblings = getInProgressTasksByContextKey(key);
+    const ids = siblings.map((t) => t.id);
+    expect(ids).toContain(pending.id);
+    expect(ids).not.toContain(done.id);
+  });
+
+  test("getInProgressTasksByContextKey returns empty for unknown key", () => {
+    const results = getInProgressTasksByContextKey("task:slack:C_NONE:0");
+    expect(results).toEqual([]);
+  });
+
+  test("child task inherits contextKey from parent", () => {
+    const agent = createAgent({
+      name: "ctx-key-agent-3",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const key = slackContextKey({ channelId: "C_TEST_3", threadTs: "1700000000.000003" });
+    const parent = createTaskExtended("Parent", { agentId: agent.id, contextKey: key });
+    const child = createTaskExtended("Child", { agentId: agent.id, parentTaskId: parent.id });
+
+    expect(child.contextKey).toBe(key);
+  });
+});