@desplega.ai/agent-swarm 1.131.1 → 1.134.0

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

@@ -1011,6 +1011,36 @@ describe("buildCodexConfig", () => {
     expect(emitted.filter((e) => e.type === "raw_stderr")).toHaveLength(0);
   });
 
+  test("forwards the per-boot runtime identity to the swarm MCP headers", async () => {
+    globalThis.fetch = stubFetch({ servers: [], total: 0 });
+    const prev = process.env.SWARM_RUNTIME_INSTANCE_ID;
+    process.env.SWARM_RUNTIME_INSTANCE_ID = "codex-runtime-1";
+    try {
+      const merged = await buildCodexConfig(cfg(), "gpt-5.4", () => {});
+      const headers = (merged.mcp_servers as Record<string, Record<string, unknown>>)["agent-swarm"]
+        ?.http_headers as Record<string, string>;
+      expect(headers["X-Runtime-Instance-ID"]).toBe("codex-runtime-1");
+    } finally {
+      if (prev === undefined) delete process.env.SWARM_RUNTIME_INSTANCE_ID;
+      else process.env.SWARM_RUNTIME_INSTANCE_ID = prev;
+    }
+  });
+
+  test("no runtime identity in the environment → no runtime header", async () => {
+    globalThis.fetch = stubFetch({ servers: [], total: 0 });
+    const prev = process.env.SWARM_RUNTIME_INSTANCE_ID;
+    delete process.env.SWARM_RUNTIME_INSTANCE_ID;
+    try {
+      const merged = await buildCodexConfig(cfg(), "gpt-5.4", () => {});
+      const headers = (merged.mcp_servers as Record<string, Record<string, unknown>>)["agent-swarm"]
+        ?.http_headers as Record<string, string>;
+      expect(headers["X-Runtime-Instance-ID"]).toBeUndefined();
+    } finally {
+      if (prev === undefined) delete process.env.SWARM_RUNTIME_INSTANCE_ID;
+      else process.env.SWARM_RUNTIME_INSTANCE_ID = prev;
+    }
+  });
+
   test("one HTTP-transport installed server → both 'agent-swarm' and installed server present", async () => {
     globalThis.fetch = stubFetch({
       servers: [

package/src/tests/create-task-validation.test.ts

@@ -0,0 +1,128 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlinkSync } from "node:fs";
+import {
+  createServer as createHttpServer,
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+} from "node:http";
+import { type CreateTaskOptions, closeDb, createTaskExtended, getDb, initDb } from "../be/db";
+import { handleMcpBridge } from "../http/mcp-bridge";
+import { getPathSegments } from "../http/utils";
+
+const TEST_DB_PATH = "./test-create-task-validation.sqlite";
+
+let server: Server;
+let baseUrl: string;
+
+function taskCount(): number {
+  return (getDb().prepare("SELECT COUNT(*) AS c FROM agent_tasks").get() as { c: number }).c;
+}
+
+beforeAll(async () => {
+  initDb(TEST_DB_PATH);
+  server = createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    const myAgentId = req.headers["x-agent-id"] as string | undefined;
+    const pathSegments = getPathSegments(req.url || "");
+    const ok = await handleMcpBridge(req, res, pathSegments, undefined, myAgentId);
+    if (!ok) {
+      res.writeHead(404);
+      res.end("Not Found");
+    }
+  });
+  await new Promise<void>((resolve) => server.listen(0, resolve));
+  const addr = server.address();
+  if (!addr || typeof addr === "string") throw new Error("no port");
+  baseUrl = `http://127.0.0.1:${addr.port}`;
+});
+
+afterAll(() => {
+  server.close();
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      unlinkSync(TEST_DB_PATH + suffix);
+    } catch {
+      // ignore
+    }
+  }
+});
+
+describe("scripts-bridge input validation", () => {
+  // REGRESSION TEST for the 2026-08-18 incident: an inline script POSTed
+  // priority: "high" to /api/mcp-bridge; the bridge invoked the send-task
+  // handler without parsing args, the TEXT value landed in the INTEGER
+  // priority column, and response validation then 500'd every task listing.
+  test("raw priority:'high' through the bridge returns 400 and writes no row", async () => {
+    const before = taskCount();
+    const res = await fetch(`${baseUrl}/api/mcp-bridge`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "x-agent-id": "test-agent" },
+      body: JSON.stringify({
+        tool: "send-task",
+        args: { task: "incident regression probe", priority: "high" },
+      }),
+    });
+    expect(res.status).toBe(400);
+    const body = (await res.json()) as { error?: string };
+    expect(body.error).toContain("Invalid arguments for tool 'send-task'");
+    expect(taskCount()).toBe(before);
+  });
+});
+
+describe("createTaskExtended input validation", () => {
+  test("string priority throws and writes no row", () => {
+    const before = taskCount();
+    expect(() =>
+      createTaskExtended("bad priority", { priority: "high" } as unknown as CreateTaskOptions),
+    ).toThrow();
+    expect(taskCount()).toBe(before);
+  });
+
+  test("priority 101 throws", () => {
+    expect(() => createTaskExtended("too high", { priority: 101 })).toThrow();
+  });
+
+  test("priority -1 throws", () => {
+    expect(() => createTaskExtended("too low", { priority: -1 })).toThrow();
+  });
+
+  test("non-integer priority throws", () => {
+    expect(() => createTaskExtended("fractional", { priority: 49.5 })).toThrow();
+  });
+
+  test("absent priority defaults to 50", () => {
+    const t = createTaskExtended("default priority");
+    expect(t.priority).toBe(50);
+  });
+
+  test("explicit priority 0 stays 0", () => {
+    const t = createTaskExtended("zero priority", { priority: 0 });
+    expect(t.priority).toBe(0);
+  });
+
+  test("unknown keys are stripped and the task is still created", () => {
+    const t = createTaskExtended("extra keys", {
+      priority: 10,
+      nonsense: true,
+    } as unknown as CreateTaskOptions);
+    expect(t.priority).toBe(10);
+  });
+
+  test("empty task throws", () => {
+    expect(() => createTaskExtended("")).toThrow();
+  });
+
+  test("valid full options pass through unchanged", () => {
+    const t = createTaskExtended("full options", {
+      priority: 90,
+      tags: ["urgent"],
+      taskType: "bug",
+      status: "backlog",
+      source: "api",
+    });
+    expect(t.priority).toBe(90);
+    expect(t.status).toBe("backlog");
+    expect(t.tags).toEqual(["urgent"]);
+  });
+});

package/src/tests/credential-wait.test.ts

@@ -1,5 +1,9 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { awaitCredentials, BootMaxWaitExceededError } from "../commands/credential-wait";
+import {
+  awaitCredentials,
+  BootMaxWaitExceededError,
+  retryBootStep,
+} from "../commands/credential-wait";
 
 /**
  * Capture-only logger so test output stays clean and we can assert on
@@ -280,3 +284,65 @@ describe("awaitCredentials", () => {
     expect(probedPaths).toContain("/home/worker/.codex/auth.json");
   });
 });
+
+describe("retryBootStep", () => {
+  test("returns after the first success without sleeping", async () => {
+    const sleeper = makeSleeper();
+    let calls = 0;
+    await retryBootStep(
+      async () => {
+        calls++;
+      },
+      { sleep: sleeper.fn, log: () => {} },
+    );
+    expect(calls).toBe(1);
+    expect(sleeper.calls).toEqual([]);
+  });
+
+  test("retries with exponential backoff until success", async () => {
+    const sleeper = makeSleeper();
+    const logger = makeLogger();
+    let calls = 0;
+    await retryBootStep(
+      async () => {
+        calls++;
+        if (calls < 3) throw new Error(`transient ${calls}`);
+      },
+      { sleep: sleeper.fn, log: logger.fn, initialDelayMs: 100, maxDelayMs: 1000 },
+    );
+    expect(calls).toBe(3);
+    expect(sleeper.calls).toEqual([100, 200]);
+    expect(logger.lines).toHaveLength(2);
+    expect(logger.lines[0]).toContain("attempt 1/5");
+  });
+
+  test("propagates the last error once attempts are exhausted", async () => {
+    const sleeper = makeSleeper();
+    let calls = 0;
+    await expect(
+      retryBootStep(
+        async () => {
+          calls++;
+          throw new Error(`down ${calls}`);
+        },
+        { attempts: 3, sleep: sleeper.fn, log: () => {} },
+      ),
+    ).rejects.toThrow("down 3");
+    expect(calls).toBe(3);
+    // No sleep after the final attempt.
+    expect(sleeper.calls).toHaveLength(2);
+  });
+
+  test("caps the backoff at maxDelayMs", async () => {
+    const sleeper = makeSleeper();
+    let calls = 0;
+    await retryBootStep(
+      async () => {
+        calls++;
+        if (calls < 5) throw new Error("transient");
+      },
+      { sleep: sleeper.fn, log: () => {}, initialDelayMs: 400, maxDelayMs: 1000 },
+    );
+    expect(sleeper.calls).toEqual([400, 800, 1000, 1000]);
+  });
+});