@desplega.ai/agent-swarm 2.5.4 → 2.7.0

package/src/tests/codex-credential-pools.test.ts

@@ -0,0 +1,120 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { CodexAdapter } from "../providers/codex-adapter";
+import type { ProviderSessionConfig } from "../providers/types";
+
+const keyVars = ["OPENAI_API_KEY", "OPENROUTER_API_KEY", "ANTHROPIC_API_KEY"];
+let savedEnv: Record<string, string | undefined>;
+let home: string;
+
+beforeEach(async () => {
+  savedEnv = Object.fromEntries(["HOME", ...keyVars].map((key) => [key, process.env[key]]));
+  home = await mkdtemp(join(tmpdir(), "credential-validation-codex-"));
+  process.env.HOME = home;
+  for (const key of keyVars) process.env[key] = "example-first, example-second";
+});
+
+afterEach(async () => {
+  for (const [key, value] of Object.entries(savedEnv)) {
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+  await rm(home, { recursive: true, force: true });
+});
+
+function config(env?: Record<string, string>): ProviderSessionConfig {
+  return {
+    agentId: crypto.randomUUID(),
+    prompt: "test",
+    systemPrompt: "",
+    cwd: home,
+    logFile: "/dev/null",
+    env,
+  };
+}
+
+describe("Codex credential pools", () => {
+  for (const source of ["container", "task", "task-pool"] as const) {
+    test(`app-server uses one OpenAI key from ${source}`, async () => {
+      let capturedEnv: Record<string, string> | undefined;
+      const adapter = new CodexAdapter({
+        bypassSubprocess: true,
+        appServerFactory: ({ env }) => {
+          capturedEnv = env;
+          throw new Error("test stops before app-server spawn");
+        },
+      });
+      const env =
+        source === "container"
+          ? {}
+          : {
+              OPENAI_API_KEY:
+                source === "task" ? "example-task" : "example-task-first, example-task-second",
+            };
+      await expect(adapter.createSession(config(env))).rejects.toThrow(
+        "test stops before app-server spawn",
+      );
+      expect(
+        source === "container"
+          ? ["example-first", "example-second"]
+          : source === "task"
+            ? ["example-task"]
+            : ["example-task-first", "example-task-second"],
+      ).toContain(capturedEnv?.OPENAI_API_KEY);
+    });
+
+    test(`subprocess forwards one key per provider from ${source}`, async () => {
+      let capturedEnv: Record<string, string | undefined> | undefined;
+      const spawn = spyOn(Bun, "spawn").mockImplementation(((
+        ...args: Parameters<typeof Bun.spawn>
+      ) => {
+        capturedEnv = args[1]?.env;
+        throw new Error("test stops before subprocess spawn");
+      }) as typeof Bun.spawn);
+      try {
+        const env =
+          source === "container"
+            ? {}
+            : Object.fromEntries(
+                keyVars.map((key) => [
+                  key,
+                  source === "task" ? "example-task" : "example-task-first, example-task-second",
+                ]),
+              );
+        await expect(new CodexAdapter().createSession(config(env))).rejects.toThrow(
+          "test stops before subprocess spawn",
+        );
+        for (const key of keyVars) {
+          expect(
+            source === "container"
+              ? ["example-first", "example-second"]
+              : source === "task"
+                ? ["example-task"]
+                : ["example-task-first", "example-task-second"],
+          ).toContain(capturedEnv?.[key]);
+        }
+      } finally {
+        spawn.mockRestore();
+      }
+    });
+  }
+
+  test("chatgpt mode still removes the OpenAI API key", async () => {
+    await Bun.write(join(home, ".codex", "auth.json"), JSON.stringify({ auth_mode: "chatgpt" }));
+    let capturedEnv: Record<string, string> | undefined;
+    const adapter = new CodexAdapter({
+      bypassSubprocess: true,
+      appServerFactory: ({ env }) => {
+        capturedEnv = env;
+        throw new Error("test stops before app-server spawn");
+      },
+    });
+    await expect(adapter.createSession(config({ OPENAI_API_KEY: "example-task" }))).rejects.toThrow(
+      "test stops before app-server spawn",
+    );
+    expect(capturedEnv).toBeDefined();
+    expect(capturedEnv?.OPENAI_API_KEY).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,165 @@
+/**
+ * Codex gateway route: `CODEX_GATEWAY_BASE_URL` + `CODEX_GATEWAY_API_KEY`
+ * send Codex through an OpenAI Responses-compatible gateway. Covers route
+ * selection in the adapter, the presence gate, and the live check.
+ */
+
+import { afterEach, describe, expect, spyOn, test } from "bun:test";
+import { validateProviderCredentials } from "../commands/provider-credentials";
+import { CodexAdapter, checkCodexCredentials } from "../providers/codex-adapter";
+import type { ProviderSessionConfig } from "../providers/types";
+
+const GATEWAY_ENV = {
+  CODEX_GATEWAY_BASE_URL: "https://sub2api.example.com/v1",
+  CODEX_GATEWAY_API_KEY: "sk-gateway",
+};
+const OAUTH_BLOB = JSON.stringify({
+  access: "oauth-access",
+  refresh: "r",
+  expires: 1,
+  accountId: "a",
+});
+
+function makeFakeThread() {
+  return {
+    id: null as string | null,
+    async runStreamed() {
+      async function* generate() {
+        yield { type: "turn.completed" as const };
+      }
+      return { events: generate() };
+    },
+    async steer() {},
+    async interrupt() {},
+    async close() {},
+  };
+}
+
+function testConfig(overrides: Partial<ProviderSessionConfig> = {}): ProviderSessionConfig {
+  return {
+    prompt: "hello",
+    systemPrompt: "",
+    model: "gpt-5.4",
+    role: "worker",
+    agentId: "11111111-1111-4111-8111-111111111111",
+    apiUrl: "http://127.0.0.1:9",
+    apiKey: "test",
+    cwd: "/tmp",
+    logFile: `/tmp/codex-gateway-route-test-${Date.now()}-${Math.random().toString(36).slice(2)}.log`,
+    ...overrides,
+  };
+}
+
+async function captureSpawn(
+  env: Record<string, string>,
+  extra: Partial<ProviderSessionConfig> = {},
+) {
+  let captured: { env: Record<string, string>; codexConfig: Record<string, unknown> } | undefined;
+  const config = testConfig({ env, ...extra });
+  const adapter = new CodexAdapter({
+    bypassSubprocess: true,
+    threadFactory: ({ env: spawnEnv, codexConfig }) => {
+      captured = { env: spawnEnv, codexConfig };
+      return makeFakeThread();
+    },
+  });
+  const session = await adapter.createSession(config);
+  await session.waitForCompletion();
+  await Bun.file(config.logFile).delete();
+  if (!captured) throw new Error("thread factory not called");
+  return captured;
+}
+
+const realFetch = globalThis.fetch;
+afterEach(() => {
+  globalThis.fetch = realFetch;
+});
+
+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");
+    // codexSlot set: without the gateway route this would revalidate the pool
+    // slot against the (unreachable) API and throw.
+    const { env, codexConfig } = await captureSpawn(
+      { ...GATEWAY_ENV, CODEX_OAUTH: OAUTH_BLOB, OPENAI_API_KEY: "sk-openai" },
+      { codexSlot: 0 },
+    );
+    const logged = log.mock.calls.map((c) => String(c[0]));
+    log.mockRestore();
+
+    expect(codexConfig.model_provider).toBe("swarm-gateway");
+    expect(codexConfig.model_providers).toEqual({
+      "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(env.CODEX_GATEWAY_API_KEY).toBe("sk-gateway");
+    expect(env.CODEX_OAUTH).toBeUndefined();
+    expect(env.OPENAI_API_KEY).toBeUndefined();
+    expect(logged.some((line) => line.endsWith("Using credential: gateway"))).toBe(true);
+  });
+
+  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",
+      CODEX_GATEWAY_API_KEY: "k",
+      OPENAI_API_KEY: "sk-openai",
+    });
+    expect(codexConfig.model_provider).toBeUndefined();
+    expect(codexConfig.model_providers).toBeUndefined();
+    expect(env.OPENAI_API_KEY).toBe("sk-openai");
+  });
+});
+
+describe("codex gateway route: credential gate", () => {
+  const noAuthJson = { homeDir: "/nonexistent", fs: { existsSync: () => false } };
+  const withAuthJson = { homeDir: "/home/worker", fs: { existsSync: () => true } };
+
+  test("the gateway URL + key alone is ready", () => {
+    expect(checkCodexCredentials(GATEWAY_ENV, noAuthJson)).toMatchObject({
+      ready: true,
+      satisfiedBy: "env",
+    });
+  });
+
+  test("a gateway URL without its key is not ready, even with auth.json or OAuth", () => {
+    const env = {
+      CODEX_GATEWAY_BASE_URL: GATEWAY_ENV.CODEX_GATEWAY_BASE_URL,
+      CODEX_OAUTH: OAUTH_BLOB,
+    };
+    expect(checkCodexCredentials(env, withAuthJson)).toMatchObject({
+      ready: false,
+      missing: ["CODEX_GATEWAY_API_KEY"],
+    });
+  });
+
+  test("live check calls the gateway's /v1/models with the gateway key, never api.openai.com", async () => {
+    const calls: Array<{ url: string; auth: string | undefined }> = [];
+    globalThis.fetch = (async (url: string | URL | Request, init?: RequestInit) => {
+      const headers = init?.headers as Record<string, string> | undefined;
+      calls.push({ url: String(url), auth: headers?.Authorization });
+      return new Response(JSON.stringify({ data: [{ id: "gpt-5.5" }] }), { status: 200 });
+    }) as typeof fetch;
+
+    const result = await validateProviderCredentials("codex", {
+      ...GATEWAY_ENV,
+      OPENAI_API_KEY: "sk-openai",
+      CODEX_OAUTH: OAUTH_BLOB,
+    });
+    expect(result.ok).toBe(true);
+    expect(result.skipped).toBeUndefined();
+    expect(calls).toEqual([
+      { url: "https://sub2api.example.com/v1/models", auth: "Bearer sk-gateway" },
+    ]);
+  });
+
+  test("live check reports the gateway's 401", async () => {
+    globalThis.fetch = (async () => new Response("bad key", { status: 401 })) as typeof fetch;
+    const result = await validateProviderCredentials("codex", GATEWAY_ENV);
+    expect(result).toMatchObject({ ok: false, httpStatus: 401 });
+  });
+});

package/src/tests/codex-oauth-accounts.test.ts

@@ -0,0 +1,357 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { Readable } from "node:stream";
+import {
+  closeDb,
+  createAgent,
+  createUser,
+  getAvailableKeyIndices,
+  getDbClient,
+  getSwarmConfigs,
+  initDb,
+  markKeyRateLimited,
+  recordKeyAuthFailure,
+  recordKeyUsage,
+  upsertKv,
+  upsertSwarmConfig,
+} from "../be/db";
+import { mintAgentToken, mintToken } from "../be/users";
+import { type CodexAccountsResponse, handleCodexOAuthAccounts } from "../http/codex-oauth-accounts";
+import { _autoReloadStatsForTests, _resetAutoReloadForTests, handleCore } from "../http/core";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+
+const API_KEY = "example-codex-accounts-operator";
+let workerToken: string;
+let leadToken: string;
+let workerId: string;
+let leadId: string;
+
+function credentials(userId: string, profile?: Record<string, unknown>) {
+  const payload = {
+    "https://api.openai.com/auth": {
+      chatgpt_user_id: userId,
+      chatgpt_account_id: "example-shared-workspace",
+      chatgpt_plan_type: "team",
+    },
+    ...(profile ? { "https://api.openai.com/profile": profile } : {}),
+  };
+  return {
+    access: `eyJhbGciOiJub25lIn0.${Buffer.from(JSON.stringify(payload)).toString("base64url")}.signature`,
+    refresh: `example-refresh-${userId}`,
+    accountId: "example-shared-workspace",
+    expires: Date.now() + 3_600_000,
+  };
+}
+
+async function store(key: string, value: unknown = credentials(`user-${key}`)) {
+  return await upsertSwarmConfig({
+    scope: "global",
+    key,
+    value: typeof value === "string" ? value : JSON.stringify(value),
+    isSecret: true,
+  });
+}
+
+async function request(path = "", method = "GET", bearer = API_KEY, agentId?: string) {
+  const url = `/api/codex-oauth/accounts${path}`;
+  const req = Object.assign(Readable.from([]), {
+    method,
+    url,
+    headers: {
+      authorization: `Bearer ${bearer}`,
+      ...(agentId ? { "x-agent-id": agentId } : {}),
+    },
+  }) as IncomingMessage;
+  let status = 200;
+  let body = "";
+  const res = {
+    setHeader: () => {},
+    writeHead: (code: number) => {
+      status = code;
+    },
+    end: (chunk?: string) => {
+      body += chunk ?? "";
+    },
+  } as unknown as ServerResponse;
+  if (!(await handleCore(req, res, agentId, API_KEY))) {
+    const handled = await handleCodexOAuthAccounts(
+      req,
+      res,
+      getPathSegments(url),
+      parseQueryParams(url),
+    );
+    expect(handled).toBe(true);
+  }
+  return new Response(body, { status });
+}
+
+async function list(): Promise<CodexAccountsResponse> {
+  const response = await request();
+  expect(response.status).toBe(200);
+  return (await response.json()) as CodexAccountsResponse;
+}
+
+beforeAll(async () => {
+  initDb(":memory:");
+  workerId = (await createAgent({ name: "account-worker", isLead: false, status: "idle" })).id;
+  leadId = (await createAgent({ name: "account-lead", isLead: true, status: "idle" })).id;
+  workerToken = (await mintAgentToken(workerId)).plaintext;
+  leadToken = (await mintAgentToken(leadId)).plaintext;
+});
+
+beforeEach(async () => {
+  await getDbClient().run("DELETE FROM swarm_config");
+  await getDbClient().run("DELETE FROM api_key_status");
+  await getDbClient().run("DELETE FROM kv_entries");
+});
+
+afterEach(() => _resetAutoReloadForTests());
+
+afterAll(() => {
+  _resetAutoReloadForTests();
+  closeDb();
+});
+
+describe("Codex account HTTP routes", () => {
+  test("lists slots in numeric order with metadata and no credentials", async () => {
+    const account = credentials("grant-first", { email: "first@example.test" });
+    await store("codex_oauth_10", credentials("grant-tenth"));
+    await store("codex_oauth_2", account);
+    await upsertSwarmConfig({
+      scope: "agent",
+      scopeId: workerId,
+      key: "codex_oauth_1",
+      value: JSON.stringify(credentials("agent-only")),
+      isSecret: true,
+    });
+    await recordKeyUsage("CODEX_OAUTH", "first", 2, null);
+    const response = await request();
+    expect(response.status).toBe(200);
+    const text = await response.text();
+    expect(text).not.toContain(account.access);
+    expect(text).not.toContain(account.refresh);
+    expect(text).not.toContain(account.accountId);
+    expect(JSON.parse(text)).toEqual({
+      accounts: [
+        {
+          slot: 2,
+          configKey: "codex_oauth_2",
+          legacy: false,
+          suffix: "first",
+          plan: "team",
+          email: "first@example.test",
+          status: "ok",
+        },
+        {
+          slot: 10,
+          configKey: "codex_oauth_10",
+          legacy: false,
+          suffix: "tenth",
+          plan: "team",
+          email: null,
+          status: "unchecked",
+        },
+      ],
+    });
+  });
+
+  test("uses the legacy row only when slot zero does not exist", async () => {
+    await store("codex_oauth");
+    expect((await list()).accounts).toMatchObject([
+      { slot: 0, legacy: true, configKey: "codex_oauth" },
+    ]);
+    await store("codex_oauth_0");
+    expect((await list()).accounts).toMatchObject([
+      { slot: 0, legacy: false, configKey: "codex_oauth_0" },
+    ]);
+  });
+
+  test("lists malformed credentials as accounts that need login", async () => {
+    await store("codex_oauth_0", "not-json");
+    await store("codex_oauth_1", { access: 42, accountId: "example" });
+    await store("codex_oauth_2", "null");
+    const { accounts } = await list();
+    expect(accounts).toHaveLength(3);
+    for (const account of accounts) {
+      expect(account).toMatchObject({
+        suffix: null,
+        plan: null,
+        email: null,
+        status: "needs_login",
+      });
+    }
+  });
+
+  test.each([
+    { refresh: undefined },
+    { refresh: "" },
+    { expires: undefined },
+    { expires: "invalid" },
+    { expires: null },
+  ])("requires a refresh token and numeric expiry: %j", async (invalid) => {
+    await store("codex_oauth_0", { ...credentials("grant-invalid"), ...invalid });
+    expect((await list()).accounts).toMatchObject([
+      { slot: 0, suffix: null, plan: null, email: null, status: "needs_login" },
+    ]);
+  });
+
+  test("rejects a non-finite expiry", async () => {
+    const value = JSON.stringify(credentials("grant-invalid")).replace(
+      /"expires":\d+/,
+      '"expires":1e999',
+    );
+    await store("codex_oauth_0", value);
+    expect((await list()).accounts).toMatchObject([
+      { slot: 0, suffix: null, plan: null, email: null, status: "needs_login" },
+    ]);
+  });
+
+  test("ignores unrelated unreadable secrets and permits removal of an unreadable account", async () => {
+    await store("codex_oauth_0");
+    for (const key of ["UNRELATED_SECRET", "codex_oauth_1"]) {
+      await store(key);
+      await getDbClient().run("UPDATE swarm_config SET value = ?, encrypted = 1 WHERE key = ?", [
+        "invalid-ciphertext",
+        key,
+      ]);
+    }
+    const { accounts } = await list();
+    expect(accounts).toHaveLength(2);
+    expect(accounts[1]).toMatchObject({ slot: 1, suffix: null, status: "needs_login" });
+    const response = await request("/1", "DELETE");
+    expect(response.status).toBe(200);
+    expect((await response.json()).accounts).toHaveLength(1);
+  });
+
+  test("shows active KV and status auth benches without treating ordinary rate limits as auth failures", async () => {
+    await store("codex_oauth_0", credentials("grant-bench"));
+    await store("codex_oauth_1", credentials("grant-authf"));
+    await store("codex_oauth_2", credentials("grant-ratel"));
+    await upsertKv({
+      namespace: "codex-auth-watch",
+      key: "bench:bench",
+      valueType: "string",
+      value: "1",
+    });
+    await recordKeyAuthFailure("CODEX_OAUTH", "authf", 1);
+    await recordKeyAuthFailure("CODEX_OAUTH", "authf", 1);
+    await getDbClient().run("DELETE FROM kv_entries WHERE key = 'bench:authf'");
+    await markKeyRateLimited(
+      "CODEX_OAUTH",
+      "ratel",
+      2,
+      new Date(Date.now() + 3_600_000).toISOString(),
+    );
+    expect((await list()).accounts.map((account) => account.status)).toEqual([
+      "needs_login",
+      "needs_login",
+      "ok",
+    ]);
+  });
+
+  test("ignores expired KV markers and status records from other scopes", async () => {
+    await store("codex_oauth_0", credentials("grant-clear"));
+    await upsertKv({
+      namespace: "codex-auth-watch",
+      key: "bench:clear",
+      valueType: "string",
+      value: "1",
+      expiresAt: Date.now() - 1,
+    });
+    await recordKeyAuthFailure("CODEX_OAUTH", "clear", 0, "agent", workerId);
+    expect((await list()).accounts[0]?.status).toBe("unchecked");
+  });
+
+  test("requires authentication and permission to read all secrets", async () => {
+    await store("codex_oauth_0");
+    expect((await request("", "GET", "invalid")).status).toBe(401);
+    const denied = await request("", "GET", workerToken);
+    expect(denied.status).toBe(403);
+    expect(await denied.text()).not.toContain("codex_oauth_0");
+    expect((await request("", "GET", leadToken)).status).toBe(200);
+    expect((await request("", "GET", API_KEY, workerId)).status).toBe(200);
+  });
+
+  test("deletes only the selected slot and schedules config side effects", async () => {
+    await store("codex_oauth_0");
+    await store("codex_oauth_2");
+    const response = await request("/2", "DELETE");
+    expect(response.status).toBe(200);
+    expect((await response.json()).accounts).toMatchObject([{ slot: 0 }]);
+    expect(await getSwarmConfigs({ scope: "global", key: "codex_oauth_2" })).toEqual([]);
+    expect(_autoReloadStatsForTests().pending).toBe(true);
+  });
+
+  test("a sign-in in a freed slot does not inherit the removed account's auth bench", async () => {
+    await store("codex_oauth_0", credentials("grant-keep0"));
+    await store("codex_oauth_1", credentials("grant-gone1"));
+    await recordKeyAuthFailure("CODEX_OAUTH", "gone1", 1);
+    await recordKeyAuthFailure("CODEX_OAUTH", "gone1", 1);
+    expect((await getAvailableKeyIndices("CODEX_OAUTH", 2)).availableIndices).toEqual([0]);
+    expect((await request("/1", "DELETE")).status).toBe(200);
+    await store("codex_oauth_1", credentials("grant-fresh"));
+    expect((await getAvailableKeyIndices("CODEX_OAUTH", 2)).availableIndices).toEqual([0, 1]);
+    expect((await list()).accounts.map((account) => account.status)).toEqual([
+      "unchecked",
+      "unchecked",
+    ]);
+  });
+
+  test("deletes the legacy slot zero and keeps it when the numbered row exists", async () => {
+    await store("codex_oauth");
+    expect((await request("/0", "DELETE")).status).toBe(200);
+    expect(await getSwarmConfigs({ scope: "global", key: "codex_oauth" })).toEqual([]);
+    await store("codex_oauth");
+    await store("codex_oauth_0");
+    const response = await request("/0", "DELETE");
+    expect(response.status).toBe(200);
+    expect((await response.json()).accounts).toMatchObject([{ slot: 0, legacy: true }]);
+    expect(await getSwarmConfigs({ scope: "global", key: "codex_oauth_0" })).toEqual([]);
+  });
+
+  test("returns 404 for missing slots and rejects invalid slot numbers", async () => {
+    expect((await request("/1", "DELETE")).status).toBe(404);
+    for (const slot of ["-1", "1.5", "nope", "101"]) {
+      expect((await request(`/${slot}`, "DELETE")).status).toBe(400);
+    }
+    expect(_autoReloadStatsForTests().pending).toBe(false);
+  });
+
+  test("a user who may delete config but not read secrets cannot remove an account", async () => {
+    await store("codex_oauth_0", credentials("grant-keep0", { email: "keep@example.com" }));
+    await store("codex_oauth_1");
+    const user = await createUser({ name: "Delete-only user" });
+    const token = await mintToken(user.id, "delete-only", { kind: "operator", id: "codex-test" });
+    // A new user starts as admin. Replace that with a role that grants only the delete.
+    await getDbClient().run("DELETE FROM principal_roles WHERE principalId = ?", [user.id]);
+    await getDbClient().run(
+      "INSERT INTO roles (id, name) VALUES ('codex-delete-only', 'codex-delete-only')",
+    );
+    await getDbClient().run(
+      "INSERT INTO role_permissions (roleId, verb) VALUES ('codex-delete-only', 'config.delete.any')",
+    );
+    await getDbClient().run(
+      "INSERT INTO principal_roles (principalType, principalId, roleId) VALUES ('user', ?, 'codex-delete-only')",
+      [user.id],
+    );
+    const previous = process.env.RBAC_ENABLED;
+    process.env.RBAC_ENABLED = "true";
+    try {
+      const response = await request("/1", "DELETE", token.plaintext);
+      expect(response.status).toBe(403);
+      expect(await response.text()).not.toContain("keep@example.com");
+      expect((await getSwarmConfigs({ scope: "global", key: "codex_oauth_1" })).length).toBe(1);
+    } finally {
+      if (previous === undefined) delete process.env.RBAC_ENABLED;
+      else process.env.RBAC_ENABLED = previous;
+    }
+  });
+
+  test("denies worker deletion and identity spoofing while allowing the lead", async () => {
+    await store("codex_oauth_0");
+    expect((await request("/0", "DELETE", workerToken)).status).toBe(403);
+    expect((await request("/0", "DELETE", workerToken, leadId)).status).toBe(403);
+    expect((await getSwarmConfigs({ scope: "global", key: "codex_oauth_0" })).length).toBe(1);
+    expect((await request("/0", "DELETE", leadToken)).status).toBe(200);
+  });
+});