@desplega.ai/agent-swarm 1.91.0 → 1.92.1

package/src/tests/create-page-tool.test.ts

@@ -63,14 +63,13 @@ describe("create_page MCP tool", () => {
     }
   });
 
-  test("first call creates a row + returns shareable URLs", async () => {
+  test("first call creates an authed row by default + returns shareable URLs", async () => {
     const tool = buildServer();
     const result = (await tool.handler(
       {
         title: "Hello Page",
         body: "<h1>hello</h1>",
         contentType: "text/html",
-        authMode: "public",
       },
       fakeMeta,
     )) as {
@@ -97,6 +96,24 @@ describe("create_page MCP tool", () => {
     const row = getPageBySlug(agentId, "hello-page");
     expect(row).not.toBeNull();
     expect(row!.body).toBe("<h1>hello</h1>");
+    expect(row!.authMode).toBe("authed");
+  });
+
+  test("explicit public auth mode is preserved", async () => {
+    const tool = buildServer();
+    await tool.handler(
+      {
+        title: "Public Page",
+        body: "<h1>public</h1>",
+        contentType: "text/html",
+        authMode: "public",
+      },
+      fakeMeta,
+    );
+
+    const row = getPageBySlug(agentId, "public-page");
+    expect(row).not.toBeNull();
+    expect(row!.authMode).toBe("public");
   });
 
   test("re-running with the same slug upserts + bumps edit-counter", async () => {

package/src/tests/db-query.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import { DbQueryInputSchema, resolveDbQuerySql } from "../http/db-query";
+
+describe("db-query input compatibility", () => {
+  test("canonical sql input resolves to sql", () => {
+    const parsed = DbQueryInputSchema.parse({ sql: "SELECT 1", params: [] });
+
+    expect(resolveDbQuerySql(parsed)).toBe("SELECT 1");
+  });
+
+  test("legacy query input remains a runtime alias", () => {
+    const parsed = DbQueryInputSchema.parse({ query: "SELECT 2" });
+
+    expect(resolveDbQuerySql(parsed)).toBe("SELECT 2");
+  });
+
+  test("sql takes precedence when both sql and query are present", () => {
+    const parsed = DbQueryInputSchema.parse({ sql: "SELECT 3", query: "SELECT 4" });
+
+    expect(resolveDbQuerySql(parsed)).toBe("SELECT 3");
+  });
+
+  test("rejects input without sql or query", () => {
+    const parsed = DbQueryInputSchema.safeParse({});
+
+    expect(parsed.success).toBe(false);
+  });
+});

package/src/tests/error-tracker.test.ts

@@ -1,8 +1,14 @@
 import { describe, expect, test } from "bun:test";
 import {
+  CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS,
+  isCodexCreditsExhaustedMessage,
+  isRateLimitMessage,
+  MAX_RATE_LIMIT_RESET_MS,
+  MIN_CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS,
   parseCodexRateLimitResetTime,
   parseRateLimitResetTime,
   parseStderrForErrors,
+  resolveCodexCreditsExhaustedCooldownMs,
   SessionErrorTracker,
   trackErrorFromJson,
 } from "../utils/error-tracker";
@@ -567,6 +573,121 @@ describe("parseRateLimitResetTime", () => {
   });
 });
 
+describe("isCodexCreditsExhaustedMessage", () => {
+  const CANONICAL =
+    "Your workspace is out of credits. Ask your workspace owner to refill in order to continue.";
+
+  test("returns true for the canonical credits-exhausted message", () => {
+    expect(isCodexCreditsExhaustedMessage(CANONICAL)).toBe(true);
+  });
+
+  test("matches 'out of credits' fragment", () => {
+    expect(isCodexCreditsExhaustedMessage("Your workspace is out of credits.")).toBe(true);
+  });
+
+  test("matches 'refill in order to continue' fragment", () => {
+    expect(isCodexCreditsExhaustedMessage("Please refill in order to continue.")).toBe(true);
+  });
+
+  test("matches 'workspace owner to refill' fragment", () => {
+    expect(isCodexCreditsExhaustedMessage("Ask your workspace owner to refill credits.")).toBe(
+      true,
+    );
+  });
+
+  test("is case-insensitive", () => {
+    expect(isCodexCreditsExhaustedMessage("OUT OF CREDITS")).toBe(true);
+  });
+
+  test("returns false for unrelated errors", () => {
+    expect(isCodexCreditsExhaustedMessage("No conversation found with session ID abc123")).toBe(
+      false,
+    );
+    expect(isCodexCreditsExhaustedMessage("Authentication failed")).toBe(false);
+    expect(isCodexCreditsExhaustedMessage("Rate limit exceeded")).toBe(false);
+    expect(isCodexCreditsExhaustedMessage("Connection timeout")).toBe(false);
+  });
+
+  test("returns false for bare 'refill' without qualifying context", () => {
+    expect(isCodexCreditsExhaustedMessage("Please refill your coffee")).toBe(false);
+  });
+});
+
+describe("isRateLimitMessage — Codex credits-exhausted integration", () => {
+  const CANONICAL =
+    "Your workspace is out of credits. Ask your workspace owner to refill in order to continue.";
+
+  test("returns true for canonical Codex credits-exhausted message", () => {
+    expect(isRateLimitMessage(CANONICAL)).toBe(true);
+  });
+
+  test("still returns true for standard rate-limit messages", () => {
+    expect(isRateLimitMessage("Rate limit exceeded")).toBe(true);
+    expect(isRateLimitMessage("429 Too Many Requests")).toBe(true);
+    expect(isRateLimitMessage("You've hit your weekly limit")).toBe(true);
+  });
+
+  test("still returns false for unrelated errors", () => {
+    expect(isRateLimitMessage("No conversation found with session ID abc123")).toBe(false);
+    expect(isRateLimitMessage("Authentication failed")).toBe(false);
+    expect(isRateLimitMessage("Server error 500")).toBe(false);
+  });
+});
+
+describe("resolveCodexCreditsExhaustedCooldownMs", () => {
+  test("absent (undefined) → default constant", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs(undefined)).toBe(
+      CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS,
+    );
+  });
+
+  test("null → default constant", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs(null)).toBe(CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS);
+  });
+
+  test("empty string → default constant", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs("")).toBe(CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS);
+  });
+
+  test("non-numeric string → default constant", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs("abc")).toBe(CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS);
+  });
+
+  test("zero → default constant", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs("0")).toBe(CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS);
+  });
+
+  test("negative → default constant", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs("-5")).toBe(CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS);
+  });
+
+  test("valid in-range string (30m) → parsed value", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs("1800000")).toBe(1_800_000);
+  });
+
+  test("valid in-range number (30m) → parsed value", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs(1_800_000)).toBe(1_800_000);
+  });
+
+  test("below floor → clamped to MIN", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs("1000")).toBe(
+      MIN_CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS,
+    );
+  });
+
+  test("above ceiling (8d) → clamped to MAX", () => {
+    expect(resolveCodexCreditsExhaustedCooldownMs(String(8 * 24 * 60 * 60 * 1000))).toBe(
+      MAX_RATE_LIMIT_RESET_MS,
+    );
+  });
+
+  test("partial-numeric strings → default constant (not silently truncated)", () => {
+    for (const bad of ["60000ms", "1.5", "123abc", "1e5"]) {
+      expect(resolveCodexCreditsExhaustedCooldownMs(bad)).toBe(CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS);
+    }
+  });
+});
+
 describe("Codex/Claude coexistence — single tracker handles both providers", () => {
   test("processRateLimitEvent (Claude) and processCodexUsageLimitMessage (Codex) both stash into getRateLimitResetAt", () => {
     // Claude path: processRateLimitEvent

package/src/tests/harness-provider-resolution.test.ts

@@ -138,6 +138,39 @@ describe("validateConfigValue", () => {
     expect(validateConfigValue("HARNESS_PROVIDER", 42)).not.toBeNull();
     expect(validateConfigValue("HARNESS_PROVIDER", null)).not.toBeNull();
   });
+
+  test("accepts a valid CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS", () => {
+    expect(validateConfigValue("CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS", "7200000")).toBeNull();
+    expect(validateConfigValue("CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS", "1800000")).toBeNull();
+    // case-insensitive key lookup
+    expect(validateConfigValue("codex_credits_exhausted_cooldown_ms", "60000")).toBeNull();
+  });
+
+  test("rejects non-positive / non-numeric CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS", () => {
+    for (const bad of ["abc", "0", "-5", ""]) {
+      const err = validateConfigValue("CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS", bad);
+      expect(err).not.toBeNull();
+      expect(err).toMatch(/CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS/);
+    }
+  });
+
+  test("rejects partial-numeric CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS values", () => {
+    for (const bad of ["60000ms", "1.5", "123abc", "1e5", " 60000 ms"]) {
+      const err = validateConfigValue("CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS", bad);
+      expect(err).not.toBeNull();
+      expect(err).toMatch(/CODEX_CREDITS_EXHAUSTED_COOLDOWN_MS/);
+    }
+  });
+
+  test("accepts only boolean-like SWARM_USE_CLAUDE_BRIDGE values", () => {
+    for (const value of ["true", "false", "1", "0", " TRUE "]) {
+      expect(validateConfigValue("SWARM_USE_CLAUDE_BRIDGE", value)).toBeNull();
+    }
+    expect(validateConfigValue("SWARM_USE_CLAUDE_BRIDGE", "yes")).toMatch(
+      /SWARM_USE_CLAUDE_BRIDGE/,
+    );
+    expect(validateConfigValue("SWARM_USE_CLAUDE_BRIDGE", true)).toMatch(/SWARM_USE_CLAUDE_BRIDGE/);
+  });
 });
 
 // ─── getResolvedConfig — scope precedence for HARNESS_PROVIDER ───────────────

package/src/tests/heartbeat-checklist.test.ts

@@ -271,6 +271,26 @@ describe("Heartbeat Checklist", () => {
       expect(tasks[0]!.task).toContain("Review blocked tasks");
     });
 
+    test("created task enforces HEARTBEAT tracked-item cap and seeded audit call", async () => {
+      const lead = createAgent({ name: "lead", isLead: true, status: "idle" });
+      updateAgentProfile(lead.id, {
+        heartbeatMd: "- Watch PR #123 until 2026-06-07\n",
+      });
+
+      await checkHeartbeatChecklist();
+
+      const tasks = getDb()
+        .query("SELECT task FROM agent_tasks WHERE taskType = 'heartbeat-checklist'")
+        .all() as Array<{ task: string }>;
+      expect(tasks.length).toBe(1);
+      expect(tasks[0]!.task).toContain("Active Blockers + Watch Items + Open Discussion");
+      expect(tasks[0]!.task).toContain("≤10 items");
+      expect(tasks[0]!.task).toContain("20 is the absolute max");
+      expect(tasks[0]!.task).toContain("script-run");
+      expect(tasks[0]!.task).toContain("Heartbeat Audit");
+      expect(tasks[0]!.task).toContain("Rule #11");
+    });
+
     test("created task has correct tags", async () => {
       const lead = createAgent({ name: "lead", isLead: true, status: "idle" });
       updateAgentProfile(lead.id, {
@@ -369,6 +389,22 @@ describe("Heartbeat Checklist", () => {
       expect(tasks[0]!.task).toContain("Check Slack for unaddressed requests");
     });
 
+    test("boot-triage task enforces HEARTBEAT cap and seeded boot-triage call", async () => {
+      createAgent({ name: "lead", isLead: true, status: "idle" });
+
+      await createBootTriageTask();
+
+      const tasks = getDb()
+        .query("SELECT task FROM agent_tasks WHERE taskType = 'boot-triage'")
+        .all() as Array<{ task: string }>;
+      expect(tasks[0]!.task).toContain("Active Blockers + Watch Items + Open Discussion");
+      expect(tasks[0]!.task).toContain("≤10 items");
+      expect(tasks[0]!.task).toContain("20 is the absolute max");
+      expect(tasks[0]!.task).toContain("script-run");
+      expect(tasks[0]!.task).toContain("boot-triage");
+      expect(tasks[0]!.task).toContain("one read-only call");
+    });
+
     test("dedup: skips when active boot-triage task exists", async () => {
       const lead = createAgent({ name: "lead", isLead: true, status: "idle" });
       updateAgentProfile(lead.id, {

package/src/tests/mcp-tools.test.ts

@@ -55,6 +55,12 @@ describe("script MCP tools", () => {
         "Remove a swarm-shared script from the catalog. Versions table preserves history.",
       "script-query-types":
         "Fetch the signature + the auto-generated `swarm-sdk.d.ts` (derived from the live MCP tool registry) + the `stdlib.d.ts` blobs — for IDE-style introspection before authoring or running a script. The same types are used by `script-upsert`'s typecheck pass, so they are authoritative.",
+      "launch-script-run":
+        "Launch a durable one-off script workflow run. The run executes in the background and can be inspected with get-script-run for terminal status and journal entries.",
+      "get-script-run":
+        "Get a durable script workflow run by ID, including its journal entries for swarm-script, raw-llm, and agent-task steps.",
+      "list-script-runs":
+        "List durable script workflow runs, optionally filtered by status or agent ID.",
     };
 
     for (const [name, description] of Object.entries(expected)) {

package/src/tests/mcp-transport-gc.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from "bun:test";
+import type { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { closeIdleMcpTransports } from "../http/mcp";
+import { closeIdleMcpUserTransports } from "../http/mcp-user";
+
+function fakeTransport(onClose: () => void): StreamableHTTPServerTransport {
+  return {
+    close: onClose,
+  } as StreamableHTTPServerTransport;
+}
+
+describe("MCP transport idle GC", () => {
+  test("closes and deletes stale owner transports", () => {
+    const closed: string[] = [];
+    const transports: Record<string, StreamableHTTPServerTransport> = {
+      fresh: fakeTransport(() => closed.push("fresh")),
+      stale: fakeTransport(() => closed.push("stale")),
+      unknown: fakeTransport(() => closed.push("unknown")),
+    };
+    const activity = {
+      fresh: 9_500,
+      stale: 1_000,
+    };
+
+    const removed = closeIdleMcpTransports(transports, activity, {
+      now: 10_000,
+      idleTimeoutMs: 1_000,
+    });
+
+    expect(removed).toBe(1);
+    expect(closed).toEqual(["stale"]);
+    expect(transports.stale).toBeUndefined();
+    expect(activity.stale).toBeUndefined();
+    expect(transports.fresh).toBeDefined();
+    expect(transports.unknown).toBeDefined();
+    expect(activity.unknown).toBe(10_000);
+  });
+
+  test("deletes user ownership metadata for stale user transports", () => {
+    const closed: string[] = [];
+    const transports: Record<string, StreamableHTTPServerTransport> = {
+      stale: fakeTransport(() => closed.push("stale")),
+    };
+    const sessionUsers = { stale: "user_1" };
+    const activity = { stale: 1_000 };
+
+    const removed = closeIdleMcpUserTransports(transports, sessionUsers, activity, {
+      now: 10_000,
+      idleTimeoutMs: 1_000,
+    });
+
+    expect(removed).toBe(1);
+    expect(closed).toEqual(["stale"]);
+    expect(transports.stale).toBeUndefined();
+    expect(sessionUsers.stale).toBeUndefined();
+    expect(activity.stale).toBeUndefined();
+  });
+});

package/src/tests/memory-health-endpoint.test.ts

@@ -0,0 +1,78 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { closeDb, initDb } from "../be/db";
+import { EMBEDDING_DIMENSIONS } from "../be/memory/constants";
+import { handleMemory } from "../http/memory";
+import { getPathSegments } from "../http/utils";
+
+const TEST_DB_PATH = "./test-memory-health-endpoint.sqlite";
+
+function fakeReqRes(path: string) {
+  const req = {
+    method: "GET",
+    url: path,
+    headers: {},
+  } as unknown as IncomingMessage;
+
+  const captured = { status: 0, body: "" };
+  const res = {
+    writeHead(status: number) {
+      captured.status = status;
+      return this;
+    },
+    end(chunk?: string) {
+      if (chunk) captured.body = chunk;
+      return this;
+    },
+  } as unknown as ServerResponse;
+
+  return { req, res, captured };
+}
+
+describe("GET /api/memory/health", () => {
+  beforeAll(async () => {
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {}
+    }
+    initDb(TEST_DB_PATH);
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(TEST_DB_PATH + suffix);
+      } catch {}
+    }
+  });
+
+  test("returns vector index health JSON", async () => {
+    const { req, res, captured } = fakeReqRes("/api/memory/health");
+    const handled = await handleMemory(req, res, getPathSegments(req.url || ""), undefined);
+
+    expect(handled).toBe(true);
+    expect(captured.status).toBe(200);
+
+    const body = JSON.parse(captured.body);
+    expect(body).toMatchObject({
+      sqliteVec: {
+        extensionLoaded: expect.any(Boolean),
+        tableExists: expect.any(Boolean),
+        initialized: expect.any(Boolean),
+        vectorDimensions: EMBEDDING_DIMENSIONS,
+        distanceMetric: "cosine",
+      },
+      counts: {
+        total: expect.any(Number),
+        withEmbedding: expect.any(Number),
+        searchable: expect.any(Number),
+        memoryVec: expect.any(Number),
+      },
+      retrievalMode: expect.any(String),
+      reasons: expect.any(Array),
+    });
+  });
+});