@desplega.ai/agent-swarm 2.3.0 → 2.4.1

package/src/tests/pi-mono-adapter.test.ts

@@ -17,6 +17,7 @@ import {
   checkPiMonoCredentials,
   createPiRuntimeAuth,
   extractPiAssistantText,
+  listPiOpencodeGoModelIds,
   PiMonoAdapter,
   resolveModel,
   type SessionModelsJson,
@@ -457,6 +458,18 @@ describe("Model name mapping", () => {
   });
 });
 
+describe("listPiOpencodeGoModelIds", () => {
+  test("every reported opencode-go id resolves, so a picked id never falls back", () => {
+    const ids = listPiOpencodeGoModelIds();
+    expect(ids).toContain("deepseek-v4.1-flash");
+    for (const id of ids) {
+      expect(resolveModel(`opencode-go/${id}`, {})?.id).toBe(id);
+    }
+    expect(ids).not.toContain("deepseek-v4-flash");
+    expect(resolveModel("opencode-go/deepseek-v4-flash", {})).toBeUndefined();
+  });
+});
+
 describe("resolveModel — OpenRouter reroute for anthropic shortnames", () => {
   // Regression coverage for task 37a4a87a: workers spawned with
   // `provider: pi` + `OPENROUTER_API_KEY` (no ANTHROPIC_API_KEY) and a task
@@ -546,6 +559,16 @@ describe("createPiRuntimeAuth", () => {
     });
   });
 
+  test("passes OPENCODE_API_KEY to pi opencode-go runtime auth", async () => {
+    const modelRuntime = await createPiRuntimeAuth({
+      OPENCODE_API_KEY: "example-opencode-runtime",
+    });
+
+    await expect(modelRuntime.getAuth("opencode-go")).resolves.toMatchObject({
+      auth: { apiKey: "example-opencode-runtime" },
+    });
+  });
+
   test("passes GEMINI_API_KEY to pi google runtime auth", async () => {
     const modelRuntime = await createPiRuntimeAuth({
       GEMINI_API_KEY: "example-gemini-runtime",

package/src/tests/pr-body-leaks.test.ts

@@ -339,14 +339,18 @@ describe("parseGhPrCommands", () => {
     );
     expect(calls).toEqual([
       {
+        action: "create",
         cwd: "/tmp/wt",
         repos: ["o/r"],
+        resolvedRepos: ["o/r"],
         alsoCheckout: false,
         unknownTarget: false,
         texts: ["t"],
+        bodyTexts: [],
         bodyFiles: ["body.md"],
         unresolvedBodyFiles: [],
         opaqueBody: false,
+        externalBody: false,
       },
     ]);
   });

package/src/tests/pr-room-guard.test.ts

@@ -0,0 +1,242 @@
+import { describe, expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { codexPreToolUseBlock } from "../hooks/codex-hook";
+import { gitRemoteOrigin, guardGhPrRoom, type PrRoomGuardDeps } from "../hooks/pr-room-guard";
+import { expectChildOk, runChild } from "./test-proc";
+
+const ROOM_LINE = "PR room: prr-abcde23457";
+const BLOCK_REASON =
+  'This repo uses PR rooms. Create the room first with the pr-room skill (app action createRoom). Then pass the returned prBody with --body-file. The body must contain the line "PR room: prr-...".';
+
+function fakeDeps(overrides: Partial<PrRoomGuardDeps> = {}): PrRoomGuardDeps {
+  return {
+    env: { PR_ROOM_REPOS: "owner/repo" },
+    readFile: async () => "No room marker",
+    remoteOrigin: async () => "https://github.com/owner/repo.git",
+    ...overrides,
+  };
+}
+
+const check = (command: string, deps = fakeDeps()) => guardGhPrRoom({ command }, "/w", deps);
+
+describe("guardGhPrRoom", () => {
+  test.each([undefined, "", " ,  , "])("allows disabled configuration %p", async (value) => {
+    expect(
+      await check(
+        "gh pr create -R owner/repo -b plain",
+        fakeDeps({ env: { PR_ROOM_REPOS: value } }),
+      ),
+    ).toBeNull();
+  });
+
+  test("blocks a configured repo without a room marker", async () => {
+    expect(await check("gh pr create --repo owner/repo --body plain")).toBe(BLOCK_REASON);
+    expect(await check("gh pr create -Rowner/repo")).toBe(BLOCK_REASON);
+  });
+
+  test("allows a marker in the inline body", async () => {
+    expect(await check(`gh pr create -R owner/repo --body 'Summary\n${ROOM_LINE}'`)).toBeNull();
+  });
+
+  test("resolves body files relative to cd", async () => {
+    const paths: string[] = [];
+    const deps = fakeDeps({
+      readFile: async (path) => {
+        paths.push(path);
+        return ROOM_LINE;
+      },
+    });
+    expect(
+      await check("cd /checkout && gh pr create -R owner/repo --body-file body.md", deps),
+    ).toBeNull();
+    expect(paths).toEqual(["/checkout/body.md"]);
+  });
+
+  test("allows a heredoc body with a marker", async () => {
+    expect(
+      await check(`gh pr create -R owner/repo --body-file - <<'EOF'\n${ROOM_LINE}\nEOF`),
+    ).toBeNull();
+  });
+
+  test("blocks resolved files and heredocs without a marker", async () => {
+    expect(await check("gh pr create -R owner/repo -F body.md")).toBe(BLOCK_REASON);
+    expect(await check("gh pr create -R owner/repo -F - <<'EOF'\nplain\nEOF")).toBe(BLOCK_REASON);
+  });
+
+  test("allows another repo without reading its body", async () => {
+    expect(await check("gh pr create -R other/repo -b plain")).toBeNull();
+  });
+
+  test.each([
+    "GH_REPO=owner/repo gh pr create -b plain",
+    "export GH_REPO=owner/repo && gh pr create -b plain",
+  ])("checks command targeting: %s", async (command) => {
+    expect(await check(command)).toBe(BLOCK_REASON);
+  });
+
+  test("allows an ambiguous target unless every candidate is configured", async () => {
+    const otherCheckout = fakeDeps({ remoteOrigin: async () => "https://github.com/other/repo" });
+    expect(await check("GH_REPO=owner/repo && gh pr create -b plain", otherCheckout)).toBeNull();
+    expect(await check("GH_REPO=owner/repo && gh pr create -b plain")).toBe(BLOCK_REASON);
+    expect(await check("gh pr create -R owner/repo -R other/repo -b plain")).toBeNull();
+  });
+
+  test("checks inherited GH_REPO and honors an explicit override", async () => {
+    const deps = fakeDeps({ env: { PR_ROOM_REPOS: "owner/repo", GH_REPO: "owner/repo" } });
+    expect(await check("gh pr create -b plain", deps)).toBe(BLOCK_REASON);
+    expect(await check("gh pr create -R other/repo -b plain", deps)).toBeNull();
+  });
+
+  test("trims configured repos and matches case insensitively", async () => {
+    const deps = fakeDeps({ env: { PR_ROOM_REPOS: " other/repo, OWNER/REPO , " } });
+    expect(await check("gh -R Owner/Repo pr create -b plain", deps)).toBe(BLOCK_REASON);
+  });
+
+  test("allows edits and unrelated commands", async () => {
+    expect(await check("gh pr edit 123 -R owner/repo -b plain")).toBeNull();
+    expect(await check("gh pr view 123 -R owner/repo")).toBeNull();
+    expect(await guardGhPrRoom(undefined, "/w", fakeDeps())).toBeNull();
+  });
+
+  test.each([
+    "https://github.com/Owner/Repo.git",
+    "https://github.com/Owner/Repo",
+    "git@github.com:Owner/Repo.git",
+    "ssh://git@github.com/Owner/Repo.git",
+  ])("resolves checkout remote %s", async (remote) => {
+    const lookups: string[] = [];
+    const deps = fakeDeps({
+      remoteOrigin: async (cwd) => {
+        lookups.push(cwd);
+        return remote;
+      },
+    });
+    expect(await check("cd /checkout && gh pr create -b plain", deps)).toBe(BLOCK_REASON);
+    expect(lookups).toEqual(["/checkout"]);
+  });
+
+  test("allows failed remote lookup and unsupported remote forms", async () => {
+    expect(
+      await check("gh pr create -b plain", fakeDeps({ remoteOrigin: async () => "local/path" })),
+    ).toBeNull();
+    expect(
+      await check(
+        "gh pr create -b plain",
+        fakeDeps({
+          remoteOrigin: async () => {
+            throw new Error("no checkout");
+          },
+        }),
+      ),
+    ).toBeNull();
+  });
+
+  // git exports GIT_DIR to a pre-push hook in a linked worktree. The lookup then reads that repo.
+  test.skipIf(process.env.GIT_DIR !== undefined)(
+    "allows a checkout remote lookup that does not finish",
+    async () => {
+      const dir = await mkdtemp(join(tmpdir(), "pr-room-fifo-"));
+      try {
+        expectChildOk(await runChild(["git", "init", "-q", dir]), "git init");
+        await rm(join(dir, ".git", "config"));
+        expectChildOk(await runChild(["mkfifo", join(dir, ".git", "config")]), "mkfifo");
+        await expect(gitRemoteOrigin(dir, 200)).rejects.toThrow();
+        const deps = fakeDeps({ remoteOrigin: (cwd) => gitRemoteOrigin(cwd, 200) });
+        expect(await guardGhPrRoom({ command: "gh pr create -b plain" }, dir, deps)).toBeNull();
+      } finally {
+        await rm(dir, { recursive: true, force: true });
+      }
+    },
+  );
+
+  test.each([
+    'gh pr create -R "$UNKNOWN" -b plain',
+    'gh pr create -R owner/repo -b "$UNKNOWN"',
+    'gh pr create -R owner/repo -F "$UNKNOWN"',
+    "cd - && gh pr create -R owner/repo -b plain",
+    'cd "$UNKNOWN" && gh pr create -b plain',
+    "read GH_REPO && gh pr create -b plain",
+  ])("allows unresolved inputs: %s", async (command) => {
+    expect(await check(command)).toBeNull();
+  });
+
+  test("allows unreadable body files", async () => {
+    const deps = fakeDeps({
+      readFile: async () => {
+        throw new Error("unreadable");
+      },
+    });
+    expect(await check("gh pr create -R owner/repo -F missing.md", deps)).toBeNull();
+  });
+
+  test("resolves known variables without changing leak guard texts", async () => {
+    expect(await check('REPO=owner/repo && gh pr create -R "$REPO" -b plain')).toBe(BLOCK_REASON);
+    expect(await check(`BODY='${ROOM_LINE}' && gh pr create -R owner/repo -b "$BODY"`)).toBeNull();
+  });
+
+  test.each([
+    "cat room.md | gh pr create -R owner/repo -F -",
+    "printf plain | gh pr create -R owner/repo -F -",
+    "gh pr create -R owner/repo -b $(cat room.md)",
+    "gh pr create -R owner/repo --fill",
+    "gh pr create -R owner/repo -f",
+    "gh pr create -R owner/repo --fill-first",
+    "gh pr create -R owner/repo --fill-verbose",
+    "gh pr create -R owner/repo -T template.md -b plain",
+    "gh pr create -R owner/repo --template=template.md",
+    "gh pr create -R owner/repo -dw -b plain",
+    "gh pr create -R owner/repo --web",
+    "gh pr create -R owner/repo -e",
+    "gh pr create -R owner/repo --editor",
+    "gh pr create -R owner/repo --recover input.json",
+  ])("allows a body the guard cannot read: %s", async (command) => {
+    expect(await check(command)).toBeNull();
+  });
+
+  test.each([
+    "PR room: prr-abcde2345",
+    "PR room: prr-abcde234578",
+    "PR room: prr-ABCDE23457",
+    "prefix PR room: prr-abcde23457",
+  ])("rejects an invalid marker: %s", async (line) => {
+    expect(await check(`gh pr create -R owner/repo -b '${line}'`)).toBe(BLOCK_REASON);
+  });
+
+  test("does not accept a marker only in the title", async () => {
+    expect(await check(`gh pr create -R owner/repo -t '${ROOM_LINE}' -b plain`)).toBe(BLOCK_REASON);
+  });
+
+  test("checks every create invocation", async () => {
+    expect(await check(`gh pr edit 1 -b plain && gh pr create -R owner/repo -b plain`)).toBe(
+      BLOCK_REASON,
+    );
+  });
+
+  test("Codex runs the room guard after the leak guard, including app-server sessions", async () => {
+    const roomDeps = fakeDeps();
+    const leakDeps = {
+      env: { SWARM_CODEX_APP_SERVER: "1" },
+      readFile: roomDeps.readFile,
+      repoVisibility: async () => "PUBLIC",
+    };
+    const msg = {
+      hook_event_name: "PreToolUse",
+      cwd: "/w",
+      tool_input: { command: "gh pr create -R owner/repo -b plain" },
+    };
+    expect(await codexPreToolUseBlock(msg, leakDeps, roomDeps)).toBe(BLOCK_REASON);
+    const leaky = {
+      ...msg,
+      tool_input: {
+        command:
+          "gh pr create -R owner/repo -b 'https://acme.slack.com/archives/C01234567/p1700000000000000'",
+      },
+    };
+    expect(await codexPreToolUseBlock(leaky, leakDeps, roomDeps)).toContain("PR body leak check:");
+    expect(
+      await codexPreToolUseBlock({ ...msg, hook_event_name: "PostToolUse" }, leakDeps, roomDeps),
+    ).toBeNull();
+  });
+});

package/src/tests/ranking-listing.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, test } from "bun:test";
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { isInternalConfigKey, validateConfigValue } from "../be/swarm-config-guard";
+import { buildListing, parseTelemetryRanking } from "../ranking/telemetry-ranking";
+import { RANKING_TAXONOMY } from "../telemetry-contract/ranking-taxonomy.gen";
+import { orgIdentityStatus } from "../utils/org-identity";
+
+const FIXTURES = join(import.meta.dir, "..", "telemetry-contract", "ranking", "fixtures");
+const read = (kind: string, file: string) => readFileSync(join(FIXTURES, kind, file), "utf8");
+
+describe("telemetry_ranking contract fixtures", () => {
+  const expected = JSON.parse(readFileSync(join(FIXTURES, "expected.json"), "utf8")) as {
+    invalid: Record<string, string>;
+  };
+
+  test("the fixture set is complete", () => {
+    expect(readdirSync(join(FIXTURES, "valid")).length).toBeGreaterThan(0);
+    expect(readdirSync(join(FIXTURES, "invalid")).sort()).toEqual(
+      Object.keys(expected.invalid).sort(),
+    );
+  });
+
+  for (const file of readdirSync(join(FIXTURES, "valid"))) {
+    test(`valid/${file} parses`, () => {
+      expect(() => parseTelemetryRanking(read("valid", file))).not.toThrow();
+    });
+  }
+
+  for (const file of readdirSync(join(FIXTURES, "invalid"))) {
+    test(`invalid/${file} is rejected (${expected.invalid[file]})`, () => {
+      expect(() => parseTelemetryRanking(read("invalid", file))).toThrow();
+    });
+  }
+});
+
+describe("buildListing", () => {
+  const identity = orgIdentityStatus({ SWARM_ORG_NAME: "Acme", SWARM_ORG_WEBSITE: "acme.dev" });
+
+  test("copies the name and domain from the org identity and blanks to null", () => {
+    const listing = buildListing(
+      identity,
+      {
+        category: "engineering",
+        subcategory: "qa-testing",
+        description: "  ",
+        sourceCodeUrl: null,
+      },
+      new Date("2026-10-18T10:00:00Z"),
+    );
+    expect(listing).toEqual({
+      v: 1,
+      name: "Acme",
+      domain: "acme.dev",
+      category: "engineering",
+      subcategory: "qa-testing",
+      description: null,
+      sourceCodeUrl: null,
+      updatedAt: "2026-10-18T10:00:00.000Z",
+    });
+  });
+
+  test("refuses a missing identity and an http source URL", () => {
+    expect(() =>
+      buildListing(orgIdentityStatus({ SWARM_ORG_NAME: "Swarm", SWARM_ORG_WEBSITE: "acme.dev" }), {
+        category: "other",
+      }),
+    ).toThrow("SWARM_ORG_NAME");
+    expect(() =>
+      buildListing(identity, { category: "other", sourceCodeUrl: "http://github.com/acme" }),
+    ).toThrow();
+  });
+
+  test("a v2.4.0 listing with a claim still parses", () => {
+    const legacy = { ...JSON.parse(read("valid", "full.json")), claim: `rk_${"0".repeat(32)}` };
+    expect(parseTelemetryRanking(JSON.stringify(legacy)).claim).toBe(legacy.claim);
+  });
+
+  test("the taxonomy comes from the vendored contract", () => {
+    expect(RANKING_TAXONOMY).toEqual(
+      JSON.parse(readFileSync(join(FIXTURES, "..", "taxonomy.json"), "utf8")),
+    );
+  });
+});
+
+describe("config guard", () => {
+  test("telemetry_ranking is internal and validated", () => {
+    expect(isInternalConfigKey("telemetry_ranking")).toBe(true);
+    expect(validateConfigValue("telemetry_ranking", "{}")).toContain("telemetry_ranking");
+    expect(validateConfigValue("telemetry_ranking", read("valid", "full.json"))).toBeNull();
+  });
+
+  test("PUBLIC_RANKING_ENABLED is a boolean", () => {
+    expect(validateConfigValue("PUBLIC_RANKING_ENABLED", "true")).toBeNull();
+    expect(validateConfigValue("PUBLIC_RANKING_ENABLED", "yes please")).not.toBeNull();
+  });
+});