@desplega.ai/agent-swarm 2.7.5 → 2.7.7

package/src/tests/claude-artifacts-read-script.test.ts

@@ -0,0 +1,209 @@
+/**
+ * examples/claude-artifacts-read/claude-artifacts-read.sh must never write
+ * outside <outdir> and never replace a file with content that failed its
+ * sha256 check. A mock `claude` (CLAUDE_BIN) replays canned stream-json, so
+ * no network or auth is involved.
+ */
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { createHash } from "node:crypto";
+import {
+  lstat,
+  mkdir,
+  mkdtemp,
+  readdir,
+  readFile,
+  readlink,
+  rm,
+  symlink,
+  writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { CHILD_PROCESS_TEST_BUDGET_MS, runChild } from "./test-proc";
+
+const SCRIPT = resolve(
+  import.meta.dir,
+  "../../examples/claude-artifacts-read/claude-artifacts-read.sh",
+);
+
+const MOCK_CLAUDE = `#!/usr/bin/env bash
+case "$2" in
+  *list_files*) cat "$MOCK_DIR/list.jsonl" ;;
+  *) cat "$MOCK_DIR/read.jsonl" ;;
+esac
+`;
+
+const sha256 = (s: string) => createHash("sha256").update(s).digest("hex");
+
+function toolResult(blocks: string[]): string {
+  return JSON.stringify({
+    type: "user",
+    message: {
+      content: [{ type: "tool_result", content: blocks.map((text) => ({ type: "text", text })) }],
+    },
+  });
+}
+
+let root: string;
+let out: string;
+let outside: string;
+let mockDir: string;
+
+/**
+ * Stage a listing whose sha256 for each path is `listed` and a read that
+ * returns `served`, then run the script into `out`.
+ */
+async function run(files: { path: string; listed: string; served: string }[]) {
+  const init = JSON.stringify({
+    type: "system",
+    subtype: "init",
+    claude_code_version: "2.1.314",
+    tools: ["mcp__claude-artifacts__list_files", "mcp__claude-artifacts__read_file"],
+  });
+  const manifest = {
+    slug: "art_mock",
+    files: files.map((f) => ({
+      path: f.path,
+      content_type: "text/html",
+      size: f.listed.length,
+      sha256: sha256(f.listed),
+    })),
+  };
+  await writeFile(
+    join(mockDir, "list.jsonl"),
+    `${init}\n${toolResult([JSON.stringify(manifest)])}\n`,
+  );
+  const reads = files.map((f) =>
+    toolResult([
+      JSON.stringify({ path: f.path }),
+      `<untrusted-document-abc123>${f.served}</untrusted-document-abc123>`,
+    ]),
+  );
+  await writeFile(join(mockDir, "read.jsonl"), `${init}\n${reads.join("\n")}\n`);
+  return runChild(["bash", SCRIPT, "https://claude.ai/artifact/mock", out], {
+    env: {
+      PATH: process.env.PATH,
+      HOME: root,
+      CLAUDE_BIN: join(mockDir, "claude"),
+      MOCK_DIR: mockDir,
+    },
+  });
+}
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), "claude-artifacts-read-"));
+  out = join(root, "out");
+  outside = join(root, "outside");
+  mockDir = join(root, "mock");
+  await mkdir(out);
+  await mkdir(outside);
+  await mkdir(mockDir);
+  await writeFile(join(mockDir, "claude"), MOCK_CLAUDE, { mode: 0o755 });
+});
+
+afterEach(async () => {
+  await rm(root, { recursive: true, force: true });
+});
+
+describe("claude-artifacts-read.sh", () => {
+  test(
+    "a sha256 mismatch leaves an existing file untouched",
+    async () => {
+      await mkdir(join(out, "project"));
+      await writeFile(join(out, "project/a.html"), "previous good copy");
+
+      const r = await run([
+        { path: "project/a.html", listed: "real content", served: "truncated" },
+      ]);
+
+      expect(r.exitCode).toBe(1);
+      expect(r.stderr).toContain("sha256 mismatch: project/a.html");
+      expect(await readFile(join(out, "project/a.html"), "utf8")).toBe("previous good copy");
+      expect(await readdir(join(out, "project"))).toEqual(["a.html"]);
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "a sha256 mismatch never writes through a destination symlink",
+    async () => {
+      await writeFile(join(outside, "target.txt"), "external");
+      await symlink(join(outside, "target.txt"), join(out, "a.html"));
+
+      const r = await run([{ path: "a.html", listed: "real content", served: "truncated" }]);
+
+      expect(r.exitCode).toBe(1);
+      expect(await readFile(join(outside, "target.txt"), "utf8")).toBe("external");
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "a verified file is not written through a destination symlink",
+    async () => {
+      await writeFile(join(outside, "target.txt"), "external");
+      await symlink(join(outside, "target.txt"), join(out, "a.html"));
+
+      const r = await run([{ path: "a.html", listed: "real content", served: "real content" }]);
+
+      expect(r.exitCode).toBe(1);
+      expect(r.stderr).toContain("refused");
+      expect(await readFile(join(outside, "target.txt"), "utf8")).toBe("external");
+      expect(await readlink(join(out, "a.html"))).toBe(join(outside, "target.txt"));
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "a verified file is not written through a parent directory symlink",
+    async () => {
+      await symlink(outside, join(out, "project"));
+
+      const r = await run([
+        { path: "project/a.html", listed: "real content", served: "real content" },
+      ]);
+
+      expect(r.exitCode).toBe(1);
+      expect(r.stderr).toContain("refused");
+      expect(await readdir(outside)).toEqual([]);
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "manifest.json is not written through a symlink",
+    async () => {
+      await writeFile(join(outside, "target.json"), "external");
+      await symlink(join(outside, "target.json"), join(out, "manifest.json"));
+
+      const r = await run([{ path: "a.html", listed: "real content", served: "real content" }]);
+
+      expect(r.exitCode).toBe(1);
+      expect(await readFile(join(outside, "target.json"), "utf8")).toBe("external");
+      // The run stops before any artifact file is written.
+      await expect(lstat(join(out, "a.html"))).rejects.toThrow();
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+
+  test(
+    "verified files and the manifest replace existing regular files",
+    async () => {
+      await mkdir(join(out, "project"));
+      await writeFile(join(out, "project/a.html"), "old");
+      await writeFile(join(out, "manifest.json"), "old");
+
+      const r = await run([
+        { path: "project/a.html", listed: "real content", served: "real content" },
+      ]);
+
+      expect(r.exitCode).toBe(0);
+      expect(r.stdout).toContain("ok: project/a.html");
+      expect(await readFile(join(out, "project/a.html"), "utf8")).toBe("real content");
+      expect(JSON.parse(await readFile(join(out, "manifest.json"), "utf8")).slug).toBe("art_mock");
+      expect(await readdir(join(out, "project"))).toEqual(["a.html"]);
+      expect((await lstat(join(out, "project/a.html"))).isFile()).toBe(true);
+    },
+    CHILD_PROCESS_TEST_BUDGET_MS,
+  );
+});

package/src/tests/codex-app-server.test.ts

@@ -1,4 +1,6 @@
 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 {
   CodexAppServer,
@@ -205,4 +207,61 @@ describe("CodexAppServer", () => {
     },
     CHILD_PROCESS_TEST_BUDGET_MS,
   );
+
+  for (const { name, launchOnGateway } of [
+    {
+      name: "pinned Codex rejects a gateway turn on an app-server launched without it",
+      launchOnGateway: false,
+    },
+    {
+      name: "pinned Codex accepts a gateway turn on an app-server launched on the gateway",
+      launchOnGateway: true,
+    },
+  ]) {
+    test(
+      name,
+      async () => {
+        const gateway = {
+          model_provider: "swarm-gateway",
+          model_providers: {
+            "swarm-gateway": {
+              name: "Swarm gateway",
+              base_url: "http://127.0.0.1:9/v1",
+              env_key: "CODEX_GATEWAY_API_KEY",
+              wire_api: "responses",
+              requires_openai_auth: false,
+            },
+          },
+        };
+        const home = await mkdtemp(join(tmpdir(), "codex-app-server-provider-"));
+        const server = new CodexAppServer({
+          codexPath: join(import.meta.dir, "..", "..", "node_modules", ".bin", "codex"),
+          env: fixtureEnv({ HOME: home, CODEX_HOME: home, CODEX_GATEWAY_API_KEY: "example" }),
+          ...(launchOnGateway ? { configOverrides: gateway } : {}),
+        });
+        try {
+          const started = await server.request<{ thread: { id: string } }>("thread/start", {
+            cwd: home,
+            approvalPolicy: "never",
+            sandbox: "danger-full-access",
+            config: gateway,
+            ephemeral: true,
+          });
+          const turn = server.request("turn/start", {
+            threadId: started.thread.id,
+            input: [{ type: "text", text: "hi" }],
+          });
+          if (launchOnGateway) await turn;
+          else
+            await expect(turn).rejects.toThrow(
+              "This chat uses swarm-gateway, but your current provider is openai",
+            );
+        } finally {
+          await server.close();
+          await rm(home, { recursive: true, force: true });
+        }
+      },
+      CHILD_PROCESS_TEST_BUDGET_MS,
+    );
+  }
 });

package/src/tests/codex-gateway-route.test.ts

@@ -4,7 +4,10 @@
  * selection in the adapter, the presence gate, and the live check.
  */
 
-import { afterEach, describe, expect, spyOn, test } from "bun:test";
+import { afterAll, afterEach, beforeAll, describe, expect, spyOn, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { validateProviderCredentials } from "../commands/provider-credentials";
 import { CodexAdapter, checkCodexCredentials } from "../providers/codex-adapter";
 import type { ProviderSessionConfig } from "../providers/types";
@@ -75,6 +78,22 @@ afterEach(() => {
   globalThis.fetch = realFetch;
 });
 
+// The adapter reads `process.env.HOME` live (see `codexUserHome`) to decide
+// whether `~/.codex/auth.json` exists. A developer's real codex login would
+// make OAuth win over OPENAI_API_KEY and fail the API-key assertions, so run
+// the file against an empty home. The real auth.json is never touched.
+const realHome = process.env.HOME;
+let isolatedHome: string | undefined;
+beforeAll(() => {
+  isolatedHome = mkdtempSync(join(tmpdir(), "codex-gateway-route-home-"));
+  process.env.HOME = isolatedHome;
+});
+afterAll(() => {
+  if (realHome === undefined) delete process.env.HOME;
+  else process.env.HOME = realHome;
+  if (isolatedHome) rmSync(isolatedHome, { recursive: true, force: true });
+});
+
 describe("codex gateway route: adapter", () => {
   test("adds a Responses provider block and keeps OAuth and OPENAI_API_KEY out of the CLI env", async () => {
     const log = spyOn(console, "log");
@@ -103,6 +122,36 @@ describe("codex gateway route: adapter", () => {
     expect(logged.some((line) => line.endsWith("Using credential: gateway"))).toBe(true);
   });
 
+  test("launches the app-server on the gateway provider, and on the default without a gateway", async () => {
+    const launched = async (env: Record<string, string>) => {
+      let overrides: unknown = "not launched";
+      const adapter = new CodexAdapter({
+        bypassSubprocess: true,
+        appServerFactory: ({ configOverrides }) => {
+          overrides = configOverrides;
+          throw new Error("test stops before app-server spawn");
+        },
+      });
+      await expect(adapter.createSession(testConfig({ env }))).rejects.toThrow(
+        "test stops before app-server spawn",
+      );
+      return overrides;
+    };
+    expect(await launched({ ...GATEWAY_ENV, OPENAI_API_KEY: "sk-openai" })).toEqual({
+      model_provider: "swarm-gateway",
+      model_providers: {
+        "swarm-gateway": {
+          name: "Swarm gateway",
+          base_url: "https://sub2api.example.com/v1",
+          env_key: "CODEX_GATEWAY_API_KEY",
+          wire_api: "responses",
+          requires_openai_auth: false,
+        },
+      },
+    });
+    expect(await launched({ OPENAI_API_KEY: "sk-openai" })).toBeUndefined();
+  });
+
   test("a gateway URL on api.openai.com is not a gateway: no provider block", async () => {
     const { codexConfig, env } = await captureSpawn({
       CODEX_GATEWAY_BASE_URL: "https://api.openai.com/v1",