@desplega.ai/agent-swarm 1.79.4 → 1.80.1

package/src/tests/scripts-runtime-secret-egress.test.ts

@@ -0,0 +1,44 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { runScript } from "../scripts-runtime/loader";
+import { refreshSecretScrubberCache } from "../utils/secret-scrubber";
+
+const savedEnv = { ...process.env };
+
+beforeEach(() => {
+  process.env.AGENT_SWARM_API_KEY = "runtime-egress-secret-1234567890";
+  refreshSecretScrubberCache();
+});
+
+afterEach(() => {
+  for (const key of Object.keys(process.env)) {
+    if (!(key in savedEnv)) delete process.env[key];
+  }
+  for (const [key, value] of Object.entries(savedEnv)) {
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+  refreshSecretScrubberCache();
+});
+
+describe("runtime secret egress", () => {
+  test("scrubObject catches unwrapped returned config secrets", async () => {
+    const output = await runScript({
+      agentId: "agent-1",
+      resources: { memoryMb: 2048 },
+      source:
+        "export default async (_args, ctx) => ({ leaked: ctx.stdlib.Redacted.value(ctx.swarm.config.apiKey) });",
+    });
+
+    expect(output.result).toEqual({ leaked: "[REDACTED:AGENT_SWARM_API_KEY]" });
+  });
+
+  test("wrapped config values stringify to redacted in the result file", async () => {
+    const output = await runScript({
+      agentId: "agent-1",
+      resources: { memoryMb: 2048 },
+      source: "export default async (_args, ctx) => ({ wrapped: ctx.swarm.config.apiKey });",
+    });
+
+    expect(output.result).toEqual({ wrapped: "<redacted>" });
+  });
+});

package/src/tests/scripts-runtime.test.ts

@@ -0,0 +1,289 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { runScript } from "../scripts-runtime/loader";
+import { refreshSecretScrubberCache } from "../utils/secret-scrubber";
+
+const savedEnv = { ...process.env };
+const resources = { memoryMb: 2048, cpuTimeSec: 20, maxStdoutBytes: 1_048_576 };
+
+beforeEach(() => {
+  process.env.AGENT_SWARM_API_KEY = "runtime-test-secret-1234567890";
+  delete process.env.API_KEY;
+  process.env.MCP_BASE_URL = "http://localhost:3013";
+  refreshSecretScrubberCache();
+});
+
+afterEach(() => {
+  for (const key of Object.keys(process.env)) {
+    if (!(key in savedEnv)) delete process.env[key];
+  }
+  for (const [key, value] of Object.entries(savedEnv)) {
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+  refreshSecretScrubberCache();
+});
+
+describe("runScript", () => {
+  test("runs a trivial transform", async () => {
+    const output = await runScript({
+      agentId: "agent-1",
+      args: { x: 1 },
+      resources,
+      source: "export default async (args) => args.x + 1;",
+    });
+
+    expect(output.error).toBeUndefined();
+    expect(output.result).toBe(2);
+    expect(output.exitCode).toBe(0);
+  });
+
+  test("ctx.stdlib.fetch returns a Response and fetchJson returns parsed JSON", async () => {
+    const output = await runScript({
+      agentId: "agent-1",
+      args: { url: 'data:application/json,{"ok":true}' },
+      resources,
+      source: `
+        export default async (args, ctx) => {
+          const response = await ctx.stdlib.fetch(args.url);
+          const parsed = await ctx.stdlib.fetchJson(args.url);
+          return { status: response.status, parsed };
+        };
+      `,
+    });
+
+    expect(output.error).toBeUndefined();
+    expect(output.result).toEqual({ status: 200, parsed: { ok: true } });
+  });
+
+  test("ctx.swarm bridge round-trips kv_set then kv_get", async () => {
+    const entries = new Map<string, unknown>();
+    const server = Bun.serve({
+      port: 0,
+      async fetch(req) {
+        expect(req.headers.get("authorization")).toBe("Bearer runtime-test-secret-1234567890");
+        expect(req.headers.get("x-agent-id")).toBe("agent-1");
+
+        const url = new URL(req.url);
+        if (req.method === "PUT" && url.pathname.startsWith("/api/kv/")) {
+          const key = decodeURIComponent(url.pathname.slice("/api/kv/".length));
+          const body = (await req.json()) as { value: unknown };
+          entries.set(key, body.value);
+          return Response.json({ key, value: body.value });
+        }
+        if (req.method === "GET" && url.pathname.startsWith("/api/kv/")) {
+          const key = decodeURIComponent(url.pathname.slice("/api/kv/".length));
+          return Response.json({ key, value: entries.get(key) ?? null });
+        }
+        return Response.json({ error: "not found" }, { status: 404 });
+      },
+    });
+
+    try {
+      const output = await runScript({
+        agentId: "agent-1",
+        mcpBaseUrl: `http://127.0.0.1:${server.port}`,
+        resources,
+        source: `
+          export default async (_args, ctx) => {
+            await ctx.swarm.kv_set({ key: "bridge-smoke", value: { ok: true } });
+            return await ctx.swarm.kv_get({ key: "bridge-smoke" });
+          };
+        `,
+      });
+
+      expect(output.error).toBeUndefined();
+      expect(output.result).toEqual({
+        success: true,
+        status: 200,
+        data: { key: "bridge-smoke", value: { ok: true } },
+      });
+    } finally {
+      server.stop(true);
+    }
+  });
+
+  test("bare stdlib imports resolve through runtime shims", async () => {
+    const output = await runScript({
+      agentId: "agent-1",
+      resources,
+      source: `
+        import { table } from "stdlib";
+        export default async () => table([{ a: 1 }]);
+      `,
+    });
+
+    expect(output.error).toBeUndefined();
+    expect(output.result).toContain("a");
+    expect(output.result).toContain("1");
+  });
+
+  test("timeout kills a running script", async () => {
+    const started = Date.now();
+    const output = await runScript({
+      agentId: "agent-1",
+      timeoutMs: 150,
+      resources: { ...resources, wallClockMs: 150 },
+      source: "export default async () => new Promise(() => {});",
+    });
+
+    expect(output.error).toBe("timeout");
+    expect(Date.now() - started).toBeLessThan(1000);
+  });
+
+  test("stdout is capped and marked truncated", async () => {
+    const output = await runScript({
+      agentId: "agent-1",
+      resources: { ...resources, maxStdoutBytes: 128 },
+      source: "export default async () => { console.log('x'.repeat(2048)); return 'ok'; };",
+    });
+
+    expect(output.result).toBe("ok");
+    expect(output.truncated.stdout).toBe(true);
+    expect(output.stdout.length).toBeLessThanOrEqual(128);
+  });
+
+  test("AbortSignal aborts a running script", async () => {
+    const controller = new AbortController();
+    setTimeout(() => controller.abort(), 50);
+    const started = Date.now();
+
+    const output = await runScript({
+      agentId: "agent-1",
+      signal: controller.signal,
+      resources,
+      source: "export default async () => new Promise(() => {});",
+    });
+
+    expect(output.error).toBe("killed");
+    expect(Date.now() - started).toBeLessThan(1000);
+  });
+
+  test("subprocess env is stripped to the explicit allowlist", async () => {
+    process.env.API_KEY = "legacy-secret-that-must-not-leak";
+    process.env.AGENT_SWARM_API_KEY = "preferred-secret-that-must-not-leak";
+    refreshSecretScrubberCache();
+
+    const output = await runScript({
+      agentId: "agent-1",
+      resources,
+      source: `
+        export default async () => ({
+          keys: Object.keys(process.env).sort(),
+          apiKey: process.env.API_KEY,
+          agentSwarmApiKey: process.env.AGENT_SWARM_API_KEY,
+        });
+      `,
+    });
+
+    expect(output.error).toBeUndefined();
+    expect(output.result).toEqual({
+      keys: [
+        "HOME",
+        "LANG",
+        "LC_ALL",
+        "PATH",
+        "SWARM_SCRIPT_ARGS_FILE",
+        "SWARM_SCRIPT_RESULT_FILE",
+        "SWARM_SCRIPT_SOURCE_FILE",
+        "SWARM_SCRIPT_TMPDIR",
+        "TMPDIR",
+      ],
+    });
+  });
+
+  test("workspace-rw is rejected in v1", async () => {
+    const output = await runScript({
+      agentId: "agent-1",
+      fsMode: "workspace-rw",
+      source: "export default async () => true;",
+    });
+
+    expect(output.error).toBe("executor_error");
+    expect(output.stderr).toContain("workspace-rw");
+  });
+
+  test("SCRIPT_RUNTIME_DIR bundle path works (compiled binary mode regression)", async () => {
+    // Simulate compiled binary mode: pre-build bundles to a temp dir and set
+    // SCRIPT_RUNTIME_DIR so the executor uses them instead of import.meta.url paths.
+    const tmpdir = `${process.env.TMPDIR ?? "/tmp"}/script-runtime-test-${crypto.randomUUID()}`;
+    await Bun.$`mkdir -p ${tmpdir}`;
+    try {
+      const runtimeSrc = new URL("../scripts-runtime", import.meta.url).pathname;
+      await Bun.$`bun build ${runtimeSrc}/eval-harness.ts --target bun --no-splitting --outfile ${tmpdir}/eval-harness.bundle.js`.quiet();
+      await Bun.$`bun build ${runtimeSrc}/stdlib/index.ts --target bun --no-splitting --outfile ${tmpdir}/stdlib.bundle.js`.quiet();
+      await Bun.$`bun build ${runtimeSrc}/swarm-sdk.ts --target bun --no-splitting --outfile ${tmpdir}/swarm-sdk.bundle.js`.quiet();
+
+      process.env.SCRIPT_RUNTIME_DIR = tmpdir;
+
+      const output = await runScript({
+        agentId: "agent-1",
+        args: { x: 42 },
+        resources,
+        source: "export default async (args) => args.x * 2;",
+      });
+
+      expect(output.error).toBeUndefined();
+      expect(output.result).toBe(84);
+      expect(output.exitCode).toBe(0);
+    } finally {
+      delete process.env.SCRIPT_RUNTIME_DIR;
+      await Bun.$`rm -rf ${tmpdir}`;
+    }
+  });
+
+  test("args arrives as a parsed object, not a JSON string", async () => {
+    // Regression: eval-harness must deliver a parsed object to user code even
+    // when the caller serializes args as a JSON string (double-serialization).
+    // Before the fix, property access like args.foo would always be undefined.
+    const output = await runScript({
+      agentId: "agent-1",
+      args: { foo: "bar" },
+      resources,
+      source: `
+        export default async (args) => {
+          if (typeof args !== "object" || args === null) throw new Error("args is not an object: " + typeof args);
+          if (args.foo !== "bar") throw new Error("args.foo expected 'bar', got: " + args.foo);
+          return { ok: true, foo: args.foo };
+        };
+      `,
+    });
+
+    expect(output.error).toBeUndefined();
+    expect(output.result).toEqual({ ok: true, foo: "bar" });
+    expect(output.exitCode).toBe(0);
+  });
+
+  test("args parsed correctly in compiled binary mode (SCRIPT_RUNTIME_DIR)", async () => {
+    // Same regression exercised through the compiled-binary (SCRIPT_RUNTIME_DIR) code path.
+    const tmpdir = `${process.env.TMPDIR ?? "/tmp"}/script-runtime-test-${crypto.randomUUID()}`;
+    await Bun.$`mkdir -p ${tmpdir}`;
+    try {
+      const runtimeSrc = new URL("../scripts-runtime", import.meta.url).pathname;
+      await Bun.$`bun build ${runtimeSrc}/eval-harness.ts --target bun --no-splitting --outfile ${tmpdir}/eval-harness.bundle.js`.quiet();
+      await Bun.$`bun build ${runtimeSrc}/stdlib/index.ts --target bun --no-splitting --outfile ${tmpdir}/stdlib.bundle.js`.quiet();
+      await Bun.$`bun build ${runtimeSrc}/swarm-sdk.ts --target bun --no-splitting --outfile ${tmpdir}/swarm-sdk.bundle.js`.quiet();
+
+      process.env.SCRIPT_RUNTIME_DIR = tmpdir;
+
+      const output = await runScript({
+        agentId: "agent-1",
+        args: { foo: "bar" },
+        resources,
+        source: `
+          export default async (args) => {
+            if (typeof args !== "object" || args === null) throw new Error("args is not an object: " + typeof args);
+            if (args.foo !== "bar") throw new Error("args.foo expected 'bar', got: " + args.foo);
+            return { ok: true, foo: args.foo };
+          };
+        `,
+      });
+
+      expect(output.error).toBeUndefined();
+      expect(output.result).toEqual({ ok: true, foo: "bar" });
+      expect(output.exitCode).toBe(0);
+    } finally {
+      delete process.env.SCRIPT_RUNTIME_DIR;
+      await Bun.$`rm -rf ${tmpdir}`;
+    }
+  });
+});

package/src/tests/sdk-allowlist.test.ts

@@ -0,0 +1,59 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, initDb } from "../be/db";
+import { mcpToolNameForSdkMethod, SDK_ALLOWLIST } from "../scripts-runtime/sdk-allowlist";
+import type { SwarmConfig } from "../scripts-runtime/swarm-config";
+import { createSwarmSdk } from "../scripts-runtime/swarm-sdk";
+import { createServer } from "../server";
+
+const TEST_DB_PATH = "./test-sdk-allowlist.sqlite";
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(path + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+describe("script SDK allowlist", () => {
+  let registeredTools: Record<string, unknown>;
+
+  beforeAll(async () => {
+    await removeDbFiles(TEST_DB_PATH);
+    initDb(TEST_DB_PATH);
+    const server = createServer();
+    registeredTools = (server as unknown as { _registeredTools: Record<string, unknown> })
+      ._registeredTools;
+  });
+
+  afterAll(async () => {
+    closeDb();
+    await removeDbFiles(TEST_DB_PATH);
+  });
+
+  test("every SDK allowlist entry resolves to a live MCP tool", () => {
+    const missing = SDK_ALLOWLIST.map((name) => mcpToolNameForSdkMethod(name)).filter(
+      (name) => !(name in registeredTools),
+    );
+    expect(missing).toEqual([]);
+  });
+
+  test("runtime proxy rejects non-allowlisted tools before fetch", async () => {
+    const sdk = createSwarmSdk({} as SwarmConfig);
+    await expect(sdk.join_swarm({})).rejects.toThrow(
+      "Tool 'join_swarm' is not exposed to scripts (lifecycle/cred tool)",
+    );
+  });
+
+  test("bundled swarm-sdk.d.ts exposes only allowlisted methods", async () => {
+    const types = await Bun.file("src/scripts-runtime/types/swarm-sdk.d.ts").text();
+    for (const name of SDK_ALLOWLIST) {
+      expect(types).toContain(`${name}(args`);
+    }
+    expect(types).not.toContain("join_swarm(");
+    expect(types).not.toContain("start_worker(");
+  });
+});

package/src/tests/secret-scrubber.test.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { refreshSecretScrubberCache, scrubSecrets } from "../utils/secret-scrubber";
+import { refreshSecretScrubberCache, scrubObject, scrubSecrets } from "../utils/secret-scrubber";
 
 // Snapshot/restore process.env between tests so env-derived cache entries
 // don't leak across cases.
@@ -113,6 +113,17 @@ describe("scrubSecrets — env-based replacement", () => {
     expect(out).not.toContain("sk-proj-abcd1234567890");
   });
 
+  test("redacts OTLP exporter headers from env", () => {
+    process.env.OTEL_EXPORTER_OTLP_HEADERS = "signoz-ingestion-key=localSignozKey_1234567890abcdef";
+    refreshSecretScrubberCache();
+
+    const out = scrubSecrets(
+      "OTEL_EXPORTER_OTLP_HEADERS=signoz-ingestion-key=localSignozKey_1234567890abcdef",
+    );
+
+    expect(out).toBe("OTEL_EXPORTER_OTLP_HEADERS=[REDACTED:OTEL_EXPORTER_OTLP_HEADERS]");
+  });
+
   test("cache rebuilds after refresh when new secret is added", () => {
     const out1 = scrubSecrets("no secret yet here_abcdefghij");
     expect(out1).toBe("no secret yet here_abcdefghij");
@@ -202,6 +213,14 @@ describe("scrubSecrets — regex patterns", () => {
     const out = scrubSecrets("token=ghp_1234567890abcdefABCDEF1234567890ABCD");
     expect(out).toContain("[REDACTED:github_token]");
   });
+
+  test("redacts SigNoz ingestion-key headers even when env is empty", () => {
+    const out = scrubSecrets(
+      "OTEL_EXPORTER_OTLP_HEADERS=signoz-ingestion-key=localSignozKey_1234567890abcdef",
+    );
+
+    expect(out).toBe("OTEL_EXPORTER_OTLP_HEADERS=[REDACTED:signoz_ingestion_key]");
+  });
 });
 
 describe("scrubSecrets — does not over-scrub", () => {
@@ -247,3 +266,37 @@ describe("scrubSecrets — does not over-scrub", () => {
     expect(out).toBe("example: ghp_TOKEN and glpat-xyz (both too short)");
   });
 });
+
+describe("scrubObject", () => {
+  test("scrubs nested object and array string leaves", () => {
+    process.env.NESTED_TOKEN = "nested-secret-value-1234567890";
+    refreshSecretScrubberCache();
+
+    const out = scrubObject({
+      keep: 1,
+      nested: {
+        secret: "nested-secret-value-1234567890",
+        list: ["safe", "nested-secret-value-1234567890"],
+      },
+      nullish: null,
+      bool: true,
+    });
+
+    expect(out).toEqual({
+      keep: 1,
+      nested: {
+        secret: "[REDACTED:NESTED_TOKEN]",
+        list: ["safe", "[REDACTED:NESTED_TOKEN]"],
+      },
+      nullish: null,
+      bool: true,
+    });
+  });
+
+  test("handles circular references without recursing forever", () => {
+    const value: Record<string, unknown> = { a: "ok" };
+    value.self = value;
+
+    expect(scrubObject(value)).toEqual({ a: "ok", self: "[Circular]" });
+  });
+});

package/src/tests/session-costs-codex-recompute.test.ts

@@ -98,7 +98,7 @@ interface CreatedCostResponse {
   cost: {
     id: string;
     totalCostUsd: number;
-    costSource: "harness" | "pricing-table";
+    costSource: "harness" | "pricing-table" | "unpriced";
     model: string;
   };
 }
@@ -153,15 +153,9 @@ describe("Phase 6 — POST /api/session-costs: Codex USD recompute", () => {
     expect(body.cost.totalCostUsd).toBeCloseTo(6.64, 5);
   });
 
-  test("provider=codex but a token class is missing → falls back to worker value, costSource='harness'", async () => {
-    // Only seed input + cached_input. Missing output forces fallback.
-    insertPricingRow({
-      provider: "codex",
-      model: "codex-test-synth",
-      tokenClass: "input",
-      effectiveFrom: 1,
-      pricePerMillionUsd: 2.0,
-    });
+  test("provider=codex but input/output rows missing → 'unpriced', worker value preserved", async () => {
+    // Only seed cached_input. Missing input + output blocks recompute and
+    // Phase 2 tags the row 'unpriced' (no rates means we can't trust harness USD either).
     insertPricingRow({
       provider: "codex",
       model: "codex-test-synth",
@@ -186,13 +180,16 @@ describe("Phase 6 — POST /api/session-costs: Codex USD recompute", () => {
     });
     expect(res.status).toBe(201);
     const body = (await res.json()) as CreatedCostResponse;
-    expect(body.cost.costSource).toBe("harness");
-    // Worker value preserved verbatim.
+    // Phase 2: provider tagged but no input/output rows ⇒ 'unpriced'.
+    expect(body.cost.costSource).toBe("unpriced");
+    // Worker value preserved verbatim — we don't fabricate one.
     expect(body.cost.totalCostUsd).toBe(1.23);
   });
 
-  test("provider=claude records harness USD as-is regardless of DB pricing rows", async () => {
-    // Even if there are codex pricing rows, claude must NOT be touched.
+  test("provider=claude with no pricing rows for the model → 'unpriced' (Phase 2)", async () => {
+    // Phase 2 extended the recompute path from codex-only to every provider.
+    // With no pricing rows seeded for ('claude', 'sonnet-4'), the row is
+    // tagged 'unpriced' rather than 'harness' — the UI surfaces it as a yellow badge.
     const res = await authedFetch(`/api/session-costs`, {
       method: "POST",
       body: JSON.stringify({
@@ -209,20 +206,35 @@ describe("Phase 6 — POST /api/session-costs: Codex USD recompute", () => {
     });
     expect(res.status).toBe(201);
     const body = (await res.json()) as CreatedCostResponse;
-    expect(body.cost.costSource).toBe("harness");
+    expect(body.cost.costSource).toBe("unpriced");
     expect(body.cost.totalCostUsd).toBe(7.77);
   });
 
-  test("provider=pi records harness USD as-is regardless of DB pricing rows", async () => {
+  test("provider=pi with seeded pricing rows → recomputes (Phase 2)", async () => {
+    // Phase 2 widens recompute beyond codex. Seed pi rows so we get a hit.
+    insertPricingRow({
+      provider: "pi",
+      model: "pi-test",
+      tokenClass: "input",
+      effectiveFrom: 1,
+      pricePerMillionUsd: 0.5,
+    });
+    insertPricingRow({
+      provider: "pi",
+      model: "pi-test",
+      tokenClass: "output",
+      effectiveFrom: 1,
+      pricePerMillionUsd: 3.0,
+    });
     const res = await authedFetch(`/api/session-costs`, {
       method: "POST",
       body: JSON.stringify({
         sessionId: "pi-passthrough-1",
         agentId: testAgent.id,
-        totalCostUsd: 0.42,
-        inputTokens: 10,
-        outputTokens: 5,
-        model: "openrouter/google/gemini-3-flash-preview",
+        totalCostUsd: 0.42, // expected to be overwritten
+        inputTokens: 1_000_000, // 1M input
+        outputTokens: 1_000_000, // 1M output
+        model: "pi-test",
         provider: "pi",
         durationMs: 1_000,
         numTurns: 1,
@@ -230,8 +242,9 @@ describe("Phase 6 — POST /api/session-costs: Codex USD recompute", () => {
     });
     expect(res.status).toBe(201);
     const body = (await res.json()) as CreatedCostResponse;
-    expect(body.cost.costSource).toBe("harness");
-    expect(body.cost.totalCostUsd).toBe(0.42);
+    expect(body.cost.costSource).toBe("pricing-table");
+    // 1M @ 0.5 + 1M @ 3.0 = $3.50
+    expect(body.cost.totalCostUsd).toBeCloseTo(3.5, 5);
   });
 
   test("provider field omitted → no recompute, costSource='harness' (back-compat)", async () => {