Skip to content

Claude Code. Any Model. The most powerful AI coding agent now speaks every language.

10.0 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, test } from "bun:test";
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

let home: string;
let billing: typeof import("./billing-probe.js");
let savedFetch: typeof fetch;
let savedDisable: string | undefined;
let roles: typeof import("./prompt-role.js");
let store: typeof import("../../providers/meta-muse/muse-store.js");
let core: typeof import("../../providers/meta-muse/muse-credentials.js");
let kc: typeof import("../../providers/meta-muse/muse-keychain.js");
let generic: typeof import("../../providers/keychain.js");
let reads: number;
let mints: number;
const TOKEN = "dca:TESTTOKEN0001";
const KEY = "LLM|TESTKEY0001";
function restore(name: string, value: string | undefined) {
  if (value === undefined) delete process.env[name];
  else process.env[name] = value;
}
beforeEach(async () => {
  savedDisable = process.env.CLAUDISH_DISABLE_KEYCHAIN;
  home = mkdtempSync(join(tmpdir(), "muse-role-test-"));
  process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
  savedFetch = globalThis.fetch;
  globalThis.fetch = Object.assign(
    async (input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => {
      const url = new URL(input instanceof Request ? input.url : String(input));
      if (url.protocol === "http:" && url.hostname === "127.0.0.1") return savedFetch(input, init);
      throw new Error(`unexpected network request: ${url.origin}${url.pathname}`);
    },
    { preconnect: () => {} }
  ) as typeof fetch;
  generic = await import("../../providers/keychain.js");
  generic.setKeychainTestDeps({
    platform: () => "darwin",
    run: () => {
      throw new Error("unexpected Keychain process");
    },
    runAsync: async () => {
      throw new Error("unexpected Keychain process");
    },
    spawnAsync: () => {
      throw new Error("unexpected Keychain process");
    },
  });
  kc = await import("../../providers/meta-muse/muse-keychain.js");
  kc.setMuseKeychainTestDeps({
    dir: () => home,
    env: () => ({ CLAUDISH_DISABLE_KEYCHAIN: "1" }),
    now: () => 1000000,
    sleep: async () => {},
    pid: () => 98765,
    isAlive: () => false,
    presence: async () => ({ kind: "absent" }),
    startRead: () => {
      throw new Error("unexpected value read");
    },
  });
  roles = await import("./prompt-role.js");
  store = await import("../../providers/meta-muse/muse-store.js");
  core = await import("../../providers/meta-muse/muse-credentials.js");
  roles._resetCredentialPromptRoleForTest();
  core.resetMuseCredentialState();
  reads = 0;
  mints = 0;
  core.setMuseCoreTestDeps({
    readStore: (kind) => store.readMuseStore(kind, home),
    writeBorrowedCopy: (token, tier) =>
      store.writeBorrowedCopy(token, tier, home, () => new Date(1000000)),
    dir: () => home,
    now: () => 1000000,
    keychainLogin: async (use) => {
      reads++;
      return { kind: "used", value: await use(TOKEN), source: "keychain" };
    },
    // Exported MuseMint outcome, projected from the §8 confirmed capture.
    mint: async () => {
      mints++;
      return { apiKey: KEY, subsTierName: "Muse Code Power Usage" };
    },
  });
  billing = await import("./billing-probe.js");
  billing.clearSignedArm();
});
afterEach(() => {
  billing.clearSignedArm();
  globalThis.fetch = savedFetch;
  core.resetMuseCredentialState();
  core.setMuseCoreTestDeps(null);
  kc.resetMuseKeychainState();
  kc.setMuseKeychainTestDeps(null);
  generic.invalidateKeychainCache();
  generic.setKeychainTestDeps(null);
  roles._resetCredentialPromptRoleForTest();
  restore("CLAUDISH_DISABLE_KEYCHAIN", savedDisable);
  rmSync(home, { recursive: true, force: true });
});

describe("P1: permission to read a credential", () => {
  test("default role is never, and explicit role setter returns the effective role", () => {
    expect(roles.credentialPromptRole()).toBe("never");
    expect(core.requestPathMayPrompt()).toBe(false);
    const prior = roles.credentialPromptRole();
    expect(prior).toBe("never");
    expect(roles.setCredentialPromptRole("interactive-launch")).toBe("interactive-launch");
    expect(roles.credentialPromptRole()).toBe("interactive-launch");
    expect(core.requestPathMayPrompt()).toBe(true);
    expect(roles.setCredentialPromptRole("tui")).toBe("interactive-launch");
    expect(roles.credentialPromptRole()).toBe("interactive-launch");
    expect(roles.setCredentialPromptRole("never")).toBe("never");
    expect(roles.credentialPromptRole()).toBe("never");
    expect(core.requestPathMayPrompt()).toBe(false);
  });
  test("eligible interactive launch receives prompt rights", () => {
    expect(roles.decideLaunchRole({ argv: [], env: {}, stdinIsTTY: true, stderrIsTTY: true })).toBe(
      "interactive-launch"
    );
  });
  for (const facts of [
    { argv: [], env: {}, stdinIsTTY: false, stderrIsTTY: true },
    { argv: [], env: {}, stdinIsTTY: true, stderrIsTTY: false },
    { argv: ["-p", "reply PONG"], env: {}, stdinIsTTY: false, stderrIsTTY: false },
    { argv: ["--probe", "[email protected]"], env: {}, stdinIsTTY: true, stderrIsTTY: true },
  ]) {
    test(`denies launch rights for ${JSON.stringify(facts)}`, () => {
      expect(roles.decideLaunchRole(facts)).toBe("never");
    });
  }
  describe("decideTuiRole", () => {
    test("standalone TUI receives tui rights", () => {
      expect(roles.decideTuiRole({})).toBe("tui");
    });
    test("MCP session marker denies TUI rights without a cwd", () => {
      expect(roles.decideTuiRole({ CLAUDISH_PANE_CHILD: "1" })).toBe("never");
    });
    test("MCP session marker denies TUI rights with a cwd", () => {
      expect(roles.decideTuiRole({ CLAUDISH_PANE_CHILD: "1", CLAUDISH_PANE_CWD: "/x" })).toBe(
        "never"
      );
    });
    test("MCP session TUI role cannot later be raised to tui", () => {
      roles._resetCredentialPromptRoleForTest();
      roles.setCredentialPromptRole(roles.decideTuiRole({ CLAUDISH_PANE_CHILD: "1" }));
      expect(roles.credentialPromptRole()).toBe("never");
      roles.setCredentialPromptRole("tui");
      expect(roles.credentialPromptRole()).toBe("never");
    });
  });
  test("never role cannot gain rights from prompt:true", async () => {
    await expect(core.ensureMuseCredentialReady({ prompt: true })).rejects.toThrow("login");
    expect(reads).toBe(0);
    expect(mints).toBe(0);
    expect(core.currentMuseState()).toBeUndefined();
  });
  test("TUI proxy request cannot read Keychain", async () => {
    roles.setCredentialPromptRole("tui");
    await expect(
      core.ensureMuseCredentialReady({ prompt: core.requestPathMayPrompt() })
    ).rejects.toThrow("login");
    expect(reads).toBe(0);
    expect(mints).toBe(0);
    expect(core.currentMuseState()).toBeUndefined();
  });
  for (const action of ["Test", "Test All", "route probe"]) {
    test(`explicit wrapped ${action} prepares the credential before the action`, async () => {
      roles.setCredentialPromptRole("tui");
      const output = await core.withInteractiveCredential(async () => {
        expect(core.currentMuseState()).toMatchObject({ key: KEY, source: "keychain" });
        expect(core.requestPathMayPrompt()).toBe(false);
        await core.ensureMuseCredentialReady({ prompt: core.requestPathMayPrompt() });
        return action;
      });
      expect(output).toBe(action);
      expect(reads).toBe(1);
      expect(mints).toBe(1);
      expect(roles.credentialPromptRole()).toBe("tui");
      expect(core.requestPathMayPrompt()).toBe(false);
    });
  }
  test("overlapping requests in a never role cannot prompt", async () => {
    const results = await Promise.allSettled([
      core.ensureMuseCredentialReady({ prompt: false }),
      core.ensureMuseCredentialReady({ prompt: false }),
    ]);
    expect(results.map((result) => result.status)).toEqual(["rejected", "rejected"]);
    for (const result of results)
      if (result.status === "rejected") expect(String(result.reason)).toContain("login");
    expect(reads).toBe(0);
    expect(mints).toBe(0);
  });
  test("P1: only the exact pane session marker identifies an MCP session", async () => {
    const pane = await import("../../pane/child-env.js");
    expect(pane.PANE_LAUNCH_VARS).toEqual([
      "CLAUDISH_PANE_ENV",
      "CLAUDISH_PANE_CWD",
      "CLAUDISH_HOOK_INBOX",
      "CLAUDISH_HOOK_SESSION",
    ]);
    for (const marker of ["1", "0", "", "true", undefined]) {
      const env = marker === undefined ? {} : { CLAUDISH_PANE_CHILD: marker };
      expect(pane.inMcpSession(env)).toBe(marker === "1");
    }
  });
  test("P1: a pane child needs the exact session marker and a non-empty cwd", async () => {
    const pane = await import("../../pane/child-env.js");
    for (const marker of ["1", "0", "", "true", undefined]) {
      for (const cwd of ["/test/pane", "", undefined]) {
        const env = {
          ...(marker === undefined ? {} : { CLAUDISH_PANE_CHILD: marker }),
          ...(cwd === undefined ? {} : { CLAUDISH_PANE_CWD: cwd }),
        };
        expect(pane.isPaneChild(env)).toBe(marker === "1" && cwd === "/test/pane");
      }
    }
  });
  for (const cwd of [undefined, "/test/pane"]) {
    test(`P1: ${cwd === undefined ? "process nested below the pane child" : "pane/team child"} with real PTY facts never gains prompt rights`, async () => {
      const pane = await import("../../pane/child-env.js");
      const env = {
        CLAUDISH_PANE_CHILD: "1",
        ...(cwd === undefined ? {} : { CLAUDISH_PANE_CWD: cwd }),
      };
      expect(pane.inMcpSession(env)).toBe(true);
      expect(pane.isPaneChild(env)).toBe(cwd !== undefined);
      const role = roles.decideLaunchRole({ argv: [], env, stdinIsTTY: true, stderrIsTTY: true });
      expect(role).toBe("never");
      roles.setCredentialPromptRole(role);
      await expect(
        core.ensureMuseCredentialReady({ prompt: core.requestPathMayPrompt() })
      ).rejects.toThrow("muse@ in a team slot / MCP session needs a claudish login");
      expect(reads).toBe(0);
      expect(mints).toBe(0);
    });
  }
  test.skip("P1 BLOCKED: actual MCP/preflight probe:true and probe:false handlers are not exported; startMcpServer has no injected server or tool-dispatch seam", () => {});
});