Skip to content

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

test(meta-muse-code): add blind tests for muse@ and meta@

Jack Rudenko507b7b3ba8fa
diff --git a/packages/cli/src/auth/auth-commands.test.ts b/packages/cli/src/auth/auth-commands.test.ts
new file mode 100644
index 00000000..31545780
--- /dev/null
+++ b/packages/cli/src/auth/auth-commands.test.ts
@@ -0,0 +1,305 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+
+const children: ReturnType<typeof Bun.spawn>[] = [];
+async function waitForChild(child: ReturnType<typeof Bun.spawn>) {
+ let timer: ReturnType<typeof setTimeout> | undefined;
+ try {
+ return await Promise.race([
+ child.exited,
+ new Promise<number>((resolve) => {
+ timer = setTimeout(() => {
+ child.kill();
+ resolve(124);
+ }, 4000);
+ }),
+ ]);
+ } finally {
+ clearTimeout(timer);
+ }
+}
+
+const roots: string[] = [];
+afterEach(async () => {
+ for (const child of children.splice(0)) {
+ if (child.exitCode === null) child.kill();
+ await child.exited;
+ }
+ for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+async function runLogoutScenario(scenario: "stores" | "discovery" | "billing") {
+ const root = mkdtempSync(join(tmpdir(), "muse-logout-child-"));
+ roots.push(root);
+ const tempHome = join(root, "home");
+ mkdirSync(tempHome);
+ const scriptPath = join(root, "scenario.ts");
+ const script = `
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import { homedir } from "node:os";
+import { resolve, relative, isAbsolute } from "node:path";
+import { fileURLToPath } from "node:url";
+import { syncBuiltinESMExports } from "node:module";
+const realExit = process.exit.bind(process);
+const realFetch = globalThis.fetch;
+try {
+const tempHome = process.env.HOME;
+assert.equal(homedir(), tempHome);
+const isInside = path => {
+ const rel = relative(tempHome, resolve(path instanceof URL ? fileURLToPath(path) : path));
+ return rel === "" || (rel !== ".." && !rel.startsWith("../") && !isAbsolute(rel));
+};
+// Installed before application imports. Any filesystem mutation outside HOME fails
+// before it reaches the filesystem, including an atomic rename's destination.
+const writes = [];
+function checkWrite(path) {
+ assert.ok(typeof path === "string" || path instanceof URL, "untracked write target");
+ assert.ok(isInside(path), "write outside child HOME: " + path);
+ writes.push(String(path));
+}
+for (const [name, indices] of Object.entries({
+ writeFile: [0], appendFile: [0], mkdir: [0], rm: [0], rmdir: [0], unlink: [0],
+ rename: [0, 1], copyFile: [1], chmod: [0], chown: [0], truncate: [0],
+ utimes: [0], link: [1], symlink: [1], mkdtemp: [0]
+})) {
+ for (const api of [name, name + "Sync"]) {
+ if (typeof fs[api] !== "function") continue;
+ const original = fs[api];
+ fs[api] = function (...args) { for (const i of indices) checkWrite(args[i]); return original.apply(this, args); };
+ }
+ if (typeof fs.promises[name] === "function") {
+ const original = fs.promises[name];
+ fs.promises[name] = function (...args) { for (const i of indices) checkWrite(args[i]); return original.apply(this, args); };
+ }
+}
+for (const target of [fs, fs.promises]) {
+ for (const name of ["open", "openSync", "createWriteStream"]) {
+ if (typeof target[name] !== "function") continue;
+ const original = target[name];
+ target[name] = function (path, flags, ...args) {
+ if (name === "createWriteStream" || (typeof flags === "number" ? (flags & (fs.constants.O_WRONLY | fs.constants.O_RDWR | fs.constants.O_CREAT | fs.constants.O_TRUNC | fs.constants.O_APPEND)) !== 0 : /[wa+]/.test(flags ?? "r"))) checkWrite(path);
+ return original.call(this, path, flags, ...args);
+ };
+ }
+}
+const originalBunWrite = Bun.write;
+Bun.write = (path, ...args) => { checkWrite(path); return originalBunWrite(path, ...args); };
+syncBuiltinESMExports();
+// CLI logging cannot pollute the single JSON result line.
+console.log = (...args) => console.error(...args);
+const { existsSync, readFileSync, writeFileSync } = fs;
+const join = (...parts) => resolve(...parts);
+const commands = [];
+const urls = [];
+const exitCodes = [];
+process.exit = code => { exitCodes.push(code); };
+globalThis.fetch = Object.assign(async (input, init) => {
+ const url = new URL(input instanceof Request ? input.url : String(input));
+ if (url.protocol !== "http:" && url.protocol !== "https:") return realFetch(input, init);
+ urls.push(url.href);
+ throw new Error("unexpected network request");
+}, { preconnect() {} });
+
+let home;
+let generic;
+let kc;
+let roles;
+let store;
+let core;
+let auth;
+let discovery;
+let probe;
+let providerProbe;
+let authority;
+let billing;
+let billingTypes;
+let previous;
+let previousFetcher;
+let discoveryCalls;
+let discoveredId;
+ generic = await import(${JSON.stringify(resolve(import.meta.dir, "../providers/keychain.js"))});
+ generic.setKeychainTestDeps({ platform: () => "darwin",
+ run: (args) => { commands.push(args); return { code: 44, stdout: "", stderr: "absent" }; },
+ runAsync: async (args) => { commands.push(args); return { code: 44, stdout: "", stderr: "absent" }; },
+ spawnAsync: (args) => { commands.push(args); return { pid: undefined,
+ done: Promise.resolve({ code: 44, stdout: "", stderr: "absent" }) }; } });
+ kc = await import(${JSON.stringify(resolve(import.meta.dir, "../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 Keychain read"); } });
+ roles = await import(${JSON.stringify(resolve(import.meta.dir, "./credentials/prompt-role.js"))});
+ store = await import(${JSON.stringify(resolve(import.meta.dir, "../providers/meta-muse/muse-store.js"))});
+ home = store.defaultMuseStoreDir();
+ assert.ok(isInside(home));
+ core = await import(${JSON.stringify(resolve(import.meta.dir, "../providers/meta-muse/muse-credentials.js"))});
+ roles._resetCredentialPromptRoleForTest(); core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps({
+ readStore: (kind) => store.readMuseStore(kind, home),
+ writeBorrowedCopy: (token, tier) => store.writeBorrowedCopy(token, tier, home, () => new Date(1000000)),
+ dir: () => home, now: () => 1000000,
+ // Exported MuseMint projection of the §8 confirmed capture.
+ mint: async () => ({ apiKey: "LLM|TESTKEY0001", subsTierName: "Muse Code Power Usage" }),
+ keychainLogin: async () => ({ kind: "absent" as const }) });
+ auth = await import(${JSON.stringify(resolve(import.meta.dir, "./auth-commands.js"))});
+ discovery = await import(${JSON.stringify(resolve(import.meta.dir, "../providers/model-discovery.js"))});
+ probe = await import(${JSON.stringify(resolve(import.meta.dir, "../providers/transport/probe-discovery.js"))});
+ providerProbe = await import(${JSON.stringify(resolve(import.meta.dir, "../providers/transport/provider-model-discovery.js"))});
+ authority = await import(${JSON.stringify(resolve(import.meta.dir, "./credentials/authority.js"))});
+ billing = await import(${JSON.stringify(resolve(import.meta.dir, "./credentials/billing-probe.js"))});
+ billingTypes = await import(${JSON.stringify(resolve(import.meta.dir, "../handlers/shared/remote-provider-types.js"))});
+ const old = authority.credentials.get("meta-muse-code");
+ if (!old) throw new Error("default Muse credential registration missing");
+ previous = old;
+ const { MuseCodeCredentialProvider } = await import(${JSON.stringify(resolve(import.meta.dir, "./credentials/muse-code-credential.js"))});
+ authority.credentials.register(new MuseCodeCredentialProvider(), ["meta-muse-code"]);
+ await import(${JSON.stringify(resolve(import.meta.dir, "../providers/model-discovery-builtins.js"))});
+ const oldFetcher = discovery.getModelDiscoveryFetcher("muse-code-models");
+ if (!oldFetcher) throw new Error("Muse discovery fetcher registration missing");
+ previousFetcher = oldFetcher; discoveryCalls = 0; discoveredId = "muse-spark-1.3";
+ // Contract-typed discovery projection of §4, not an invented Meta wire body.
+ discovery.registerModelDiscoveryFetcher("muse-code-models", async provider => {
+ discoveryCalls++;
+ if (!await authority.credentials.isAvailable(provider)) return { kind: "failed",
+ failure: { kind: "no-credentials", detail: "run claudish login muse" } };
+ return { kind: "models", models: [{ id: discoveredId, reported: "chat", contextWindow: 1007997 }] };
+ });
+ discovery.invalidateModelDiscovery("meta-muse-code"); probe.invalidateProbeDiscovery("meta-muse-code");
+ billing.clearSignedArm();
+
+function noExternalEffects() {
+ assert.deepEqual(urls, []);
+ assert.ok(commands.every(args => args[0] === "find-generic-password" && !args.includes("-w")));
+ assert.ok(writes.every(isInside));
+}
+const scenario = process.env.MUSE_SCENARIO;
+let result;
+if (scenario === "stores") {
+ assert.notEqual(auth.findProvider("muse"), null);
+ store.writeMuseStore("own-login", { access_token: "dca:TESTTOKEN0001" }, home);
+ store.writeBorrowedCopy("dca:TESTTOKEN0001", "Muse Code Power Usage", home);
+ const sentinel = join(home, "unrelated-sentinel.json"); writeFileSync(sentinel, "keep");
+ await core.ensureMuseCredentialReady({ prompt: false });
+ assert.equal(core.currentMuseState()?.key, "LLM|TESTKEY0001");
+ await auth.logoutCommand("muse");
+ assert.deepEqual(exitCodes, [0]);
+ const ownExists = existsSync(store.museStorePath("own-login", home));
+ const borrowedExists = existsSync(store.museStorePath("borrowed-copy", home));
+ assert.equal(ownExists, false); assert.equal(borrowedExists, false);
+ assert.equal(readFileSync(sentinel, "utf8"), "keep");
+ assert.equal(core.currentMuseState(), undefined);
+ await assert.rejects(core.ensureMuseCredentialReady({ prompt: false }), /login/);
+ result = { ownExists, borrowedExists, sentinel: readFileSync(sentinel, "utf8"), keyCleared: !core.currentMuseState() };
+} else if (scenario === "discovery") {
+ store.writeMuseStore("own-login", { access_token: "dca:TESTTOKEN0001" }, home);
+ assert.equal((await discovery.discoverProviderModelsCatalog("meta-muse-code")).kind, "served");
+ assert.equal((await providerProbe.discoverProviderProbeModel("meta-muse-code", "Muse Code")).model, "muse-spark-1.3");
+ const warmed = discoveryCalls;
+ assert.ok(warmed > 0);
+ assert.equal((await discovery.discoverProviderModelsCatalog("meta-muse-code")).kind, "served");
+ assert.equal(discoveryCalls, warmed);
+ await auth.logoutCommand("muse");
+ assert.deepEqual(exitCodes, [0]);
+ assert.equal(existsSync(store.museStorePath("own-login", home)), false);
+ assert.equal(existsSync(store.museStorePath("borrowed-copy", home)), false);
+ assert.equal(core.currentMuseState(), undefined);
+ await assert.rejects(core.ensureMuseCredentialReady({ prompt: false }), /login/);
+ noExternalEffects();
+ // The TUI explicitly invalidates discovery after a credential change.
+ discovery.invalidateModelDiscovery("meta-muse-code");
+ probe.invalidateProbeDiscovery("meta-muse-code");
+ discoveredId = "muse-spark-1.2";
+ store.writeMuseStore("own-login", { access_token: "dca:TESTTOKEN0001" }, home);
+ const model = (await providerProbe.discoverProviderProbeModel("meta-muse-code", "Muse Code")).model;
+ assert.equal(model, "muse-spark-1.2");
+ const outcome = await discovery.discoverProviderModelsCatalog("meta-muse-code");
+ assert.equal(outcome.kind, "served");
+ assert.deepEqual(outcome.models.map(model => model.id), ["muse-spark-1.2"]);
+ assert.ok(discoveryCalls > warmed);
+ result = { model, ids: outcome.models.map(model => model.id), refreshed: discoveryCalls > warmed };
+} else {
+ assert.equal(scenario, "billing");
+ const installed = billingTypes.registerSubscriptionCredentialProbe(null);
+ billingTypes.registerSubscriptionCredentialProbe(installed);
+ assert.notEqual(installed, null);
+ billing.clearSignedArm("meta-muse-code");
+ const baseline = installed("meta-muse-code");
+ billing.recordSignedArm("meta-muse-code", baseline ? "metered" : "subscription");
+ assert.equal(installed("meta-muse-code"), !baseline);
+ await auth.logoutCommand("muse");
+ assert.deepEqual(exitCodes, [0]);
+ assert.equal(installed("meta-muse-code"), baseline);
+ result = { reset: installed("meta-muse-code") === baseline };
+}
+noExternalEffects();
+// Restore replacements even though the child is about to finish.
+discovery.registerModelDiscoveryFetcher("muse-code-models", previousFetcher);
+authority.credentials.register(previous, ["meta-muse-code"]);
+authority.credentials.invalidate("meta-muse-code"); billing.clearSignedArm();
+discovery.invalidateModelDiscovery("meta-muse-code"); probe.invalidateProbeDiscovery("meta-muse-code");
+core.resetMuseCredentialState(); core.setMuseCoreTestDeps(null);
+kc.resetMuseKeychainState(); kc.setMuseKeychainTestDeps(null);
+generic.invalidateKeychainCache(); generic.setKeychainTestDeps(null);
+roles._resetCredentialPromptRoleForTest();
+process.stdout.write(JSON.stringify({ scenario, result, exitCodes, requests: urls.length,
+ outsideWrites: writes.filter(path => !isInside(path)), writes: writes.length }) + "\\n");
+realExit(0);
+} catch (error) { console.error(error); realExit(1); }
+`;
+ writeFileSync(scriptPath, script);
+ const child = Bun.spawn([process.execPath, scriptPath], {
+ cwd: tempHome,
+ env: {
+ ...process.env,
+ HOME: tempHome,
+ TMPDIR: tempHome,
+ CLAUDISH_DISABLE_KEYCHAIN: "1",
+ CLAUDISH_DISABLE_CATALOG_WARM: "1",
+ CLAUDISH_MUSE_KEYCHAIN_FILE: "",
+ MUSE_SCENARIO: scenario,
+ },
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ children.push(child);
+ const [stdout, stderr, code] = await Promise.all([
+ new Response(child.stdout).text(),
+ new Response(child.stderr).text(),
+ waitForChild(child),
+ ]);
+ expect({ code, stderr: code === 0 ? "" : stderr }).toEqual({ code: 0, stderr: "" });
+ const lines = stdout.trim().split("\n");
+ expect(lines).toHaveLength(1);
+ const outcome = JSON.parse(lines[0]!);
+ expect(outcome.scenario).toBe(scenario);
+ expect(outcome.exitCodes).toEqual([0]);
+ expect(outcome.requests).toBe(0);
+ expect(outcome.outsideWrites).toEqual([]);
+ // The only parent-owned file outside HOME remains byte-for-byte unchanged.
+ expect(readFileSync(scriptPath, "utf8")).toBe(script);
+ expect(readdirSync(root).sort()).toEqual(["home", "scenario.ts"]);
+ return outcome;
+}
+
+describe("L1: public Muse logout with HOME set at process start", () => {
+ test("findProvider recognizes muse and logout removes both local stores and process key", async () => {
+ const { result, writes } = await runLogoutScenario("stores");
+ expect(result).toEqual({
+ ownExists: false,
+ borrowedExists: false,
+ sentinel: "keep",
+ keyCleared: true,
+ });
+ expect(writes).toBeGreaterThan(0);
+ });
+ test("L1: logout clears credentials; explicit invalidation refreshes discovery", async () => {
+ const { result } = await runLogoutScenario("discovery");
+ expect(result).toEqual({ model: "muse-spark-1.2", ids: ["muse-spark-1.2"], refreshed: true });
+ });
+ test("L1: logout clears the signed-arm record through the installed billing probe", async () => {
+ const { result } = await runLogoutScenario("billing");
+ expect(result).toEqual({ reset: true });
+ });
+});
diff --git a/packages/cli/src/auth/credentials/kimi-credential.test.ts b/packages/cli/src/auth/credentials/kimi-credential.test.ts
new file mode 100644
index 00000000..e1f2efeb
--- /dev/null
+++ b/packages/cli/src/auth/credentials/kimi-credential.test.ts
@@ -0,0 +1,556 @@
+import { afterAll, afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { Hono } from "hono";
+
+const children: ReturnType<typeof Bun.spawn>[] = [];
+
+afterEach(async () => {
+ for (const child of children.splice(0)) {
+ if (child.exitCode === null) child.kill();
+ await child.exited;
+ }
+});
+async function waitForChild(child: ReturnType<typeof Bun.spawn>) {
+ let timer: ReturnType<typeof setTimeout> | undefined;
+ try {
+ return await Promise.race([
+ child.exited,
+ new Promise<number>((resolve) => {
+ timer = setTimeout(() => {
+ child.kill();
+ resolve(124);
+ }, 4000);
+ }),
+ ]);
+ } finally {
+ clearTimeout(timer);
+ }
+}
+
+// HOME must exist in the environment at process start for Bun's os.homedir().
+// Keep the child and all of its writable resources under a per-case temp home.
+const childRoots: string[] = [];
+afterEach(async () => {
+ for (const root of childRoots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+async function runHomeScenario(scenario: string) {
+ const root = mkdtempSync(join(tmpdir(), "claudish-run4-child-"));
+ childRoots.push(root);
+ const home = join(root, "home");
+ mkdirSync(home);
+ const scriptPath = join(home, "scenario.ts");
+ const srcDir = resolve(import.meta.dir, "../..");
+ const bootstrap = `
+ import fs from "node:fs";
+ import { homedir } from "node:os";
+ import { resolve, isAbsolute } from "node:path";
+ import { fileURLToPath, pathToFileURL } from "node:url";
+ import { syncBuiltinESMExports } from "node:module";
+ const realExit = process.exit.bind(process);
+ try {
+ const home = process.env.HOME;
+ if (homedir() !== home) throw new Error("child HOME was not honoured");
+ const src = ${JSON.stringify(srcDir)};
+ const load = (name) => import(pathToFileURL(resolve(src, name)).href);
+ const writes = [];
+ const outsideWrites = [];
+ const checkWrite = (value) => {
+ const path = resolve(value instanceof URL ? fileURLToPath(value) : String(value));
+ if (path !== home && !path.startsWith(home + "/")) {
+ outsideWrites.push(path);
+ throw new Error("write outside child HOME: " + path);
+ }
+ writes.push(path);
+ };
+ // Audit before importing production modules, including cached named fs exports.
+ for (const name of ["writeFileSync", "appendFileSync", "mkdirSync", "rmSync", "unlinkSync", "chmodSync", "truncateSync", "createWriteStream"]) {
+ const original = fs[name];
+ fs[name] = function(path, ...args) { checkWrite(path); return original.call(fs, path, ...args); };
+ }
+ for (const name of ["writeFile", "appendFile", "mkdir", "rm", "unlink", "chmod", "truncate"]) {
+ const original = fs.promises[name];
+ fs.promises[name] = async function(path, ...args) { checkWrite(path); return original.call(fs.promises, path, ...args); };
+ }
+ for (const name of ["renameSync", "copyFileSync"]) {
+ const original = fs[name];
+ fs[name] = function(from, to, ...args) {
+ checkWrite(from); checkWrite(to); return original.call(fs, from, to, ...args);
+ };
+ }
+ for (const name of ["writeFile", "appendFile", "mkdir", "rm", "unlink", "chmod", "truncate"]) {
+ const original = fs[name];
+ fs[name] = function(path, ...args) { checkWrite(path); return original.call(fs, path, ...args); };
+ }
+ for (const name of ["rename", "copyFile"]) {
+ const original = fs[name];
+ fs[name] = function(from, to, ...args) {
+ checkWrite(from); checkWrite(to); return original.call(fs, from, to, ...args);
+ };
+ const promiseOriginal = fs.promises[name];
+ fs.promises[name] = async function(from, to, ...args) {
+ checkWrite(from); checkWrite(to); return promiseOriginal.call(fs.promises, from, to, ...args);
+ };
+ }
+ const writesOnOpen = (flags) => typeof flags === "number"
+ ? (flags & (1 | 2 | 64 | 512 | 1024)) !== 0 : /[wa+]/.test(flags ?? "r");
+ for (const name of ["open", "openSync"]) {
+ const original = fs[name];
+ fs[name] = function(path, flags, ...args) {
+ if (writesOnOpen(flags)) checkWrite(path);
+ return original.call(fs, path, flags, ...args);
+ };
+ }
+ const promiseOpen = fs.promises.open;
+ fs.promises.open = async function(path, flags, ...args) {
+ if (writesOnOpen(flags)) checkWrite(path);
+ return promiseOpen.call(fs.promises, path, flags, ...args);
+ };
+ syncBuiltinESMExports();
+ const bunWrite = Bun.write;
+ Bun.write = function(path, ...args) { checkWrite(path); return bunWrite.call(Bun, path, ...args); };
+ let networkRequests = 0;
+ const networkUrls = [];
+ const realFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(async (input, init) => {
+ const url = new URL(input instanceof Request ? input.url : String(input));
+ if (url.protocol !== "http:" && url.protocol !== "https:") return realFetch(input, init);
+ networkRequests++;
+ networkUrls.push(url.href);
+ throw new Error("unexpected child network request");
+ }, { preconnect: () => {} });
+ let keychainOperations = 0;
+ const keychainAbsent = () => { keychainOperations++; return { code: 44, stdout: "", stderr: "test absent" }; };
+ const keychain = await load("providers/keychain.js");
+ keychain.setKeychainTestDeps({
+ platform: () => "darwin", run: keychainAbsent, runAsync: async () => keychainAbsent(),
+ spawnAsync: () => ({ done: Promise.resolve(keychainAbsent()), pid: undefined }),
+ });
+ const core = await load("providers/meta-muse/muse-credentials.js");
+ core.setMuseCoreTestDeps({
+ dir: () => home, now: () => 1_800_000_000_000, readStore: () => null,
+ writeBorrowedCopy: () => { throw new Error("unexpected borrowed write"); },
+ mint: async () => { throw new Error("unexpected mint"); },
+ keychainLogin: async () => ({ kind: "not-allowed" }),
+ });
+ const museKeychain = await load("providers/meta-muse/muse-keychain.js");
+ museKeychain.setMuseKeychainTestDeps({
+ dir: () => home, env: () => ({}), now: () => 1_800_000_000_000,
+ sleep: async () => { throw new Error("unexpected keychain wait"); },
+ pid: () => 424242, isAlive: () => false,
+ presence: async () => ({ kind: "absent" }),
+ startRead: () => ({ done: Promise.resolve({ kind: "absent" }), pid: undefined }),
+ });
+ const { OAUTH_PROVIDERS, hasOAuthCredentials, oauthCredentialWouldQualify } = await load("auth/oauth-registry.js");
+ const credentialPath = (name) => {
+ const file = OAUTH_PROVIDERS[name].credentialFile;
+ if (isAbsolute(file) || file.includes("..")) throw new Error("unsafe credential filename");
+ return resolve(home, ".claudish", file);
+ };
+ const { credentials } = await load("auth/credentials/authority.js");
+ const report = (result) => {
+ console.log(JSON.stringify({ ...result, home, writes, outsideWrites, networkRequests, networkUrls, keychainOperations }));
+ };
+ `;
+ writeFileSync(
+ scriptPath,
+ bootstrap +
+ scenario +
+ "\nrealExit(0);\n} catch (error) { console.error(error); realExit(1); }\n"
+ );
+ const child = Bun.spawn([process.execPath, scriptPath], {
+ cwd: home,
+ env: {
+ ...process.env,
+ HOME: home,
+ TMPDIR: home,
+ TMP: home,
+ TEMP: home,
+ CLAUDISH_DISABLE_KEYCHAIN: "1",
+ CLAUDISH_DISABLE_CATALOG_WARM: "1",
+ },
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ children.push(child);
+ const [stdout, stderr, code] = await Promise.all([
+ new Response(child.stdout).text(),
+ new Response(child.stderr).text(),
+ waitForChild(child),
+ ]);
+ expect({ code, stderr: code === 0 ? "" : stderr }).toEqual({ code: 0, stderr: "" });
+ const lines = stdout.trim().split("\n");
+ expect(lines).toHaveLength(1);
+ const result = JSON.parse(lines[0]!);
+ expect(result.home).toBe(home);
+ expect(result.outsideWrites).toEqual([]);
+ expect(result.writes.every((path: string) => path === home || path.startsWith(home + "/"))).toBe(
+ true
+ );
+ expect(readdirSync(root)).toEqual(["home"]);
+ expect(result.networkRequests).toBe(0);
+ expect(result.networkUrls).toEqual([]);
+ expect(result.keychainOperations).toBe(0);
+ return result;
+}
+
+const savedEnvironment = new Map(
+ ["CLAUDISH_DISABLE_KEYCHAIN", "API_TIMEOUT_MS"].map((k) => [k, process.env[k]])
+);
+const testHome = mkdtempSync(join(tmpdir(), "claudish-run4-"));
+process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+const realFetch = globalThis.fetch;
+const keychain = await import("../../providers/keychain.js");
+const fakeKeychainDeps = {
+ platform: () => "darwin",
+ run: () => ({ code: 44, stdout: "", stderr: "test: absent" }),
+ runAsync: async () => ({ code: 44, stdout: "", stderr: "test: absent" }),
+ spawnAsync: () => ({
+ done: Promise.resolve({ code: 44, stdout: "", stderr: "test: absent" }),
+ pid: undefined,
+ }),
+};
+keychain.setKeychainTestDeps(fakeKeychainDeps);
+beforeEach(() => {
+ keychain.setKeychainTestDeps(fakeKeychainDeps);
+});
+afterEach(() => {
+ keychain.setKeychainTestDeps(null);
+ keychain.invalidateKeychainCache();
+});
+const guardedFetch = Object.assign(
+ (input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => {
+ const url = new URL(input instanceof Request ? input.url : String(input));
+ if (url.hostname === "127.0.0.1" && url.protocol === "http:") return realFetch(input, init);
+ throw new Error(`Unexpected external request: ${url.origin}${url.pathname}`);
+ },
+ { preconnect: () => {} }
+) as typeof fetch;
+globalThis.fetch = guardedFetch;
+const { credentials } = await import("../../auth/credentials/authority.js");
+const { clearSignedArm } = await import("../../auth/credentials/billing-probe.js");
+const core = await import("../../providers/meta-muse/muse-credentials.js");
+const museKeychain = await import("../../providers/meta-muse/muse-keychain.js");
+const roles = await import("../../auth/credentials/prompt-role.js");
+const catalog = await import("../../providers/catalog-client.js");
+const cache = await import("../../providers/all-models-cache.js");
+// Every seam is a complete fake: omitted fields would restore machine defaults.
+beforeEach(() => {
+ core.setMuseCoreTestDeps({
+ dir: () => testHome,
+ now: () => 1_800_000_000_000,
+ readStore: () => null,
+ writeBorrowedCopy: () => {
+ throw new Error("unexpected borrowed-copy write");
+ },
+ mint: async () => {
+ throw new Error("unexpected Muse mint");
+ },
+ keychainLogin: async () => ({ kind: "not-allowed" }),
+ });
+ museKeychain.setMuseKeychainTestDeps({
+ dir: () => testHome,
+ env: () => ({}),
+ now: () => 1_800_000_000_000,
+ sleep: async () => {
+ throw new Error("unexpected Muse Keychain wait");
+ },
+ pid: () => 424242,
+ isAlive: () => false,
+ presence: async () => ({ kind: "absent" }),
+ startRead: () => ({ done: Promise.resolve({ kind: "absent" as const }), pid: undefined }),
+ });
+});
+afterEach(() => {
+ globalThis.fetch = guardedFetch;
+ credentials.invalidate();
+ clearSignedArm();
+ core.setMuseCoreTestDeps(null);
+ core.resetMuseCredentialState();
+ museKeychain.setMuseKeychainTestDeps(null);
+ museKeychain.resetMuseKeychainState();
+ roles._resetCredentialPromptRoleForTest();
+ catalog._resetCatalogClient();
+ cache._clearAllModelsCacheMemo();
+ keychain.invalidateKeychainCache();
+});
+afterAll(() => {
+ globalThis.fetch = realFetch;
+ keychain.setKeychainTestDeps(null);
+ keychain.invalidateKeychainCache();
+ for (const [key, value] of savedEnvironment) {
+ if (value === undefined) delete process.env[key];
+ else process.env[key] = value;
+ }
+ rmSync(testHome, { recursive: true, force: true });
+});
+const { ApiKeyCredentialProvider } = await import("./api-key-credential.js");
+const { CompositeCredentialProvider } = await import("./composite-credential.js");
+const { terminalCredentialError, credentialHttpError } = await import("./credential-error.js");
+const { AnthropicProviderTransport } = await import(
+ "../../providers/transport/anthropic-compat.js"
+);
+const { ComposedHandler } = await import("../../handlers/composed-handler.js");
+const { AnthropicAPIFormat } = await import("../../adapters/anthropic-api-format.js");
+import type { CredentialProvider } from "./types.js";
+
+const envNames = ["KIMI_CODING_API_KEY", "MOONSHOT_API_KEY", "KIMI_API_KEY"];
+let savedEnv: Map<string, string | undefined>;
+let original: ReturnType<typeof credentials.get>;
+beforeEach(() => {
+ savedEnv = new Map(envNames.map((k) => [k, process.env[k]]));
+ for (const key of envNames) delete process.env[key];
+ original = credentials.get("kimi-coding");
+ credentials.invalidate("kimi-coding");
+});
+afterEach(() => {
+ for (const [key, value] of savedEnv) {
+ if (value === undefined) delete process.env[key];
+ else process.env[key] = value;
+ }
+ if (original) credentials.register(original, ["kimi-coding"]);
+ credentials.invalidate("kimi-coding");
+});
+
+// The production B3 child below covers the OAuth login-file gate. These
+// in-process cases use the exact Kimi fallback signal from the contract;
+// terminal, unknown and transient errors must propagate unchanged.
+function installOAuthFailure(error: Error) {
+ const primary: CredentialProvider = {
+ catalogName: "kimi",
+ isAvailable: async () => true,
+ getRequestAuth: async () => {
+ throw error;
+ },
+ };
+ const fallback = new ApiKeyCredentialProvider({
+ catalogName: "kimi-coding",
+ envVar: "KIMI_CODING_API_KEY",
+ authScheme: "bearer",
+ declaredKey: () => process.env.KIMI_CODING_API_KEY,
+ });
+ credentials.register(
+ new CompositeCredentialProvider("kimi-coding", primary, fallback, {
+ fallbackSignal: "OAuth_FALLBACK_TO_API_KEY",
+ }),
+ ["kimi-coding"]
+ );
+ credentials.invalidate("kimi-coding");
+}
+
+const provider = {
+ name: "kimi-coding",
+ baseUrl: "https://api.moonshot.cn",
+ apiPath: "/anthropic/v1/messages",
+ apiKeyEnvVar: "KIMI_CODING_API_KEY",
+ prefixes: ["kc@"],
+ authScheme: "x-api-key" as const,
+};
+
+describe("E1: registered Kimi composite and transport", () => {
+ test("B3: production Kimi file gate and Coding Plan fallback use the child HOME", async () => {
+ const result = await runHomeScenario(`
+ delete process.env.KIMI_CODING_API_KEY;
+ process.env.MOONSHOT_API_KEY = "forbidden-metered-key";
+ process.env.KIMI_API_KEY = "forbidden-metered-key";
+ const path = credentialPath("kimi");
+ fs.mkdirSync(resolve(home, ".claudish"), { recursive: true });
+ fs.writeFileSync(path, JSON.stringify({
+ access_token: "kimi-test-token", refresh_token: "kimi-test-refresh",
+ expires_at: Date.now() + 3_600_000, scope: "", token_type: "Bearer",
+ }));
+ const { KimiOAuth } = await load("auth/kimi-oauth.js");
+ const oauth = KimiOAuth.getInstance();
+ oauth.reloadCredentials();
+ const { makeKimiCodingCredential } = await load("auth/credentials/kimi-credential.js");
+ const { terminalCredentialError, credentialHttpError } = await load("auth/credentials/credential-error.js");
+ const { AnthropicProviderTransport } = await load("providers/transport/anthropic-compat.js");
+ const provider = ${JSON.stringify(provider)};
+ let calls = 0;
+ let failure;
+ oauth.getAccessToken = async () => { calls++; throw failure; };
+ const rows = [];
+ const loginPresent = hasOAuthCredentials("kimi");
+ for (const kind of ["signal-with-key", "signal-without-key", "dead-with-key", "dead-without-key", "unknown", "transient"]) {
+ if (kind.endsWith("without-key")) delete process.env.KIMI_CODING_API_KEY;
+ else process.env.KIMI_CODING_API_KEY = "coding-plan-fixture";
+ if (kind.startsWith("signal")) failure = new Error("OAuth_FALLBACK_TO_API_KEY", {
+ cause: terminalCredentialError("run claudish login kimi", 401),
+ });
+ else if (kind.startsWith("dead")) failure = terminalCredentialError("run claudish login kimi", 401);
+ else if (kind === "unknown") failure = new Error("OAuth unavailable");
+ else failure = credentialHttpError("token host busy", 503);
+ credentials.register(makeKimiCodingCredential(), ["kimi-coding"]);
+ credentials.invalidate("kimi-coding");
+ const before = calls;
+ try {
+ const headers = await new AnthropicProviderTransport(provider, "forbidden-constructor-key").getHeaders();
+ rows.push({ kind, headers, calls: calls - before });
+ } catch (error) {
+ rows.push({ kind, message: error.message, sameError: error === failure, calls: calls - before });
+ }
+ }
+ fs.unlinkSync(path);
+ oauth.reloadCredentials();
+ delete process.env.KIMI_CODING_API_KEY;
+ credentials.register(makeKimiCodingCredential(), ["kimi-coding"]);
+ credentials.invalidate("kimi-coding");
+ const before = calls;
+ let absentMessage;
+ try { await new AnthropicProviderTransport(provider, "forbidden-constructor-key").getHeaders(); }
+ catch (error) { absentMessage = error.message; }
+ report({ loginPresent, rows, absentMessage, absentCalls: calls - before,
+ loginAfterRemoval: hasOAuthCredentials("kimi"), fileExists: fs.existsSync(path) });
+ `);
+ expect(result.loginPresent).toBe(true);
+ expect(result.rows[0].headers.Authorization).toBe("Bearer coding-plan-fixture");
+ expect(result.rows[0].headers["x-api-key"]).toBeUndefined();
+ expect(result.rows.every((row: { calls: number }) => row.calls === 1)).toBe(true);
+ expect(result.rows[1]).toMatchObject({ message: "run claudish login kimi", sameError: false });
+ for (const row of result.rows.slice(2, 4)) {
+ expect(row).toMatchObject({ message: "run claudish login kimi", sameError: true });
+ }
+ expect(result.rows[4]).toMatchObject({ message: "OAuth unavailable", sameError: true });
+ expect(result.rows[5]).toMatchObject({ message: "token host busy", sameError: true });
+ for (const row of result.rows.slice(1)) expect(row.headers).toBeUndefined();
+ expect(JSON.stringify(result.rows.slice(1))).not.toContain("coding-plan-fixture");
+ expect(JSON.stringify(result.rows)).not.toContain("forbidden-");
+ expect(result.absentMessage).toMatch(/claudish login kimi/);
+ expect(result.absentCalls).toBe(0);
+ expect(result.loginAfterRemoval).toBe(false);
+ expect(result.fileExists).toBe(false);
+ });
+ test("declared OAuth fallback signal may sign with the same-subscription Coding Plan key", async () => {
+ process.env.KIMI_CODING_API_KEY = "coding-plan-fixture";
+ process.env.MOONSHOT_API_KEY = "forbidden-metered-key";
+ process.env.KIMI_API_KEY = "forbidden-metered-key";
+ installOAuthFailure(
+ new Error("OAuth_FALLBACK_TO_API_KEY", {
+ cause: terminalCredentialError("run `claudish login kimi`", 401),
+ })
+ );
+ const transport = new AnthropicProviderTransport(provider, "forbidden-constructor-key");
+ const headers = await transport.getHeaders();
+ expect(headers.Authorization).toBe("Bearer coding-plan-fixture");
+ expect(headers["x-api-key"]).toBeUndefined();
+ expect(JSON.stringify(headers)).not.toContain("forbidden-metered-key");
+ expect(JSON.stringify(headers)).not.toContain("forbidden-constructor-key");
+ });
+ test.each(["MOONSHOT_API_KEY", "KIMI_API_KEY"])(
+ "dead OAuth cannot sign with metered %s",
+ async (envName) => {
+ process.env[envName] = "forbidden-metered-key";
+ installOAuthFailure(terminalCredentialError("run `claudish login kimi`", 401));
+ await expect(
+ credentials.getRequestAuth("kimi-coding", { model: "kimi-fixture" })
+ ).rejects.toThrow(/claudish login kimi/);
+ await expect(
+ new AnthropicProviderTransport(provider, "forbidden-constructor-key").getHeaders()
+ ).rejects.toThrow(/claudish login kimi/);
+ }
+ );
+ test.each([
+ terminalCredentialError("run claudish login kimi", 401),
+ new Error("OAuth unavailable"),
+ credentialHttpError("token host busy", 503),
+ ])("non-signal %s propagates even with Coding Plan key", async (error) => {
+ process.env.KIMI_CODING_API_KEY = "coding-plan-fixture";
+ installOAuthFailure(error);
+ await expect(
+ new AnthropicProviderTransport(provider, "forbidden-constructor-key").getHeaders()
+ ).rejects.toBe(error);
+ });
+
+ test.each([false, true])(
+ "Kimi handler returns auth verdict (identified dead=%s), with zero inference requests",
+ async (dead) => {
+ process.env.MOONSHOT_API_KEY = "forbidden-metered-key";
+ process.env.KIMI_API_KEY = "forbidden-metered-key";
+ installOAuthFailure(
+ dead
+ ? terminalCredentialError("run `claudish login kimi`", 401)
+ : new Error("OAuth unavailable")
+ );
+ let requests = 0;
+ globalThis.fetch = Object.assign(
+ async () => {
+ requests++;
+ throw new Error("no inference expected");
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+ const handler = new ComposedHandler(
+ new AnthropicProviderTransport(provider, "forbidden-constructor-key"),
+ "kimi-fixture",
+ "kimi-fixture",
+ 0,
+ {
+ adapter: new AnthropicAPIFormat("kimi-fixture"),
+ catalogCachePath: join(testHome, "catalog.json"),
+ }
+ );
+ try {
+ const app = new Hono();
+ app.post("/", (c) =>
+ handler.handle(c, {
+ messages: [{ role: "user", content: "PONG" }],
+ max_tokens: 64,
+ stream: false,
+ })
+ );
+ const response = await app.request("http://localhost/", { method: "POST" });
+ expect(response.status).toBe(dead ? 400 : 503);
+ expect(response.headers.get("x-claudish-auth-verdict")).toBe(
+ dead ? "terminal" : "transient"
+ );
+ expect(await response.text()).toContain(dead ? "login kimi" : "OAuth unavailable");
+ expect(requests).toBe(0);
+ } finally {
+ await handler.shutdown();
+ }
+ }
+ );
+});
+
+describe("E1: declared composite fallback signal", () => {
+ test("only exact fallbackSignal advances; other errors propagate unchanged", async () => {
+ let error = new Error("OAuth_FALLBACK_TO_API_KEY");
+ let fallbackCalls = 0;
+ const primary: CredentialProvider = {
+ catalogName: "primary",
+ isAvailable: async () => true,
+ getRequestAuth: async () => {
+ throw error;
+ },
+ };
+ const fallback: CredentialProvider = {
+ catalogName: "fallback",
+ isAvailable: async () => true,
+ getRequestAuth: async () => {
+ fallbackCalls++;
+ return { arm: "api-key", headers: { "x-api-key": "coding-plan-fixture" } };
+ },
+ };
+ const composite = new CompositeCredentialProvider("kimi-coding", primary, fallback, {
+ fallbackSignal: "OAuth_FALLBACK_TO_API_KEY",
+ });
+ expect((await composite.getRequestAuth({ model: "kimi-fixture" })).headers["x-api-key"]).toBe(
+ "coding-plan-fixture"
+ );
+ expect(fallbackCalls).toBe(1);
+ for (const message of [
+ "OAuth_FALLBACK_TO_API_KEY extra",
+ "OAuth unavailable",
+ "token host busy",
+ ]) {
+ error = new Error(message);
+ await expect(composite.getRequestAuth({ model: "kimi-fixture" })).rejects.toBe(error);
+ expect(fallbackCalls).toBe(1);
+ }
+ const strict = new CompositeCredentialProvider("openai-codex", primary, fallback);
+ error = new Error("OAuth_FALLBACK_TO_API_KEY");
+ await expect(strict.getRequestAuth({ model: "codex-fixture" })).rejects.toBe(error);
+ expect(fallbackCalls).toBe(1);
+ });
+});
diff --git a/packages/cli/src/auth/credentials/muse-code-credential.test.ts b/packages/cli/src/auth/credentials/muse-code-credential.test.ts
new file mode 100644
index 00000000..138d46da
--- /dev/null
+++ b/packages/cli/src/auth/credentials/muse-code-credential.test.ts
@@ -0,0 +1,216 @@
+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 savedEnv: Map<string, string | undefined>;
+let savedFetch: typeof fetch;
+let core: typeof import("../../providers/meta-muse/muse-credentials.js");
+let store: typeof import("../../providers/meta-muse/muse-store.js");
+let mint: typeof import("../../providers/meta-muse/muse-mint.js");
+let generic: typeof import("../../providers/keychain.js");
+let kc: typeof import("../../providers/meta-muse/muse-keychain.js");
+let roles: typeof import("./prompt-role.js");
+let authority: typeof import("./authority.js");
+let billing: typeof import("./billing-probe.js");
+let provider: import("./muse-code-credential.js").MuseCodeCredentialProvider;
+let previous: import("./types.js").CredentialProvider;
+let now: number;
+let calls: string[];
+let reads: number;
+let failure: Error | undefined;
+let body: Record<string, unknown>;
+const TOKEN = "dca:TESTTOKEN0001";
+const KEY = "LLM|TESTKEY0001";
+// §8 capture. Credential values are inert ASCII placeholders; tests mutate flags and keys.
+function capturedMint(): Record<string, unknown> {
+ return {
+ api_key: KEY,
+ base_url: "https://api.meta.ai/v1",
+ has_payment_method: true,
+ require_payment: false,
+ is_subs_active: true,
+ can_subscribe: false,
+ show_subs_upsell: true,
+ user_full_name: "TEST USER",
+ user_email: "[email protected]",
+ user_avatar_url: null,
+ payment_method: "TESTPAYMENT",
+ action_url: null,
+ subs_tier_id: "<tier-id>",
+ subs_tier_name: "Muse Code Power Usage",
+ is_subs_upgrade_available: true,
+ subs_usage: {
+ window: { used_percent: 1, window_duration_mins: 300, resets_at: 1792136182 },
+ weekly: { used_percent: 0, resets_at: 1792368000 },
+ tier: "<tier-id>",
+ },
+ };
+}
+beforeEach(async () => {
+ savedEnv = new Map(["CLAUDISH_DISABLE_KEYCHAIN", "META_API_KEY"].map((k) => [k, process.env[k]]));
+ home = mkdtempSync(join(tmpdir(), "muse-credential-test-"));
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ process.env.META_API_KEY = "metered-key-fixture-never-send";
+ savedFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(
+ async () => {
+ throw new Error("unexpected network request");
+ },
+ { 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");
+ mint = await import("../../providers/meta-muse/muse-mint.js");
+ core = await import("../../providers/meta-muse/muse-credentials.js");
+ roles._resetCredentialPromptRoleForTest();
+ core.resetMuseCredentialState();
+ now = 1000000;
+ calls = [];
+ reads = 0;
+ failure = undefined;
+ body = capturedMint();
+ core.setMuseCoreTestDeps({
+ readStore: (kind) => store.readMuseStore(kind, home),
+ writeBorrowedCopy: (token, tier) =>
+ store.writeBorrowedCopy(token, tier, home, () => new Date(1000000)),
+ dir: () => home,
+ now: () => now,
+ mint: async (token) => {
+ calls.push(token);
+ if (failure) throw failure;
+ return mint.interpretMint(body);
+ },
+ keychainLogin: async () => {
+ reads++;
+ return { kind: "not-allowed" };
+ },
+ });
+ authority = await import("./authority.js");
+ billing = await import("./billing-probe.js");
+ const old = authority.credentials.get("meta-muse-code");
+ if (!old) throw new Error("default Muse credential registration missing");
+ previous = old;
+ const { MuseCodeCredentialProvider } = await import("./muse-code-credential.js");
+ provider = new MuseCodeCredentialProvider();
+ authority.credentials.register(provider, ["meta-muse-code"]);
+ billing.clearSignedArm();
+});
+afterEach(() => {
+ authority.credentials.register(previous, ["meta-muse-code"]);
+ authority.credentials.invalidate("meta-muse-code");
+ billing.clearSignedArm();
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(null);
+ kc.resetMuseKeychainState();
+ kc.setMuseKeychainTestDeps(null);
+ generic.invalidateKeychainCache();
+ generic.setKeychainTestDeps(null);
+ roles._resetCredentialPromptRoleForTest();
+ globalThis.fetch = savedFetch;
+ for (const [key, value] of savedEnv) {
+ if (value === undefined) delete process.env[key];
+ else process.env[key] = value;
+ }
+ rmSync(home, { recursive: true, force: true });
+});
+function sign() {
+ return authority.credentials.getRequestAuth("meta-muse-code", { model: "muse-spark-1.3" });
+}
+
+describe("A1/C2: the real Muse credential signs only confirmed process keys", () => {
+ test("authority registration returns an OAuth artifact with the minted bearer, ignoring META_API_KEY", async () => {
+ store.writeMuseStore("own-login", { access_token: TOKEN }, home);
+ expect(provider.catalogName).toBe("meta-muse-code");
+ expect(authority.credentials.get("meta-muse-code")).toBe(provider);
+ const artifact = await sign();
+ expect(artifact.arm).toBe("oauth");
+ expect(artifact.headers.Authorization).toBe(`Bearer ${KEY}`);
+ expect(Object.values(artifact.headers)).not.toContain(`Bearer ${process.env.META_API_KEY}`);
+ expect(calls).toEqual([TOKEN]);
+ expect(reads).toBe(0);
+ expect(await provider.isAvailable()).toBe(true);
+ expect((await provider.describeReadiness()).readiness).toBe("present");
+ expect((await sign()).headers.Authorization).toBe(`Bearer ${KEY}`);
+ expect(calls).toEqual([TOKEN]);
+ });
+ test("META_API_KEY alone cannot make Muse ready or sign; error names claudish login muse", async () => {
+ expect(await provider.isAvailable()).toBe(false);
+ expect((await provider.describeReadiness()).readiness).toBe("absent");
+ await expect(sign()).rejects.toThrow("claudish login muse");
+ expect(calls).toEqual([]);
+ expect(reads).toBe(0);
+ expect(core.currentMuseState()).toBeUndefined();
+ });
+ for (const flags of [
+ { is_subs_active: false, require_payment: false },
+ { is_subs_active: true, require_payment: true },
+ { is_subs_active: undefined, require_payment: false },
+ { is_subs_active: true, require_payment: undefined },
+ ]) {
+ test(`readiness cannot bypass entitlement ${JSON.stringify(flags)}`, async () => {
+ store.writeMuseStore("own-login", { access_token: TOKEN }, home);
+ Object.assign(body, flags);
+ await provider.describeReadiness();
+ await provider.isAvailable();
+ await expect(sign()).rejects.toThrow("https://accountscenter.meta.com/muse_code/?ep=no_payg");
+ expect(calls.length).toBeGreaterThan(0);
+ expect(reads).toBe(0);
+ expect(core.currentMuseState()).toBeUndefined();
+ expect(store.readMuseStore("own-login", home)?.access_token).toBe(TOKEN);
+ });
+ }
+ test("C2: exact TTL signs cached key; expired confirmation must remint before signing", async () => {
+ store.writeMuseStore("own-login", { access_token: TOKEN }, home);
+ expect((await sign()).headers.Authorization).toBe(`Bearer ${KEY}`);
+ now += 30 * 60_000;
+ expect((await sign()).headers.Authorization).toBe(`Bearer ${KEY}`);
+ expect(calls).toEqual([TOKEN]);
+ now++;
+ failure = new mint.MuseMintTransientError(503);
+ await expect(sign()).rejects.toBe(failure);
+ expect(calls).toEqual([TOKEN, TOKEN]);
+ failure = undefined;
+ body.api_key = "LLM|TESTKEY0002";
+ expect((await sign()).headers.Authorization).toBe(`Bearer ${body.api_key}`);
+ expect(calls).toEqual([TOKEN, TOKEN, TOKEN]);
+ });
+ test("C2: rejected key cannot sign after a terminal remint", async () => {
+ store.writeMuseStore("own-login", { access_token: TOKEN }, home);
+ expect((await sign()).headers.Authorization).toBe(`Bearer ${KEY}`);
+ failure = new mint.MuseLoginExpiredError(401);
+ await expect(core.forceRefreshMuseApiKey({ rejectedKey: KEY, prompt: false })).rejects.toThrow(
+ "login"
+ );
+ await expect(sign()).rejects.toThrow("login");
+ expect(calls.length).toBeGreaterThan(1);
+ expect(reads).toBe(0);
+ });
+});
diff --git a/packages/cli/src/auth/credentials/prompt-role.test.ts b/packages/cli/src/auth/credentials/prompt-role.test.ts
new file mode 100644
index 00000000..f7700c02
--- /dev/null
+++ b/packages/cli/src/auth/credentials/prompt-role.test.ts
@@ -0,0 +1,189 @@
+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");
+ });
+ }
+ 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: pane/team child with real PTY facts never gains prompt rights", async () => {
+ const pane = await import("../../pane/child-env.js");
+ expect(pane.PANE_MARKER_VARS).toContain("CLAUDISH_PANE_CHILD");
+ const env = { CLAUDISH_PANE_CHILD: "1" };
+ expect(pane.isPaneChild(env)).toBe(true);
+ 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", () => {});
+});
diff --git a/packages/cli/src/auth/meta-muse-oauth.test.ts b/packages/cli/src/auth/meta-muse-oauth.test.ts
new file mode 100644
index 00000000..48d3edf2
--- /dev/null
+++ b/packages/cli/src/auth/meta-muse-oauth.test.ts
@@ -0,0 +1,139 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtemp, readdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { MuseOAuthDeps } from "./meta-muse-oauth.js";
+
+// Each OAuth instance receives this directory through its complete deps object.
+let home: string;
+let priorGuard: string | undefined;
+let oauth: typeof import("./meta-muse-oauth.js");
+
+beforeEach(async () => {
+ priorGuard = process.env.CLAUDISH_DISABLE_KEYCHAIN;
+ home = await mkdtemp(join(tmpdir(), "muse-oauth-test-"));
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ oauth = await import("./meta-muse-oauth.js");
+});
+
+afterEach(async () => {
+ if (priorGuard === undefined) delete process.env.CLAUDISH_DISABLE_KEYCHAIN;
+ else process.env.CLAUDISH_DISABLE_KEYCHAIN = priorGuard;
+ await rm(home, { recursive: true, force: true });
+});
+
+// wire-capture.md §8 shape; the sent device code is an ASCII test placeholder.
+// There is no token-success fixture.
+const DEVICE = {
+ device_code: "TESTDEVICECODE0001",
+ user_code: "XXXX-XXXX",
+ verification_uri: "https://auth.meta.com/oauth/device/",
+ verification_uri_complete: "https://auth.meta.com/oauth/device/?code=XXXX-XXXX",
+ expires_in: 600,
+ interval: 5,
+};
+const AUTHORIZATION = "https://auth.meta.com/oidc/device/authorization/";
+const TOKEN = "https://auth.meta.com/oidc/device/token/";
+
+function deviceFlow(slowDown: boolean) {
+ let now = 0;
+ let polls = 0;
+ let mints = 0;
+ const requests: { request: Request; at: number }[] = [];
+ const sleeps: number[] = [];
+ const opened: string[] = [];
+ const printed: string[] = [];
+ const deps: MuseOAuthDeps = {
+ fetch: async (...args) => {
+ const request = new Request(args[0], args[1]);
+ requests.push({ request, at: now });
+ if (request.url === AUTHORIZATION) return Response.json(DEVICE);
+ if (request.url !== TOKEN) throw new Error(`Unexpected OAuth URL: ${request.url}`);
+ if (++polls > 130) throw new Error("Polling continued beyond device expiry");
+ // Captured errors, not an invented successful token body.
+ return Response.json(
+ { error: slowDown && polls === 2 ? "slow_down" : "authorization_pending" },
+ { status: 400 }
+ );
+ },
+ sleep: async (ms) => {
+ sleeps.push(ms);
+ now += ms;
+ },
+ now: () => now,
+ openBrowser: async (url) => {
+ opened.push(url);
+ },
+ print: (line) => {
+ printed.push(line);
+ },
+ mint: async () => {
+ mints++;
+ throw new Error("Pending authorization must not mint");
+ },
+ dir: () => home,
+ };
+ return { deps, requests, sleeps, opened, printed, mintCount: () => mints, now: () => now };
+}
+
+describe("O1 — captured device authorization, pending and backoff", () => {
+ test("uses the captured device client id", () => {
+ expect(oauth.MUSE_OIDC_CLIENT_ID).toBe("1031625952748946");
+ });
+
+ for (const slowDown of [false, true]) {
+ test(`posts exact device forms, displays/opens verification and stops at expiry (slow_down=${slowDown})`, async () => {
+ const io = deviceFlow(slowDown);
+ let failure: unknown;
+ try {
+ await new oauth.MuseCodeOAuth(io.deps).login();
+ } catch (error) {
+ failure = error;
+ }
+ expect(failure).toBeInstanceOf(Error);
+ expect((failure as Error).message).toMatch(/expir/i);
+
+ const authorization = io.requests.filter(({ request }) => request.url === AUTHORIZATION);
+ const polls = io.requests.filter(({ request }) => request.url === TOKEN);
+ expect(authorization).toHaveLength(1);
+ expect(io.requests).toHaveLength(1 + polls.length);
+ expect(polls.length).toBeGreaterThan(3);
+ expect(authorization[0]!.request.method).toBe("POST");
+ expect(authorization[0]!.request.headers.get("content-type")).toContain(
+ "application/x-www-form-urlencoded"
+ );
+ expect([...new URLSearchParams(await authorization[0]!.request.text()).entries()]).toEqual([
+ ["client_id", "1031625952748946"],
+ ]);
+ for (const { request } of polls) {
+ expect(request.method).toBe("POST");
+ expect(request.headers.get("content-type")).toContain("application/x-www-form-urlencoded");
+ const form = new URLSearchParams(await request.text());
+ expect(Object.fromEntries(form)).toEqual({
+ grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+ device_code: DEVICE.device_code,
+ client_id: "1031625952748946",
+ });
+ expect([...form.keys()]).toHaveLength(3);
+ expect(form.has("scope")).toBe(false);
+ }
+ expect(io.opened).toEqual([DEVICE.verification_uri_complete]);
+ expect(io.printed.join("\n")).toContain(DEVICE.user_code);
+ expect(io.printed.join("\n")).toContain(DEVICE.verification_uri);
+ // The interval after pending is 5 s; after the second poll's slow_down,
+ // each remaining poll must wait 5 s more. Also detects ignored backoff.
+ for (let i = 1; i < polls.length; i++) {
+ expect(polls[i]!.at - polls[i - 1]!.at).toBe(slowDown && i >= 2 ? 10_000 : 5_000);
+ }
+ expect(io.sleeps.length).toBeGreaterThan(0);
+ expect(polls.every(({ at }) => at < DEVICE.expires_in * 1000)).toBe(true);
+ expect(io.now()).toBeGreaterThanOrEqual(DEVICE.expires_in * 1000);
+ expect(io.mintCount()).toBe(0);
+ expect(await readdir(home)).toEqual([]);
+ });
+ }
+});
+
+test.skip("BLOCKED O2 inactive/unconfirmed login must not replace stores: no captured device-token success body; login() is the only public save boundary", () => {});
+test.skip("BLOCKED O2 transient mint must preserve existing stores: no captured device-token success body; no public token-to-mint/save seam", () => {});
+test.skip("BLOCKED O1 successful device-token decoding: wire-capture.md §8 explicitly did not capture approval success", () => {});
diff --git a/packages/cli/src/handlers/composed-handler.muse-code.test.ts b/packages/cli/src/handlers/composed-handler.muse-code.test.ts
new file mode 100644
index 00000000..edfa86e0
--- /dev/null
+++ b/packages/cli/src/handlers/composed-handler.muse-code.test.ts
@@ -0,0 +1,401 @@
+import { afterAll, afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Hono } from "hono";
+
+const savedEnvironment = new Map(
+ ["CLAUDISH_DISABLE_KEYCHAIN", "API_TIMEOUT_MS"].map((k) => [k, process.env[k]])
+);
+const testHome = mkdtempSync(join(tmpdir(), "claudish-run4-"));
+process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+const realFetch = globalThis.fetch;
+const keychain = await import("../providers/keychain.js");
+const fakeKeychainDeps = {
+ platform: () => "darwin",
+ run: () => ({ code: 44, stdout: "", stderr: "test: absent" }),
+ runAsync: async () => ({ code: 44, stdout: "", stderr: "test: absent" }),
+ spawnAsync: () => ({
+ done: Promise.resolve({ code: 44, stdout: "", stderr: "test: absent" }),
+ pid: undefined,
+ }),
+};
+keychain.setKeychainTestDeps(fakeKeychainDeps);
+beforeEach(() => {
+ keychain.setKeychainTestDeps(fakeKeychainDeps);
+});
+afterEach(() => {
+ keychain.setKeychainTestDeps(null);
+ keychain.invalidateKeychainCache();
+});
+const guardedFetch = Object.assign(
+ (input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => {
+ const url = new URL(input instanceof Request ? input.url : String(input));
+ if (url.hostname === "127.0.0.1" && url.protocol === "http:") return realFetch(input, init);
+ throw new Error(`Unexpected external request: ${url.origin}${url.pathname}`);
+ },
+ { preconnect: () => {} }
+) as typeof fetch;
+globalThis.fetch = guardedFetch;
+const { credentials } = await import("../auth/credentials/authority.js");
+const { clearSignedArm } = await import("../auth/credentials/billing-probe.js");
+const core = await import("../providers/meta-muse/muse-credentials.js");
+const museKeychain = await import("../providers/meta-muse/muse-keychain.js");
+const roles = await import("../auth/credentials/prompt-role.js");
+const catalog = await import("../providers/catalog-client.js");
+const cache = await import("../providers/all-models-cache.js");
+// Every seam is a complete fake: omitted fields would restore machine defaults.
+beforeEach(() => {
+ core.setMuseCoreTestDeps({
+ dir: () => testHome,
+ now: () => 1_800_000_000_000,
+ readStore: () => null,
+ writeBorrowedCopy: () => {
+ throw new Error("unexpected borrowed-copy write");
+ },
+ mint: async () => {
+ throw new Error("unexpected Muse mint");
+ },
+ keychainLogin: async () => ({ kind: "not-allowed" }),
+ });
+ museKeychain.setMuseKeychainTestDeps({
+ dir: () => testHome,
+ env: () => ({}),
+ now: () => 1_800_000_000_000,
+ sleep: async () => {
+ throw new Error("unexpected Muse Keychain wait");
+ },
+ pid: () => 424242,
+ isAlive: () => false,
+ presence: async () => ({ kind: "absent" }),
+ startRead: () => ({ done: Promise.resolve({ kind: "absent" as const }), pid: undefined }),
+ });
+});
+afterEach(() => {
+ globalThis.fetch = guardedFetch;
+ credentials.invalidate();
+ clearSignedArm();
+ core.setMuseCoreTestDeps(null);
+ core.resetMuseCredentialState();
+ museKeychain.setMuseKeychainTestDeps(null);
+ museKeychain.resetMuseKeychainState();
+ roles._resetCredentialPromptRoleForTest();
+ catalog._resetCatalogClient();
+ cache._clearAllModelsCacheMemo();
+ keychain.invalidateKeychainCache();
+});
+afterAll(() => {
+ globalThis.fetch = realFetch;
+ keychain.setKeychainTestDeps(null);
+ keychain.invalidateKeychainCache();
+ for (const [key, value] of savedEnvironment) {
+ if (value === undefined) delete process.env[key];
+ else process.env[key] = value;
+ }
+ rmSync(testHome, { recursive: true, force: true });
+});
+import type { ProviderTransport } from "../providers/transport/types.js";
+const { ComposedHandler } = await import("./composed-handler.js");
+const { DefaultAPIFormat } = await import("../adapters/base-api-format.js");
+const { terminalCredentialError, credentialHttpError } = await import(
+ "../auth/credentials/credential-error.js"
+);
+const recovery = await import("../recovery/settings.js");
+const recoveryTime = await import("../recovery/clock.js");
+const episodes = await import("../recovery/coordinator.js");
+const stores = await import("../providers/meta-muse/muse-store.js");
+
+const parameterComplaint =
+ "reasoning_effort 'none' is not supported for model 'muse-spark-1.3'. Supported values: [minimal, low, medium, high, xhigh, max]";
+
+// Parameter rejection is an adapter outcome, not a fabricated Meta response.
+class RecoveringAdapter extends DefaultAPIFormat {
+ recoverFromRejection(payload: any, errorText: string) {
+ if (errorText !== parameterComplaint) return null;
+ return { payload: { ...payload, reasoning_effort: "minimal" }, note: "test adapter recovery" };
+ }
+}
+const sites = [
+ "refreshAuth",
+ "getHeaders",
+ "primary fetch",
+ "parameter-recovery re-fetch",
+ "forceRefreshAuth",
+] as const;
+type Site = (typeof sites)[number];
+const rejection = JSON.stringify({ error: { type: "invalid_api_key", message: "Unauthorized" } }); // capture §7
+const payload = {
+ model: "muse-spark-1.3",
+ messages: [{ role: "user", content: "PONG" }],
+ max_tokens: 64,
+ stream: false,
+};
+let handler: InstanceType<typeof ComposedHandler> | undefined;
+let server: ReturnType<typeof Bun.serve> | undefined;
+let previous: ReturnType<typeof credentials.get>;
+
+beforeEach(() => {
+ previous = credentials.get("meta-muse-code");
+ credentials.register(
+ {
+ catalogName: "meta-muse-code",
+ isAvailable: async () => true,
+ getRequestAuth: async () => ({
+ arm: "oauth",
+ headers: { Authorization: "Bearer LLM|TESTKEY0001" },
+ }),
+ },
+ ["meta-muse-code"]
+ );
+ core.resetMuseCredentialState();
+ roles.setCredentialPromptRole("never");
+ recovery.setRecoveryFlagOverrides({ recovery: true, recoveryUi: false });
+ // Advance only the recovery scheduler. No waits or real service requests.
+ let elapsed = 0;
+ recoveryTime.setRecoveryClock({
+ now: () => Date.now() + elapsed,
+ setTimeout: (fn, ms) =>
+ setTimeout(() => {
+ elapsed += ms;
+ fn();
+ }, 0),
+ clearTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
+ });
+ core.setMuseCoreTestDeps({
+ dir: () => testHome,
+ now: () => 1_800_000_000_000,
+ mint: async () => {
+ throw new Error("unexpected mint in fake-transport test");
+ },
+ readStore: (kind) => stores.readMuseStore(kind, testHome),
+ writeBorrowedCopy: (token, tier) =>
+ stores.writeBorrowedCopy(token, tier, testHome, () => new Date(1_800_000_000_000)),
+ keychainLogin: async () => ({ kind: "not-allowed" }),
+ });
+ stores.writeMuseStore("own-login", { access_token: "dca:TESTTOKEN0001" }, testHome);
+ stores.writeBorrowedCopy(
+ "dca:TESTTOKEN0001",
+ "Muse Code Power Usage",
+ testHome,
+ () => new Date(1_800_000_000_000)
+ );
+});
+afterEach(async () => {
+ if (handler) await handler.shutdown();
+ handler = undefined;
+ if (server) await server.stop(true);
+ server = undefined;
+ if (previous) credentials.register(previous, ["meta-muse-code"]);
+ credentials.invalidate("meta-muse-code");
+ episodes.closeAllEpisodes("shutdown");
+ recovery.resetRecoveryFlagOverrides();
+ recoveryTime.resetRecoveryClock();
+});
+
+async function refusedFetch() {
+ const closed = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => new Response("unused") });
+ const url = `http://127.0.0.1:${closed.port}/token`;
+ await closed.stop(true);
+ try {
+ await realFetch(url);
+ } catch (error) {
+ return error;
+ }
+ throw new Error("refused-fetch fixture unexpectedly succeeded");
+}
+
+async function exercise(
+ site: Site,
+ failures: unknown[],
+ retryStatus = 401,
+ providerName = "meta-muse-code",
+ primaryStatus = 403
+) {
+ let siteCalls = 0;
+ let fetchCalls = 0;
+ let forceCalls = 0;
+ const seen: Array<{ url: string; authorization: string | null }> = [];
+ server = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => new Response("unused") });
+ const endpoint = `http://127.0.0.1:${server.port}/v1/responses`;
+ const hit = () => {
+ const index = siteCalls++;
+ if (index < failures.length) throw failures[index];
+ };
+ const transport: ProviderTransport = {
+ name: providerName,
+ displayName: providerName,
+ streamFormat: "openai-sse",
+ getEndpoint: () => endpoint,
+ refreshAuth: async () => {
+ if (site === "refreshAuth") hit();
+ },
+ getHeaders: async () => {
+ if (site === "getHeaders") hit();
+ return { Authorization: forceCalls ? "Bearer LLM|TESTKEY0002" : "Bearer LLM|TESTKEY0001" };
+ },
+ forceRefreshAuth: async () => {
+ forceCalls++;
+ if (site === "forceRefreshAuth") hit();
+ },
+ classifyTerminalError: (status) => providerName === "antigravity" && status === 429,
+ };
+ globalThis.fetch = Object.assign(
+ async (input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => {
+ const request = new Request(input, init);
+ // Fail closed on incidental discovery or telemetry: it cannot reach a service.
+ if (request.url !== endpoint) throw new Error(`unexpected URL ${request.url}`);
+ fetchCalls++;
+ seen.push({ url: request.url, authorization: request.headers.get("authorization") });
+ if (site === "primary fetch") hit();
+ if (site === "parameter-recovery re-fetch") {
+ if (fetchCalls === 1) return new Response(parameterComplaint, { status: 400 });
+ hit();
+ }
+ // Negative fixtures mutate only the status of capture §7's rejection body.
+ if (site === "forceRefreshAuth")
+ return new Response(rejection, { status: fetchCalls === 1 ? 401 : retryStatus });
+ return new Response(rejection, { status: primaryStatus });
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+ const own = readFileSync(stores.museStorePath("own-login", testHome), "utf8");
+ const borrowed = readFileSync(stores.museStorePath("borrowed-copy", testHome), "utf8");
+ handler = new ComposedHandler(transport, "muse-spark-1.3", "muse-spark-1.3", 0, {
+ adapter: new RecoveringAdapter("muse-spark-1.3"),
+ isInteractive: false,
+ invocationMode: "explicit-model",
+ catalogCachePath: join(testHome, "empty-catalog.json"),
+ });
+ const app = new Hono();
+ app.post("/v1/messages", (c) => handler!.handle(c, payload));
+ const response = await app.request("http://localhost/v1/messages", {
+ method: "POST",
+ body: JSON.stringify(payload),
+ headers: { "content-type": "application/json" },
+ });
+ const result = {
+ status: response.status,
+ verdict: response.headers.get("x-claudish-auth-verdict"),
+ body: await response.text(),
+ siteCalls,
+ fetchCalls,
+ forceCalls,
+ seen,
+ };
+ expect(readFileSync(stores.museStorePath("own-login", testHome), "utf8")).toBe(own);
+ expect(readFileSync(stores.museStorePath("borrowed-copy", testHome), "utf8")).toBe(borrowed);
+ expect(seen.every((request) => request.url === endpoint)).toBe(true);
+ return result;
+}
+
+const failures = [
+ {
+ name: "dead login",
+ make: () => terminalCredentialError("run `claudish login muse`", 401),
+ status: 400,
+ verdict: "terminal",
+ message: "login muse",
+ },
+ {
+ name: "token host 429",
+ make: () => credentialHttpError("key service unavailable (429)", 429),
+ status: 429,
+ verdict: "transient",
+ message: "429",
+ },
+ {
+ name: "token host 503",
+ make: () => credentialHttpError("key service unavailable (503)", 503),
+ status: 503,
+ verdict: "transient",
+ message: "503",
+ },
+ {
+ name: "unknown subscription error",
+ make: () => new Error("OAuth unavailable"),
+ status: 503,
+ verdict: "transient",
+ message: "OAuth unavailable",
+ },
+];
+describe("H1: all five auth failure sites", () => {
+ for (const site of sites)
+ for (const failure of failures) {
+ test(`${site}: ${failure.name}`, async () => {
+ const result = await exercise(site, [failure.make()]);
+ expect(result.siteCalls).toBe(1);
+ expect(result.status).toBe(failure.status);
+ expect(result.verdict).toBe(failure.verdict);
+ expect(result.body).toContain(failure.message);
+ if (site === "refreshAuth" || site === "getHeaders") expect(result.fetchCalls).toBe(0);
+ else expect(result.fetchCalls).toBe(site === "parameter-recovery re-fetch" ? 2 : 1);
+ });
+ }
+});
+
+describe("H2: real connection recovery reclassifies its next outcome", () => {
+ for (const site of sites)
+ for (const wrapped of [false, true])
+ for (const failure of failures) {
+ test(`${site}: ${wrapped ? "wrapped" : "raw"} refused fetch then ${failure.name}`, async () => {
+ const raw = await refusedFetch();
+ const connection = wrapped ? new Error("token host unreachable", { cause: raw }) : raw;
+ const result = await exercise(site, [connection, failure.make()]);
+ expect(result.siteCalls).toBe(2);
+ expect(result.status).toBe(failure.status);
+ expect(result.verdict).toBe(failure.verdict);
+ expect(result.body).toContain(failure.message);
+ });
+ }
+ for (const site of sites)
+ test(`${site}: recovery returning fresh-key HTTP 403 is terminal`, async () => {
+ const result = await exercise(site, [await refusedFetch()]);
+ expect(result.siteCalls).toBeGreaterThanOrEqual(2);
+ expect(result.status).toBe(400);
+ expect(result.verdict).toBe("terminal");
+ expect(result.body).toMatch(/login/);
+ });
+});
+
+describe("H3: post-refresh HTTP rejection and allowance", () => {
+ for (const status of [401, 403])
+ test(`fresh-key HTTP ${status} requires login`, async () => {
+ const result = await exercise("forceRefreshAuth", [], status);
+ expect(result.forceCalls).toBe(1);
+ expect(result.fetchCalls).toBe(2);
+ expect(result.seen.map((request) => request.authorization)).toEqual([
+ "Bearer LLM|TESTKEY0001",
+ "Bearer LLM|TESTKEY0002",
+ ]);
+ expect(result.status).toBe(400);
+ expect(result.verdict).toBe("terminal");
+ expect(result.body).toMatch(/login/);
+ });
+ test("post-refresh 429 retains allowance behavior without terminal credential verdict", async () => {
+ const result = await exercise("forceRefreshAuth", [], 429);
+ expect(result.forceCalls).toBe(1);
+ expect(result.fetchCalls).toBe(2);
+ expect(result.status).toBe(429);
+ expect(result.verdict).not.toBe("terminal");
+ });
+ test("Antigravity post-refresh 429 retains its upstream status", async () => {
+ const result = await exercise("forceRefreshAuth", [], 429, "antigravity");
+ expect(result.forceCalls).toBe(1);
+ expect(result.fetchCalls).toBe(2);
+ expect(result.status).toBe(429);
+ expect(result.verdict).not.toBe("terminal");
+ const body = JSON.parse(result.body);
+ expect(body.error.type).toBe("rate_limit_error");
+ expect(body.error.message).toContain("Unauthorized");
+ });
+});
+
+describe("H3: Antigravity primary allowance response", () => {
+ test("primary terminal 429 is remapped to 400 without refreshing auth", async () => {
+ const result = await exercise("primary fetch", [], 401, "antigravity", 429);
+ expect(result.status).toBe(400);
+ expect(result.body).toContain("429");
+ expect(result.forceCalls).toBe(0);
+ expect(result.fetchCalls).toBe(1);
+ });
+});
diff --git a/packages/cli/src/handlers/fallback-handler.muse-code.test.ts b/packages/cli/src/handlers/fallback-handler.muse-code.test.ts
new file mode 100644
index 00000000..08fb8666
--- /dev/null
+++ b/packages/cli/src/handlers/fallback-handler.muse-code.test.ts
@@ -0,0 +1,307 @@
+import { afterAll, afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Hono } from "hono";
+
+const savedEnvironment = new Map(
+ ["CLAUDISH_DISABLE_KEYCHAIN", "API_TIMEOUT_MS"].map((k) => [k, process.env[k]])
+);
+const testHome = mkdtempSync(join(tmpdir(), "claudish-run4-"));
+process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+const realFetch = globalThis.fetch;
+const keychain = await import("../providers/keychain.js");
+const fakeKeychainDeps = {
+ platform: () => "darwin",
+ run: () => ({ code: 44, stdout: "", stderr: "test: absent" }),
+ runAsync: async () => ({ code: 44, stdout: "", stderr: "test: absent" }),
+ spawnAsync: () => ({
+ done: Promise.resolve({ code: 44, stdout: "", stderr: "test: absent" }),
+ pid: undefined,
+ }),
+};
+keychain.setKeychainTestDeps(fakeKeychainDeps);
+beforeEach(() => {
+ keychain.setKeychainTestDeps(fakeKeychainDeps);
+});
+afterEach(() => {
+ keychain.setKeychainTestDeps(null);
+ keychain.invalidateKeychainCache();
+});
+const guardedFetch = Object.assign(
+ (input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => {
+ const url = new URL(input instanceof Request ? input.url : String(input));
+ if (url.hostname === "127.0.0.1" && url.protocol === "http:") return realFetch(input, init);
+ throw new Error(`Unexpected external request: ${url.origin}${url.pathname}`);
+ },
+ { preconnect: () => {} }
+) as typeof fetch;
+globalThis.fetch = guardedFetch;
+const { credentials } = await import("../auth/credentials/authority.js");
+const { clearSignedArm, recordSignedArm } = await import("../auth/credentials/billing-probe.js");
+const core = await import("../providers/meta-muse/muse-credentials.js");
+const museKeychain = await import("../providers/meta-muse/muse-keychain.js");
+const roles = await import("../auth/credentials/prompt-role.js");
+const catalog = await import("../providers/catalog-client.js");
+const cache = await import("../providers/all-models-cache.js");
+// Every seam is a complete fake: omitted fields would restore machine defaults.
+beforeEach(() => {
+ core.setMuseCoreTestDeps({
+ dir: () => testHome,
+ now: () => 1_800_000_000_000,
+ readStore: () => null,
+ writeBorrowedCopy: () => {
+ throw new Error("unexpected borrowed-copy write");
+ },
+ mint: async () => {
+ throw new Error("unexpected Muse mint");
+ },
+ keychainLogin: async () => ({ kind: "not-allowed" }),
+ });
+ museKeychain.setMuseKeychainTestDeps({
+ dir: () => testHome,
+ env: () => ({}),
+ now: () => 1_800_000_000_000,
+ sleep: async () => {
+ throw new Error("unexpected Muse Keychain wait");
+ },
+ pid: () => 424242,
+ isAlive: () => false,
+ presence: async () => ({ kind: "absent" }),
+ startRead: () => ({ done: Promise.resolve({ kind: "absent" as const }), pid: undefined }),
+ });
+});
+afterEach(() => {
+ globalThis.fetch = guardedFetch;
+ credentials.invalidate();
+ clearSignedArm();
+ core.setMuseCoreTestDeps(null);
+ core.resetMuseCredentialState();
+ museKeychain.setMuseKeychainTestDeps(null);
+ museKeychain.resetMuseKeychainState();
+ roles._resetCredentialPromptRoleForTest();
+ catalog._resetCatalogClient();
+ cache._clearAllModelsCacheMemo();
+ keychain.invalidateKeychainCache();
+});
+afterAll(() => {
+ globalThis.fetch = realFetch;
+ keychain.setKeychainTestDeps(null);
+ keychain.invalidateKeychainCache();
+ for (const [key, value] of savedEnvironment) {
+ if (value === undefined) delete process.env[key];
+ else process.env[key] = value;
+ }
+ rmSync(testHome, { recursive: true, force: true });
+});
+const { FallbackHandler, isRetryableError } = await import("./fallback-handler.js");
+import { authVerdictHeaders } from "./shared/auth-failure.js";
+
+const subscriptions = [
+ "kimi-coding",
+ "qwen-token-plan",
+ "qwen-coding",
+ "glm-coding",
+ "minimax-coding",
+ "sakana-subscription",
+ "opencode-zen-go",
+ "grok-subscription",
+ "antigravity",
+ "devin",
+ "meta-muse-code",
+];
+// Meta wire-capture §7; upstream_status is claudish's surfaced-error envelope.
+const rejection = JSON.stringify({
+ error: { type: "invalid_api_key", message: "Unauthorized", upstream_status: 401 },
+});
+
+describe("B1: routing-chain stop decisions", () => {
+ test.each(subscriptions)(
+ "%s holds terminal/transient verdicts before status recovery",
+ (provider) => {
+ for (const verdict of ["terminal", "transient"] as const) {
+ for (const upstream of [401, 403]) {
+ const body = JSON.stringify({
+ error: { message: "run `claudish login muse`", upstream_status: upstream },
+ });
+ expect(
+ isRetryableError(
+ 400,
+ body,
+ provider,
+ new Headers(authVerdictHeaders(verdict)),
+ provider
+ )
+ ).toBe(false);
+ }
+ }
+ }
+ );
+ test.each(subscriptions)("%s stops a credential rejection without a verdict", (provider) => {
+ expect(isRetryableError(401, rejection, provider, new Headers(), provider)).toBe(false);
+ });
+ test("metered Meta 401 remains eligible to advance", () => {
+ expect(isRetryableError(401, rejection, "meta", new Headers(), "meta")).toBe(true);
+ });
+});
+
+describe("B2: request-specific failures may advance", () => {
+ test.each([
+ "Model deepseek-v4-pro-0813 is not supported",
+ "Model grok-4.6 is not supported for format oa-compat",
+ ])("Zen Go model miss: %s", (message) => {
+ for (const status of [401, 403]) {
+ expect(
+ isRetryableError(status, message, "opencode-zen-go", new Headers(), "opencode-zen-go")
+ ).toBe(true);
+ }
+ });
+ test("Kimi allowance exhaustion still advances", () => {
+ expect(
+ isRetryableError(
+ 403,
+ "You've reached your usage limit for this billing cycle",
+ "kimi-coding",
+ new Headers(),
+ "kimi-coding"
+ )
+ ).toBe(true);
+ expect(
+ isRetryableError(
+ 429,
+ "You've reached your usage limit for this billing cycle",
+ "kimi-coding",
+ new Headers(),
+ "kimi-coding"
+ )
+ ).toBe(true);
+ });
+ test.skip("BLOCKED B2 region opt-in: no captured or measured region-opt-in message in the contract", () => {});
+});
+
+// Exercise the actual chain: only the second handler represents metered Meta.
+async function twoHop(provider: string, firstResponse: () => Response) {
+ let firstCalls = 0;
+ let meteredCalls = 0;
+ const warnings: string[] = [];
+ const originalWrite = process.stderr.write;
+ process.stderr.write = ((chunk: unknown, ..._rest: unknown[]) => {
+ warnings.push(String(chunk));
+ return true;
+ }) as typeof process.stderr.write;
+ const chain = new FallbackHandler([
+ {
+ name: `${provider}@fixture`,
+ provider,
+ handler: {
+ handle: async () => {
+ firstCalls++;
+ return firstResponse();
+ },
+ shutdown: async () => {},
+ },
+ },
+ {
+ name: "meta@fixture",
+ provider: "meta",
+ handler: {
+ handle: async () => {
+ meteredCalls++;
+ return new Response("metered success");
+ },
+ shutdown: async () => {},
+ },
+ },
+ ]);
+ try {
+ const app = new Hono();
+ app.post("/", (c) => chain.handle(c, { messages: [{ role: "user", content: "PONG" }] }));
+ const response = await app.request("http://localhost/", { method: "POST" });
+ return {
+ status: response.status,
+ verdict: response.headers.get("x-claudish-auth-verdict"),
+ body: await response.text(),
+ firstCalls,
+ meteredCalls,
+ warnings: warnings.join(""),
+ };
+ } finally {
+ process.stderr.write = originalWrite;
+ await chain.shutdown();
+ }
+}
+
+describe("B1: actual two-hop subscription stops", () => {
+ test.each([...subscriptions, "openai-codex"])(
+ "%s never calls metered Meta on auth failure",
+ async (provider) => {
+ recordSignedArm("openai-codex", "subscription");
+ for (const verdict of ["terminal", "transient"] as const) {
+ for (const upstream of [401, 403]) {
+ const result = await twoHop(
+ provider,
+ () =>
+ new Response(
+ JSON.stringify({
+ error: {
+ message: "run `claudish login muse`",
+ upstream_status: upstream,
+ },
+ }),
+ { status: verdict === "terminal" ? 400 : 503, headers: authVerdictHeaders(verdict) }
+ )
+ );
+ expect(result.status).toBe(verdict === "terminal" ? 400 : 503);
+ expect(result.verdict).toBe(verdict);
+ expect(result.body).toContain("login muse");
+ expect(result.firstCalls).toBe(1);
+ expect(result.meteredCalls).toBe(0);
+ }
+ }
+ for (const upstream of [401, 403]) {
+ const result = await twoHop(provider, () => new Response(rejection, { status: upstream }));
+ expect(result.status).not.toBe(200);
+ expect(result.body).toContain("Unauthorized");
+ expect(result.firstCalls).toBe(1);
+ expect(result.meteredCalls).toBe(0);
+ }
+ }
+ );
+});
+
+describe("B2: actual request-specific and metered advances", () => {
+ test.each([401, 403])(
+ "Zen Go unsupported-model HTTP %i reaches the next handler once",
+ async (status) => {
+ const result = await twoHop(
+ "opencode-zen-go",
+ () => new Response("Model grok-4.6 is not supported for format oa-compat", { status })
+ );
+ expect(result.status).toBe(200);
+ expect(result.body).toBe("metered success");
+ expect(result.firstCalls).toBe(1);
+ expect(result.meteredCalls).toBe(1);
+ }
+ );
+ test.each([403, 429])(
+ "subscription allowance HTTP %i advances with a billing warning",
+ async (status) => {
+ const result = await twoHop(
+ "kimi-coding",
+ () => new Response("You've reached your usage limit for this billing cycle", { status })
+ );
+ expect(result.status).toBe(200);
+ expect(result.meteredCalls).toBe(1);
+ expect(result.warnings).toMatch(/cost|metered|per.token|paid|billing/i);
+ }
+ );
+ test("metered Meta invalid key advances, including Codex's metered signed arm", async () => {
+ recordSignedArm("openai-codex", "metered");
+ for (const provider of ["meta", "openai-codex"]) {
+ const result = await twoHop(provider, () => new Response(rejection, { status: 401 }));
+ expect(result.status).toBe(200);
+ expect(result.body).toBe("metered success");
+ expect(result.meteredCalls).toBe(1);
+ }
+ });
+});
diff --git a/packages/cli/src/handlers/shared/auth-failure.test.ts b/packages/cli/src/handlers/shared/auth-failure.test.ts
new file mode 100644
index 00000000..98f3823d
--- /dev/null
+++ b/packages/cli/src/handlers/shared/auth-failure.test.ts
@@ -0,0 +1,189 @@
+import { describe, expect, test } from "bun:test";
+import { Hono } from "hono";
+import {
+ credentialHttpError,
+ isTransientCredentialError,
+ terminalCredentialError,
+} from "../../auth/credentials/credential-error.js";
+import {
+ AUTH_VERDICT_HEADER,
+ authVerdict,
+ authVerdictHeaders,
+ classifyAuthFailure,
+ isCredentialRejection,
+ respondAuthFailure,
+} from "./auth-failure.js";
+
+async function refusedFetch(): Promise<unknown> {
+ const server = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => new Response("unused") });
+ const url = `http://127.0.0.1:${server.port}/token`;
+ await server.stop(true);
+ try {
+ await fetch(url);
+ } catch (error) {
+ return error;
+ }
+ throw new Error("Refused-fetch fixture unexpectedly succeeded");
+}
+
+describe("F1: credential failure classification", () => {
+ test("real connection failure wins over terminal and transient markers, including causes", async () => {
+ const raw = await refusedFetch();
+ expect(classifyAuthFailure(raw).kind).toBe("connection");
+ const wrapped = Object.assign(new Error("run `claudish login muse`", { cause: raw }), {
+ terminal: true,
+ transient: true,
+ upstreamStatus: 503,
+ });
+ expect(classifyAuthFailure(wrapped).kind).toBe("connection");
+ });
+
+ test("positive terminal marker wins over transient marker", () => {
+ const error = Object.assign(terminalCredentialError("run `claudish login muse`", 401), {
+ transient: true,
+ });
+ expect(classifyAuthFailure(error)).toEqual({
+ kind: "terminal",
+ message: "run `claudish login muse`",
+ upstreamStatus: 401,
+ });
+ });
+
+ test.each([429, 500, 503])("HTTP %i is transient, with its status retained", (status) => {
+ const error = credentialHttpError(`key service unavailable (${status})`, status);
+ expect(isTransientCredentialError(error)).toBe(true);
+ expect(classifyAuthFailure(error)).toEqual({
+ kind: "transient",
+ status,
+ message: `key service unavailable (${status})`,
+ });
+ });
+
+ test.each(["OAuth unavailable", "refresh_token rejected"])(
+ "unclassified %s stays unknown",
+ (message) => {
+ expect(classifyAuthFailure(new Error(message))).toEqual({ kind: "unknown", message });
+ }
+ );
+
+ test.each(["terminal", "transient"] as const)(
+ "%s verdict survives Headers conversion",
+ (verdict) => {
+ const headers = new Headers(authVerdictHeaders(verdict));
+ expect(AUTH_VERDICT_HEADER).toBe("x-claudish-auth-verdict");
+ expect(headers.get("x-claudish-auth-verdict")).toBe(verdict);
+ expect(authVerdict(headers)).toBe(verdict);
+ expect(authVerdict(new Headers())).toBeUndefined();
+ }
+ );
+
+ test.each([
+ [
+ terminalCredentialError("run `claudish login muse`", 401),
+ true,
+ 400,
+ "terminal",
+ "login muse",
+ ],
+ [
+ terminalCredentialError(
+ "subscribe at https://accountscenter.meta.com/muse_code/?ep=no_payg",
+ 403
+ ),
+ true,
+ 400,
+ "terminal",
+ "subscribe at",
+ ],
+ [credentialHttpError("key service unavailable (429)", 429), true, 429, "transient", "429"],
+ [credentialHttpError("key service unavailable (500)", 500), true, 503, "transient", "500"],
+ [credentialHttpError("key service unavailable (503)", 503), true, 503, "transient", "503"],
+ [new Error("OAuth unavailable"), true, 503, "transient", "OAuth unavailable"],
+ [new Error("OAuth unavailable"), false, 401, null, "OAuth unavailable"],
+ ] as const)(
+ "responds to %s (subscription=%s)",
+ async (error, isSubscription, status, verdict, message) => {
+ const app = new Hono();
+ app.post(
+ "/",
+ (c) =>
+ respondAuthFailure(c, classifyAuthFailure(error), {
+ isSubscription,
+ providerDisplayName: "Muse Code",
+ }) ?? new Response("unexpected connection branch", { status: 599 })
+ );
+ const response = await app.request("http://localhost/", { method: "POST" });
+ expect(response.status).toBe(status);
+ expect(response.headers.get(AUTH_VERDICT_HEADER)).toBe(verdict);
+ const body = await response.text();
+ expect(body).toContain(message);
+ if (status === 400) {
+ expect(JSON.parse(body).error.type).toBe("invalid_request_error");
+ expect(JSON.parse(body).error.upstream_status).toBe(
+ (error as { upstreamStatus?: number }).upstreamStatus
+ );
+ }
+ }
+ );
+
+ test.each([terminalCredentialError("login muse", 403), credentialHttpError("retry", 503)])(
+ "wrapped credential markers stay unknown and subscription response is transient",
+ async (cause) => {
+ const failure = classifyAuthFailure(new Error("wrapper", { cause }));
+ expect(failure).toEqual({ kind: "unknown", message: "wrapper" });
+ const app = new Hono();
+ app.post(
+ "/",
+ (c) =>
+ respondAuthFailure(c, failure, {
+ isSubscription: true,
+ providerDisplayName: "Muse Code",
+ }) ?? new Response("unexpected connection branch", { status: 599 })
+ );
+ const response = await app.request("http://localhost/", { method: "POST" });
+ expect(response.status).toBe(503);
+ expect(response.headers.get(AUTH_VERDICT_HEADER)).toBe("transient");
+ expect(await response.text()).toContain("wrapper");
+ }
+ );
+
+ test("a connection is left to recovery, rather than serialized as credential rejection", async () => {
+ const failure = classifyAuthFailure(await refusedFetch());
+ const app = new Hono();
+ let result: Response | null | undefined;
+ app.get("/", (c) => {
+ result = respondAuthFailure(c, failure, {
+ isSubscription: true,
+ providerDisplayName: "Muse Code",
+ });
+ return new Response("recovery");
+ });
+ await app.request("http://localhost/");
+ expect(result).toBeNull();
+ });
+});
+
+describe("F2: credential rejection excludes model misses and allowance exhaustion", () => {
+ test.each([401, 403])("invalid key HTTP %i rejects the credential", (status) => {
+ // wire-capture §7's synthetic rejection body, preserved verbatim.
+ expect(
+ isCredentialRejection(
+ status,
+ JSON.stringify({ error: { type: "invalid_api_key", message: "Unauthorized" } })
+ )
+ ).toBe(true);
+ });
+ test.each([
+ "Model deepseek-v4-pro-0813 is not supported",
+ "Model grok-4.6 is not supported for format oa-compat",
+ "You've reached your usage limit for this billing cycle",
+ ])("measured request-specific failure: %s", (message) => {
+ for (const status of [401, 403]) expect(isCredentialRejection(status, message)).toBe(false);
+ });
+ test("429 allowance exhaustion is not a dead login", () => {
+ expect(
+ isCredentialRejection(429, "You've reached your usage limit for this billing cycle")
+ ).toBe(false);
+ });
+ test.skip("BLOCKED F2: no measured region-opt-in wording is supplied", () => {});
+});
diff --git a/packages/cli/src/model-loader.muse-code.test.ts b/packages/cli/src/model-loader.muse-code.test.ts
new file mode 100644
index 00000000..6be59459
--- /dev/null
+++ b/packages/cli/src/model-loader.muse-code.test.ts
@@ -0,0 +1,173 @@
+import { afterEach, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+
+const children: ReturnType<typeof Bun.spawn>[] = [];
+
+const temporaryDirectories: string[] = [];
+afterEach(async () => {
+ for (const child of children.splice(0)) {
+ if (child.exitCode === null) child.kill();
+ await child.exited;
+ }
+ for (const directory of temporaryDirectories.splice(0))
+ rmSync(directory, { recursive: true, force: true });
+});
+
+test("G2c: old recommended projection is rejected without returning an opt-in command", async () => {
+ const directory = mkdtempSync(join(tmpdir(), "claudish-g2c-"));
+ temporaryDirectories.push(directory);
+ const home = join(directory, "home");
+ mkdirSync(home);
+ const scriptPath = join(directory, "scenario.ts");
+ // Absolute imports resolve beside the test in the final repository. HOME must
+ // be set at process START, before os.homedir() or any singleton is evaluated.
+ const loaderPath = resolve(import.meta.dir, "model-loader.js");
+ const cachePath = resolve(import.meta.dir, "providers/all-models-cache.js");
+ writeFileSync(
+ scriptPath,
+ `
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { syncBuiltinESMExports } from "node:module";
+import { fileURLToPath } from "node:url";
+const realExit = process.exit.bind(process);
+try {
+const home = process.env.HOME!;
+assert.equal(homedir(), home);
+const outsideHomeWrites: string[] = [];
+function inside(path: unknown) {
+ const name = path instanceof URL ? fileURLToPath(path) : String(path);
+ const rel = relative(home, resolve(name));
+ return rel === "" || (!isAbsolute(rel) && rel !== ".." && !rel.startsWith("../"));
+}
+function guard(path: unknown) {
+ if (!inside(path)) {
+ outsideHomeWrites.push(String(path));
+ throw new Error("Write outside temporary HOME: " + String(path));
+ }
+}
+// Observe and reject filesystem mutations, including cache writes during
+// imports. Patch before imports and update named node:fs imports as well.
+for (const name of ["writeFileSync", "appendFileSync", "mkdirSync", "unlinkSync", "rmSync", "rmdirSync", "chmodSync",
+ "writeFile", "appendFile", "mkdir", "unlink", "rm", "rmdir", "chmod"]) {
+ const original = (fs as any)[name];
+ (fs as any)[name] = function(path: unknown, ...args: unknown[]) {
+ guard(path);
+ return original.call(this, path, ...args);
+ };
+}
+for (const name of ["renameSync", "copyFileSync", "rename", "copyFile"]) {
+ const original = (fs as any)[name];
+ (fs as any)[name] = function(from: unknown, to: unknown, ...args: unknown[]) {
+ guard(from); guard(to);
+ return original.call(this, from, to, ...args);
+ };
+}
+for (const name of ["writeFile", "appendFile", "mkdir", "unlink", "rm", "rmdir", "chmod", "rename", "copyFile"]) {
+ const original = (fs.promises as any)[name];
+ (fs.promises as any)[name] = function(path: unknown, ...args: unknown[]) {
+ guard(path);
+ if (name === "rename" || name === "copyFile") guard(args[0]);
+ return original.call(this, path, ...args);
+ };
+}
+for (const name of ["openSync", "open", "createWriteStream"]) {
+ const original = (fs as any)[name];
+ (fs as any)[name] = function(path: unknown, ...args: unknown[]) {
+ // Reads may inspect repository modules; every write-open stays in HOME.
+ if (name === "createWriteStream" || (args[0] !== undefined && args[0] !== "r" && args[0] !== 0)) guard(path);
+ return original.call(this, path, ...args);
+ };
+}
+const originalPromiseOpen = fs.promises.open;
+(fs.promises as any).open = function(path: unknown, flags: unknown, ...args: unknown[]) {
+ if (flags !== undefined && flags !== "r" && flags !== 0) guard(path);
+ return (originalPromiseOpen as any).call(this, path, flags, ...args);
+};
+const originalBunWrite = Bun.write;
+(Bun as any).write = function(path: unknown, ...args: unknown[]) {
+ guard(path);
+ return (originalBunWrite as any).call(this, path, ...args);
+};
+syncBuiltinESMExports();
+let requests = 0;
+const realFetch = globalThis.fetch;
+globalThis.fetch = Object.assign(async (input, init) => {
+ const url = new URL(input instanceof Request ? input.url : String(input));
+ if (url.protocol !== "http:" && url.protocol !== "https:") return realFetch(input, init);
+ requests++;
+ throw new Error("G2c forbids network requests");
+}, { preconnect: () => {} });
+const loader = await import(${JSON.stringify(loaderPath)});
+const cache = await import(${JSON.stringify(cachePath)});
+assert.ok(inside(loader.RECOMMENDED_MODELS_CACHE_PATH));
+assert.ok(inside(cache.ALL_MODELS_CACHE_PATH));
+const generation = "g-run3-old-projection";
+const stamp = new Date().toISOString();
+fs.mkdirSync(dirname(cache.ALL_MODELS_CACHE_PATH), { recursive: true });
+fs.mkdirSync(dirname(loader.RECOMMENDED_MODELS_CACHE_PATH), { recursive: true });
+cache.writeAllModelsCache({ version: 3, lastUpdated: stamp, catalogGenerationId: generation,
+ entries: [{ contractVersion: 3, modelId: "muse-spark-1.3", provider: "meta", aliases: [], aggregators: [] }],
+ models: [{ id: "muse-spark-1.3" }], plans: [] });
+const obsolete = { contractVersion: 3, generationId: generation,
+ projectionVersion: loader.RECOMMENDED_PROJECTION_VERSION - 1, version: "3", lastUpdated: stamp,
+ models: [{ id: "muse-spark-1.3", name: "Muse Spark", description: "Cloud models catalog test seed",
+ provider: "meta", category: "flagship", priority: 1, context: "1M",
+ pricing: { input: "0", output: "0", average: "0" },
+ subscription: { prefix: "zgo", plan: "Go", command: "[email protected]" } }] };
+fs.writeFileSync(loader.RECOMMENDED_MODELS_CACHE_PATH, JSON.stringify(obsolete));
+let message = "";
+let returned = false;
+try { await loader.getRecommendedModels(); returned = true; }
+catch (error) { message = error instanceof Error ? error.message : String(error); }
+assert.equal(returned, false);
+assert.match(message, /Unable to load v3 recommended models/);
+assert.ok(!message.includes("-contributor"));
+assert.ok(requests > 0);
+assert.deepEqual(outsideHomeWrites, []);
+console.log(JSON.stringify({ message, returned, requests, outsideHomeWrites,
+ recommendedExists: fs.existsSync(loader.RECOMMENDED_MODELS_CACHE_PATH),
+ catalogExists: fs.existsSync(cache.ALL_MODELS_CACHE_PATH) }));
+realExit(0);
+} catch (error) { console.error(error); realExit(1); }
+`
+ );
+ const child = Bun.spawn([process.execPath, scriptPath], {
+ cwd: home,
+ env: {
+ ...process.env,
+ HOME: home,
+ CLAUDISH_DISABLE_KEYCHAIN: "1",
+ CLAUDISH_DISABLE_CATALOG_WARM: "1",
+ },
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ children.push(child);
+ const [stdout, stderr, exitCode] = await Promise.all([
+ new Response(child.stdout).text(),
+ new Response(child.stderr).text(),
+ child.exited,
+ ]);
+ expect(exitCode).toBe(0);
+ // Preserve diagnostics when a child assertion fails, without requiring quiet logs.
+ if (exitCode !== 0) throw new Error(stderr);
+ const lines = stdout.trim().split("\n");
+ expect(lines).toHaveLength(1);
+ const result = JSON.parse(lines[0]!);
+ expect(result.returned).toBe(false);
+ expect(result.message).toMatch(/Unable to load v3 recommended models/);
+ expect(result.message).not.toContain("-contributor");
+ expect(result.requests).toBeGreaterThan(0);
+ expect(result.catalogExists).toBe(true);
+ expect(result.outsideHomeWrites).toEqual([]);
+ expect(readdirSync(directory).sort()).toEqual(["home", "scenario.ts"]);
+});
+
+// HOME isolation is available; the remaining blocker is the unspecified HTTP
+// payload T of CatalogV3Envelope<T> for single-model/search/page/top100 requests.
+test.skip("G2c BLOCKED: ModelDoc fetch/search/provider/top100 HTTP data/pagination payloads are undeclared", () => {});
diff --git a/packages/cli/src/model-selector.muse-code.test.ts b/packages/cli/src/model-selector.muse-code.test.ts
new file mode 100644
index 00000000..3860c860
--- /dev/null
+++ b/packages/cli/src/model-selector.muse-code.test.ts
@@ -0,0 +1,245 @@
+import { afterEach, beforeEach, 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 savedEnv: Record<string, string | undefined>;
+let savedFetch: typeof fetch;
+let savedExit: typeof process.exit;
+// Any unexpected CLI exit must fail the case instead of terminating Bun's runner.
+class UnexpectedProcessExit extends Error {
+ constructor(code?: string | number | null) {
+ super(`RUN5_PROCESS_EXIT:${code ?? 0}`);
+ this.name = "UnexpectedProcessExit";
+ }
+}
+beforeEach(() => {
+ savedEnv = { CLAUDISH_DISABLE_KEYCHAIN: process.env.CLAUDISH_DISABLE_KEYCHAIN };
+ home = mkdtempSync(join(tmpdir(), "muse-run5-"));
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ savedExit = process.exit;
+ process.exit = (code?: string | number | null): never => {
+ throw new UnexpectedProcessExit(code);
+ };
+ savedFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(
+ async () => {
+ throw new Error("Unexpected network in Run 5 test");
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+});
+function restoreHarness() {
+ process.exit = savedExit;
+ globalThis.fetch = savedFetch;
+ for (const [key, value] of Object.entries(savedEnv)) {
+ if (value === undefined) delete process.env[key];
+ else process.env[key] = value;
+ }
+ rmSync(home, { recursive: true, force: true });
+}
+
+// HOME is not an isolation seam in Bun. Every filesystem-capable dependency
+// below is explicit and test-owned; omitted production defaults are forbidden.
+function fakeCoreDeps(
+ overrides: Partial<import("./providers/meta-muse/muse-credentials.js").MuseCoreDeps> = {}
+): import("./providers/meta-muse/muse-credentials.js").MuseCoreDeps {
+ return {
+ dir: () => home,
+ now: () => 1792088000000,
+ readStore: () => null,
+ writeBorrowedCopy: () => {
+ throw new Error("Unexpected borrowed-copy write");
+ },
+ mint: async () => {
+ throw new Error("Unexpected mint");
+ },
+ keychainLogin: async () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+function fakeMuseKeychainDeps(
+ overrides: Partial<import("./providers/meta-muse/muse-keychain.js").MuseKeychainDeps> = {}
+): import("./providers/meta-muse/muse-keychain.js").MuseKeychainDeps {
+ return {
+ dir: () => home,
+ env: () => ({}),
+ now: () => 1792088000000,
+ sleep: async () => {
+ throw new Error("Unexpected Keychain wait");
+ },
+ pid: () => 424242,
+ isAlive: () => false,
+ presence: async () => ({ kind: "absent" }),
+ startRead: () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+let previousConfigPath: string | null;
+const restoreRegistrations: (() => void)[] = [];
+beforeEach(async () => {
+ const keychain = await import("./providers/keychain.js");
+ const forbidden = () => {
+ throw new Error("Real Keychain process forbidden");
+ };
+ keychain.setKeychainTestDeps({
+ platform: () => "darwin",
+ run: forbidden,
+ runAsync: async () => forbidden(),
+ spawnAsync: forbidden,
+ });
+ const core = await import("./providers/meta-muse/muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(fakeCoreDeps());
+ const museKeychain = await import("./providers/meta-muse/muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(fakeMuseKeychainDeps());
+ (await import("./auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ const config = await import("./config-override.js");
+ previousConfigPath = config.getConfigFileOverride();
+ config.setConfigFileOverride(join(home, "config.json"));
+});
+afterEach(async () => {
+ for (const restore of restoreRegistrations.splice(0).reverse()) restore();
+ const core = await import("./providers/meta-muse/muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(null);
+ const museKeychain = await import("./providers/meta-muse/muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(null);
+ const keychain = await import("./providers/keychain.js");
+ keychain.invalidateKeychainCache();
+ keychain.setKeychainTestDeps(null);
+ (await import("./auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ (await import("./auth/credentials/billing-probe.js")).clearSignedArm();
+ (await import("./providers/model-discovery.js")).invalidateModelDiscovery("meta-muse-code");
+ (await import("./providers/all-models-cache.js"))._clearAllModelsCacheMemo();
+ (await import("./providers/catalog-client.js"))._resetCatalogClient();
+ (await import("./config-override.js")).setConfigFileOverride(previousConfigPath);
+ restoreHarness();
+});
+
+test("N3: picker offers Muse and Meta and emits the exact plain Muse spec", async () => {
+ const { buildProviderChoices, buildExplicitModelSpec } = await import("./model-selector.js");
+ const choices = buildProviderChoices();
+ expect(choices.some((choice) => choice.provider === "meta-muse-code")).toBe(true);
+ expect(choices.some((choice) => choice.provider === "meta")).toBe(true);
+ expect(buildExplicitModelSpec("meta-muse-code", "muse-wonder-full-1.0")).toBe(
+ );
+});
+
+test("N3: discovery failure notice identifies the missing Muse login", async () => {
+ const { formatDiscoveryFailureNotice } = await import("./model-selector.js");
+ const notice = formatDiscoveryFailureNotice(
+ "Muse Code",
+ {
+ kind: "no-credentials",
+ provider: "meta-muse-code",
+ detail: "Muse Code login not available in this process",
+ },
+ { apiKeyEnvVar: "", apiKeyUrl: "https://accountscenter.meta.com/muse_code/?ep=no_payg" }
+ );
+ expect(JSON.stringify(notice)).toContain("Muse Code");
+ expect(JSON.stringify(notice).toLowerCase()).toContain("login");
+});
+
+test("N3: contributor-first cloud connections emit plain Meta specs and no implicit zgo contributor", async () => {
+ const { createCatalogClient } = await import("./providers/model-catalog.js");
+ const { servedModelsForProvider, resolveProviderExternalId } = await import(
+ "./model-selector.js"
+ );
+ const { writeAllModelsCache, readAllModelsCache, _clearAllModelsCacheMemo } = await import(
+ "./providers/all-models-cache.js"
+ );
+ const connection = (routeId: string, externalModelId: string) => ({
+ sourceProviderId: routeId,
+ sourceCollectorId: "contract-fixture",
+ confidence: "api_official" as const,
+ routeStatus: "mapped" as const,
+ route: { routeId, routeProfileId: "direct-api" },
+ externalModelId,
+ });
+ // Contract v3 seed; ids copied from §4 / architecture §3b, not a Meta response.
+ const entry = {
+ modelId: "muse-spark-1.3",
+ displayName: "Muse Spark",
+ provider: "meta",
+ aliases: [],
+ inputModalities: ["text"],
+ outputModalities: ["text"],
+ supportsTools: true,
+ aggregators: [
+ connection("meta", "muse-spark-1.3-contributor"),
+ connection("meta", "muse-spark-1.3"),
+ {
+ ...connection("opencode", "muse-spark-1.3-contributor"),
+ route: { routeId: "opencode", routeProfileId: "go-subscription" },
+ },
+ ],
+ };
+ const cachePath = join(home, "picker-catalog.json");
+ writeAllModelsCache(
+ {
+ version: 3,
+ lastUpdated: new Date().toISOString(),
+ entries: [entry],
+ models: [{ id: entry.modelId }],
+ plans: [],
+ catalogGenerationId: "g-picker-wave2",
+ },
+ cachePath
+ );
+ const catalog = createCatalogClient({
+ readSlimCache: () => readAllModelsCache(cachePath),
+ getModelsByProvider: async () => [],
+ getModelByIdFromFirebase: async () => null,
+ searchModels: async () => [],
+ });
+ try {
+ const rows = servedModelsForProvider("meta", catalog);
+ expect(rows.map((r) => resolveProviderExternalId("meta", r))).toEqual(["muse-spark-1.3"]);
+ expect(servedModelsForProvider("opencode-zen-go", catalog)).toEqual([]);
+ } finally {
+ _clearAllModelsCacheMemo();
+ }
+});
+
+test("N3: discovered reported chat rows exclude contributor-first ids before picker emission", async () => {
+ const d = await import("./providers/model-discovery.js");
+ await import("./providers/model-discovery-builtins.js");
+ const { createCatalogClient } = await import("./providers/model-catalog.js");
+ const { buildDiscoveredModelRows, buildExplicitModelSpec } = await import("./model-selector.js");
+ const original = d.getModelDiscoveryFetcher("muse-code-models");
+ if (!original) throw new Error("missing production discovery fetcher");
+ restoreRegistrations.push(() => d.registerModelDiscoveryFetcher("muse-code-models", original));
+ const catalog = createCatalogClient({
+ readSlimCache: () => null,
+ getModelsByProvider: async () => [],
+ getModelByIdFromFirebase: async () => null,
+ searchModels: async () => [],
+ });
+ d.invalidateModelDiscovery("meta-muse-code");
+ d.registerModelDiscoveryFetcher("muse-code-models", async () => ({
+ kind: "models",
+ models: [
+ { id: "muse-wonder-full-1.0-contributor", reported: "chat", contextWindow: 1007997 },
+ { id: "muse-wonder-full-1.0", reported: "chat", contextWindow: 1007997 },
+ ],
+ }));
+ try {
+ const rows = await buildDiscoveredModelRows("meta-muse-code", "Muse Code", catalog);
+ expect(rows.map((r) => buildExplicitModelSpec("meta-muse-code", r.id))).toEqual([
+ ]);
+ expect(rows[0].contextLength).toBe(1007997);
+ } finally {
+ d.registerModelDiscoveryFetcher("muse-code-models", original);
+ d.invalidateModelDiscovery("meta-muse-code");
+ }
+});
diff --git a/packages/cli/src/providers/all-models-cache.muse-code.test.ts b/packages/cli/src/providers/all-models-cache.muse-code.test.ts
new file mode 100644
index 00000000..9d843168
--- /dev/null
+++ b/packages/cli/src/providers/all-models-cache.muse-code.test.ts
@@ -0,0 +1,126 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { AggregatorEntry } from "../model-loader.js";
+import type { DiskCacheV3, SlimModelEntry } from "./all-models-cache.js";
+
+let home: string;
+let savedKeychain: string | undefined;
+let cachePath: string;
+let savedFetch: typeof globalThis.fetch;
+let cache: typeof import("./all-models-cache.js");
+
+function connection(id: string, routeId = "meta", routeProfileId = "direct-api"): AggregatorEntry {
+ return {
+ sourceProviderId: routeId,
+ sourceCollectorId: routeId,
+ confidence: "api_official",
+ routeStatus: "mapped",
+ route: { routeId, routeProfileId },
+ externalModelId: id,
+ };
+}
+function seed(aggregators: AggregatorEntry[]): SlimModelEntry {
+ return {
+ contractVersion: 3,
+ modelId: "muse-spark-1.3",
+ provider: "meta",
+ aliases: [],
+ aggregators,
+ };
+}
+function disk(entries: SlimModelEntry[]): DiskCacheV3 {
+ return {
+ version: 3,
+ lastUpdated: new Date().toISOString(),
+ catalogGenerationId: "g-run3-fixture",
+ entries,
+ models: entries.map((entry) => ({ id: entry.modelId })),
+ plans: [],
+ };
+}
+beforeEach(async () => {
+ // All disk access uses the explicit cache path; HOME is not an isolation seam.
+ home = mkdtempSync(join(tmpdir(), "claudish-run3-"));
+ savedKeychain = process.env.CLAUDISH_DISABLE_KEYCHAIN;
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ cachePath = join(home, "all-models.json");
+ savedFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(
+ async () => {
+ throw new Error("Run 3 tests forbid network requests");
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+ cache = await import("./all-models-cache.js");
+ cache._clearAllModelsCacheMemo();
+});
+afterEach(() => {
+ cache?._clearAllModelsCacheMemo();
+ if (savedFetch) globalThis.fetch = savedFetch;
+ if (savedKeychain === undefined) delete process.env.CLAUDISH_DISABLE_KEYCHAIN;
+ else process.env.CLAUDISH_DISABLE_KEYCHAIN = savedKeychain;
+ rmSync(home, { recursive: true, force: true });
+});
+
+describe("G2a: disk ingestion partitions before exposing connections", () => {
+ test("G2a: raw contributor-first v3 disk data is normalized on read", async () => {
+ const { allConnections } = await import("./content-use.js");
+ const opt = connection("muse-spark-1.3-contributor");
+ const plain = connection("muse-spark-1.3");
+ // Bypass the writer so a writer-side fix cannot conceal a reader regression.
+ writeFileSync(cachePath, JSON.stringify(disk([seed([opt, plain])])));
+ const result = cache.readAllModelsCache(cachePath);
+ expect(result).not.toBeNull();
+ expect(result!.entries[0]!.aggregators).toEqual([plain]);
+ expect(allConnections(result!.entries[0]!)).toEqual([plain, opt]);
+ expect(cache.isSlimModelEntry(result!.entries[0])).toBe(true);
+ });
+
+ test("G2a: write/read retains both plain and opt-in connections", async () => {
+ const { allConnections } = await import("./content-use.js");
+ const opt = connection("muse-spark-1.3-contributor");
+ const plain = connection("muse-spark-1.3");
+ cache.writeAllModelsCache(disk([seed([opt, plain])]), cachePath);
+ cache._clearAllModelsCacheMemo();
+ const result = cache.readAllModelsCache(cachePath);
+ expect(result).not.toBeNull();
+ expect(result!.entries[0]!.aggregators).toEqual([plain]);
+ expect(allConnections(result!.entries[0]!)).toEqual([plain, opt]);
+ });
+
+ const invalidRows = [
+ { field: "routeStatus", mutate: (row: AggregatorEntry) => ({ ...row, routeStatus: 42 }) },
+ {
+ field: "route.routeId",
+ mutate: (row: AggregatorEntry) => ({ ...row, route: { ...row.route!, routeId: 42 } }),
+ },
+ {
+ field: "route.routeProfileId",
+ mutate: (row: AggregatorEntry) => ({ ...row, route: { ...row.route!, routeProfileId: 42 } }),
+ },
+ {
+ field: "externalModelId",
+ mutate: (row: AggregatorEntry) => ({ ...row, externalModelId: "" }),
+ },
+ ];
+ for (const { field, mutate } of invalidRows) {
+ test.each([true, false])(
+ `G2a: malformed raw row (${field}, opt-in=%s) is rejected before partition`,
+ (optIn) => {
+ // Identical invalid fields on opt-in and plain rows test validation parity.
+ const invalid = mutate(connection(optIn ? "muse-spark-1.3-contributor" : "muse-spark-1.3"));
+ const raw = { ...seed([]), aggregators: [invalid, connection("muse-spark-1.3")] };
+ expect(cache.isSlimModelEntry(raw)).toBe(false);
+ writeFileSync(
+ cachePath,
+ JSON.stringify({ ...disk([]), entries: [raw], models: [{ id: raw.modelId }] })
+ );
+ cache._clearAllModelsCacheMemo();
+ const read = cache.readAllModelsCache(cachePath);
+ expect(read?.entries.some((entry) => entry.modelId === raw.modelId) ?? false).toBe(false);
+ }
+ );
+ }
+});
diff --git a/packages/cli/src/providers/catalog-client.muse-code.test.ts b/packages/cli/src/providers/catalog-client.muse-code.test.ts
new file mode 100644
index 00000000..2ea640e0
--- /dev/null
+++ b/packages/cli/src/providers/catalog-client.muse-code.test.ts
@@ -0,0 +1,115 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { AggregatorEntry } from "../model-loader.js";
+import type { DiskCacheV3, SlimModelEntry } from "./all-models-cache.js";
+
+let home: string;
+let savedKeychain: string | undefined;
+let cachePath: string;
+let savedFetch: typeof globalThis.fetch;
+let cache: typeof import("./all-models-cache.js");
+
+function connection(id: string, routeId = "meta", routeProfileId = "direct-api"): AggregatorEntry {
+ return {
+ sourceProviderId: routeId,
+ sourceCollectorId: routeId,
+ confidence: "api_official",
+ routeStatus: "mapped",
+ route: { routeId, routeProfileId },
+ externalModelId: id,
+ };
+}
+function seed(aggregators: AggregatorEntry[]): SlimModelEntry {
+ return {
+ contractVersion: 3,
+ modelId: "muse-spark-1.3",
+ provider: "meta",
+ aliases: [],
+ aggregators,
+ };
+}
+function disk(entries: SlimModelEntry[]): DiskCacheV3 {
+ return {
+ version: 3,
+ lastUpdated: new Date().toISOString(),
+ catalogGenerationId: "g-run3-fixture",
+ entries,
+ models: entries.map((entry) => ({ id: entry.modelId })),
+ plans: [],
+ };
+}
+beforeEach(async () => {
+ // All disk access uses the explicit cache path; HOME is not an isolation seam.
+ home = mkdtempSync(join(tmpdir(), "claudish-run3-"));
+ savedKeychain = process.env.CLAUDISH_DISABLE_KEYCHAIN;
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ cachePath = join(home, "all-models.json");
+ savedFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(
+ async () => {
+ throw new Error("Run 3 tests forbid network requests");
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+ cache = await import("./all-models-cache.js");
+ cache._clearAllModelsCacheMemo();
+});
+afterEach(() => {
+ cache?._clearAllModelsCacheMemo();
+ if (savedFetch) globalThis.fetch = savedFetch;
+ if (savedKeychain === undefined) delete process.env.CLAUDISH_DISABLE_KEYCHAIN;
+ else process.env.CLAUDISH_DISABLE_KEYCHAIN = savedKeychain;
+ rmSync(home, { recursive: true, force: true });
+});
+
+let catalog: typeof import("./catalog-client.js") | undefined;
+afterEach(() => {
+ catalog?._setCatalogEntriesForTest(null);
+ catalog?._resetCatalogClient();
+});
+
+describe("G2b: catalog setter and wire-id resolution", () => {
+ beforeEach(async () => {
+ catalog = await import("./catalog-client.js");
+ catalog._resetCatalogClient();
+ });
+
+ test("G2b: setter normalizes contributor-first rows; implicit selection stays plain", async () => {
+ const { allConnections } = await import("./content-use.js");
+ const opt = connection("muse-spark-1.3-contributor");
+ const plain = connection("muse-spark-1.3");
+ catalog!._setCatalogEntriesForTest([seed([opt, plain])]);
+ const entry = catalog!.getCatalogEntries()![0]!;
+ expect(entry.aggregators).toEqual([plain]);
+ expect(allConnections(entry)).toEqual([plain, opt]);
+ expect(catalog!.externalIdFor(entry, "meta")).toBe("muse-spark-1.3");
+ });
+
+ test("G2b: exact contributor id survives while plain lookup chooses plain id", () => {
+ const opt = connection("muse-spark-1.3-contributor");
+ const plain = connection("muse-spark-1.3");
+ writeFileSync(cachePath, JSON.stringify(disk([seed([opt, plain])])));
+ catalog!._setCatalogEntriesForTest([seed([opt, plain])]);
+ expect(catalog!.resolveExternalId("muse-spark-1.3-contributor", "meta", cachePath)).toBe(
+ opt.externalModelId!
+ );
+ expect(catalog!.resolveExternalId("muse-spark-1.3", "meta", cachePath)).toBe(
+ plain.externalModelId!
+ );
+ });
+
+ test("G2b: plain request cannot inherit an opt-in-only connection", () => {
+ const entry = seed([connection("muse-spark-1.3-contributor")]);
+ writeFileSync(cachePath, JSON.stringify(disk([entry])));
+ catalog!._setCatalogEntriesForTest([entry]);
+ expect(catalog!.externalIdFor(catalog!.getCatalogEntries()![0]!, "meta")).toBeNull();
+ expect(catalog!.resolveExternalId("muse-spark-1.3", "meta", cachePath)).toBeNull();
+ expect(catalog!.resolveExternalId("muse-spark-1.3-contributor", "meta", cachePath)).toBe(
+ "muse-spark-1.3-contributor"
+ );
+ });
+
+ test.skip("G2b BLOCKED: CatalogV3Envelope<T> leaves refresh model-page T and pagination/completeness fields undeclared", () => {});
+});
diff --git a/packages/cli/src/providers/connection-resolver.muse-code.test.ts b/packages/cli/src/providers/connection-resolver.muse-code.test.ts
new file mode 100644
index 00000000..073042c4
--- /dev/null
+++ b/packages/cli/src/providers/connection-resolver.muse-code.test.ts
@@ -0,0 +1,161 @@
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { AggregatorEntry } from "../model-loader.js";
+import type { DiskCacheV3 } from "./all-models-cache.js";
+import type { CachedRouteRegistry, KnownWire } from "./connection-wire.js";
+
+const id = "muse-spark-1.3";
+const generation = "g-run3-connections";
+// Cloud models catalog fixture, not a Meta HTTP response.
+const plainWire: KnownWire = {
+ status: "known",
+ api: "responses",
+ tokenParam: "max_output_tokens",
+ toolsWithReasoning: "ok",
+ reasoning: { status: "unknown" },
+ speed: { status: "unknown" },
+ evidence: [],
+};
+const contributorWire: KnownWire = {
+ ...plainWire,
+ api: "chat-completions",
+ tokenParam: "max_tokens",
+};
+function connection(
+ wireId: string,
+ wire: KnownWire,
+ routeId = "meta",
+ profile = "direct-api"
+): AggregatorEntry {
+ return {
+ sourceProviderId: routeId,
+ sourceCollectorId: routeId,
+ confidence: "api_official",
+ routeStatus: "mapped",
+ route: { routeId, routeProfileId: profile },
+ externalModelId: wireId,
+ wire,
+ };
+}
+let home: string;
+let path: string;
+let savedKeychain: string | undefined;
+let savedFetch: typeof fetch;
+let cache: typeof import("./all-models-cache.js");
+let catalog: typeof import("./catalog-client.js");
+let resolver: typeof import("./connection-resolver.js");
+beforeEach(async () => {
+ // All disk access uses the explicit cache path; HOME is not an isolation seam.
+ home = mkdtempSync(join(tmpdir(), "claudish-g3-"));
+ path = join(home, "models.json");
+ savedKeychain = process.env.CLAUDISH_DISABLE_KEYCHAIN;
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ savedFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(
+ async () => {
+ throw new Error("G3 forbids network");
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+ cache = await import("./all-models-cache.js");
+ catalog = await import("./catalog-client.js");
+ resolver = await import("./connection-resolver.js");
+ cache._clearAllModelsCacheMemo();
+ catalog._resetCatalogClient();
+});
+afterEach(() => {
+ cache?._clearAllModelsCacheMemo();
+ catalog?._setCatalogEntriesForTest(null);
+ catalog?._resetCatalogClient();
+ globalThis.fetch = savedFetch;
+ if (savedKeychain === undefined) delete process.env.CLAUDISH_DISABLE_KEYCHAIN;
+ else process.env.CLAUDISH_DISABLE_KEYCHAIN = savedKeychain;
+ rmSync(home, { recursive: true, force: true });
+});
+function install(aggregators: AggregatorEntry[]) {
+ const routeRegistry: CachedRouteRegistry = {
+ generationId: generation,
+ registry: {
+ registryVersion: "3.7.0",
+ routes: {
+ meta: {
+ profiles: {
+ "direct-api": {
+ kind: "direct",
+ nativeModelProviders: ["meta"],
+ apis: {
+ responses: { baseUrl: "https://api.meta.ai/v1" },
+ "chat-completions": { baseUrl: "https://api.meta.ai/v1" },
+ },
+ },
+ },
+ },
+ openrouter: {
+ profiles: {
+ gateway: {
+ kind: "gateway",
+ apis: {
+ responses: { baseUrl: "https://openrouter.ai/api/v1" },
+ },
+ },
+ },
+ },
+ },
+ },
+ };
+ const entries = [
+ { contractVersion: 3 as const, modelId: id, provider: "meta", aliases: [], aggregators },
+ ];
+ const data: DiskCacheV3 = {
+ version: 3,
+ lastUpdated: new Date().toISOString(),
+ catalogGenerationId: generation,
+ entries,
+ models: [{ id }],
+ plans: [],
+ routeRegistry,
+ };
+ cache.writeAllModelsCache(data, path);
+ catalog._setCatalogEntriesForTest(entries);
+}
+
+test.each([id, `${id}-contributor`])(
+ "G3: explicit %s uses its exact connection and request URL",
+ (requested) => {
+ install([connection(`${id}-contributor`, contributorWire), connection(id, plainWire)]);
+ const result = resolver.resolveConnection("meta", requested, path);
+ expect(result.ok).toBe(true);
+ if (!result.ok) throw new Error(result.reason);
+ expect(result.connection.externalModelId).toBe(requested);
+ expect(result.connection.wire).toEqual(requested === id ? plainWire : contributorWire);
+ expect(result.connection.generationId).toBe(generation);
+ expect(
+ resolver.connectionRequestUrl(
+ result.connection,
+ requested === id ? "responses" : "chat-completions"
+ )
+ ).toBe(`https://api.meta.ai/v1/${requested === id ? "responses" : "chat/completions"}`);
+ }
+);
+
+test("G3: implicit selection and borrowed owner wire exclude contributor-first connection", () => {
+ const gateway = connection(id, plainWire, "openrouter", "gateway");
+ gateway.wire = { status: "unknown", evidence: [] };
+ install([connection(`${id}-contributor`, contributorWire), connection(id, plainWire), gateway]);
+ const result = resolver.resolveConnection("openrouter", id, path);
+ expect(result.ok).toBe(true);
+ if (!result.ok) throw new Error(result.reason);
+ expect(result.connection.externalModelId).toBe(id);
+ expect(result.connection.ownerWire).toEqual(plainWire);
+ expect(result.connection.ownerWire).not.toEqual(contributorWire);
+});
+
+test("G3: opt-in-only Meta connection is unavailable for an implicit plain request", () => {
+ install([connection(`${id}-contributor`, contributorWire)]);
+ expect(resolver.resolveConnection("meta", id, path)).toEqual({
+ ok: false,
+ reason: "no-connection",
+ });
+});
diff --git a/packages/cli/src/providers/content-use.test.ts b/packages/cli/src/providers/content-use.test.ts
new file mode 100644
index 00000000..1d2bbb1e
--- /dev/null
+++ b/packages/cli/src/providers/content-use.test.ts
@@ -0,0 +1,120 @@
+import { describe, expect, test } from "bun:test";
+import { readFileSync, readdirSync } from "node:fs";
+import { join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { AggregatorEntry } from "../model-loader.js";
+import {
+ allConnections,
+ isOptInWireId,
+ normaliseCatalogPayload,
+ splitOptInConnections,
+} from "./content-use.js";
+
+// Wire ids from wire-capture §4; contributor-free is architecture §3(b).
+function connection(id: string): AggregatorEntry {
+ return {
+ sourceProviderId: "meta",
+ sourceCollectorId: "meta",
+ confidence: "api_official",
+ routeStatus: "mapped",
+ route: { routeId: "meta", routeProfileId: "direct-api" },
+ externalModelId: id,
+ };
+}
+
+describe("G1: content-use opt-in is explicit", () => {
+ test.each([
+ ["muse-spark-1.3-contributor", true],
+ ["meta/muse-spark-1.3-CONTRIBUTOR", true],
+ ["meta/muse-spark-1.3-Contributor-Free", true],
+ ["muse-spark-1.3", false],
+ ["muse-wonder-full-1.0", false],
+ ["muse-spark-1.3-contributor-preview", false],
+ ["contributor/muse-spark-1.3", false],
+ ["muse-spark-1.3-contributor/ordinary", false],
+ ["", false],
+ ])("G1: %s → %s", (id, expected) => {
+ expect(isOptInWireId(id)).toBe(expected);
+ });
+
+ test("G1: contributor-first partition is lossless and idempotent", () => {
+ const opt = connection("muse-spark-1.3-contributor");
+ const plain = connection("muse-spark-1.3");
+ const free = connection("muse-spark-1.3-contributor-free");
+ const entry = { modelId: "muse-spark-1.3", aggregators: [opt, plain, free] };
+ const split = splitOptInConnections(entry);
+ expect(split.aggregators).toEqual([plain]);
+ expect(split.optInConnections).toEqual([opt, free]);
+ expect(splitOptInConnections(split)).toEqual(split);
+ expect(allConnections(split)).toEqual([plain, opt, free]);
+ expect(
+ allConnections(split).find((row) => row.externalModelId === opt.externalModelId)
+ ).toEqual(opt);
+ });
+
+ test("G1: payload normalization retains model metadata and plain connections", () => {
+ const plain = connection("muse-wonder-full-1.0");
+ const opt = connection("muse-wonder-full-1.0-contributor");
+ const payload = {
+ models: [{ modelId: "muse-wonder-full-1.0", provider: "meta", aggregators: [opt, plain] }],
+ };
+ const normalized = normaliseCatalogPayload(payload);
+ expect(normalized.models[0]?.aggregators).toEqual([plain]);
+ expect(normalized.models[0]?.provider).toBe("meta");
+ expect(allConnections(normalized.models[0]!)).toEqual([plain, opt]);
+ expect(normaliseCatalogPayload(normalized)).toEqual(normalized);
+ });
+});
+
+// These guards inspect the final repository ONLY when the runner executes them.
+// The authoring sandbox contains no implementation source.
+function sources(root: string): string[] {
+ return readdirSync(root, { withFileTypes: true }).flatMap((entry) => {
+ const path = join(root, entry.name);
+ if (entry.isDirectory()) return sources(path);
+ return /\.tsx?$/.test(entry.name) && !/\.test\.tsx?$/.test(entry.name) ? [path] : [];
+ });
+}
+
+test("G1: content-use.ts owns the sole contributor suffix regex", () => {
+ const root = fileURLToPath(new URL("./", import.meta.url));
+ const occurrences = sources(root).flatMap((path) => {
+ const text = readFileSync(path, "utf8");
+ return [...text.matchAll(/\/(?:\\.|[^/\r\n])+\/[dgimsuvy]*/g)]
+ .filter((match) => match[0].includes("contributor") && match[0].includes("$"))
+ .map(() => relative(root, path));
+ });
+ expect(occurrences).toEqual(["content-use.ts"]);
+});
+
+test("G1: aggregators readers require architecture review", () => {
+ const root = fileURLToPath(new URL("../", import.meta.url));
+ const approved = new Set([
+ "providers/content-use.ts",
+ "providers/catalog-client.ts",
+ "adapters/model-catalog.ts",
+ "providers/route-candidates.ts",
+ "providers/connection-resolver.ts",
+ "providers/model-availability.ts",
+ "model-selector.ts",
+ "model-loader.ts",
+ "handlers/native-handler-advisor.ts",
+ "services/pricing-cache.ts",
+ "session/baseline-pricing.ts",
+ "providers/model-catalog.ts",
+ "providers/catalog-query.ts",
+ "providers/all-models-cache.ts",
+ ]);
+ const unexpected = sources(root)
+ .filter((path) => {
+ const text = readFileSync(path, "utf8")
+ .replace(/\/\*[\s\S]*?\*\//g, "")
+ .replace(/^\s*\/\/.*$/gm, "");
+ return (
+ /\.aggregators\b|\[\s*["\']aggregators["\']\s*\]/.test(text) &&
+ !approved.has(relative(root, path))
+ );
+ })
+ .map((path) => relative(root, path));
+ expect(unexpected).toEqual([]);
+});
diff --git a/packages/cli/src/providers/meta-muse/muse-credentials.test.ts b/packages/cli/src/providers/meta-muse/muse-credentials.test.ts
new file mode 100644
index 00000000..67b71dd0
--- /dev/null
+++ b/packages/cli/src/providers/meta-muse/muse-credentials.test.ts
@@ -0,0 +1,416 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// Explicit temporary directories and complete Keychain fakes isolate the core.
+let home: string;
+let billing: typeof import("../../auth/credentials/billing-probe.js");
+let savedFetch: typeof fetch;
+let savedDisable: string | undefined;
+let core: typeof import("./muse-credentials.js");
+let store: typeof import("./muse-store.js");
+let roles: typeof import("../../auth/credentials/prompt-role.js");
+let kc: typeof import("./muse-keychain.js");
+let generic: typeof import("../keychain.js");
+let mintModule: typeof import("./muse-mint.js");
+let now: number;
+let calls: string[];
+let reads: number;
+let status: number;
+let body: Record<string, unknown>;
+const OWN = "dca:TESTTOKENOWN0001";
+const BORROWED = "dca:TESTTOKENBORROWED0001";
+const KEYCHAIN = "dca:TESTTOKEN0001";
+const KEY = "LLM|TESTKEY0001";
+// §8 response fields with inert ASCII credentials; source/key changes are explicit mutations.
+function capturedMint(): Record<string, unknown> {
+ return {
+ api_key: KEY,
+ base_url: "https://api.meta.ai/v1",
+ has_payment_method: true,
+ require_payment: false,
+ is_subs_active: true,
+ can_subscribe: false,
+ show_subs_upsell: true,
+ user_full_name: "TEST USER",
+ user_email: "[email protected]",
+ user_avatar_url: null,
+ payment_method: "TESTPAYMENT",
+ action_url: null,
+ subs_tier_id: "<tier-id>",
+ subs_tier_name: "Muse Code Power Usage",
+ is_subs_upgrade_available: true,
+ subs_usage: {
+ window: { used_percent: 1, window_duration_mins: 300, resets_at: 1792136182 },
+ weekly: { used_percent: 0, resets_at: 1792368000 },
+ tier: "<tier-id>",
+ },
+ };
+}
+function restore(name: string, value: string | undefined) {
+ if (value === undefined) delete process.env[name];
+ else process.env[name] = value;
+}
+function installCore(overrides: Partial<import("./muse-credentials.js").MuseCoreDeps> = {}) {
+ core.setMuseCoreTestDeps({
+ readStore: (kind) => store.readMuseStore(kind, home),
+ writeBorrowedCopy: (token, tier) =>
+ store.writeBorrowedCopy(token, tier, home, () => new Date(1000000)),
+ dir: () => home,
+ now: () => now,
+ mint: async (token) => {
+ calls.push(token);
+ return mintModule.mintMuseApiKey(token, {
+ fetch: Object.assign(async () => Response.json(body, { status }), {
+ preconnect: () => {},
+ }) as typeof fetch,
+ });
+ },
+ keychainLogin: async (use) => {
+ reads++;
+ return { kind: "used", value: await use(KEYCHAIN), source: "keychain" };
+ },
+ ...overrides,
+ });
+}
+beforeEach(async () => {
+ savedDisable = process.env.CLAUDISH_DISABLE_KEYCHAIN;
+ home = mkdtempSync(join(tmpdir(), "muse-core-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("../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("./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("../../auth/credentials/prompt-role.js");
+ store = await import("./muse-store.js");
+ mintModule = await import("./muse-mint.js");
+ core = await import("./muse-credentials.js");
+ roles._resetCredentialPromptRoleForTest();
+ core.resetMuseCredentialState();
+ now = 1000000;
+ calls = [];
+ reads = 0;
+ status = 200;
+ body = capturedMint();
+ installCore();
+ billing = await import("../../auth/credentials/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 });
+});
+function seed() {
+ store.writeMuseStore("own-login", { access_token: OWN }, home);
+ store.writeBorrowedCopy(BORROWED, "Muse Code Power Usage", home);
+}
+function bytes(kind: "own-login" | "borrowed-copy") {
+ return readFileSync(store.museStorePath(kind, home), "utf8");
+}
+
+describe("C1/C3/C4: source selection and entitlement", () => {
+ test("C1/C4: never role uses own login before borrowed without Keychain", async () => {
+ seed();
+ await core.ensureMuseCredentialReady({ prompt: false });
+ expect(calls).toEqual([OWN]);
+ expect(reads).toBe(0);
+ expect(core.currentMuseState()).toMatchObject({
+ source: "claudish-login",
+ key: KEY,
+ accessToken: OWN,
+ subsTierName: "Muse Code Power Usage",
+ });
+ });
+ for (const rejected of [401, 403]) {
+ test(`C1: mint ${rejected} advances own → borrowed → permitted Keychain`, async () => {
+ seed();
+ roles.setCredentialPromptRole("interactive-launch");
+ installCore({
+ mint: async (token) => {
+ calls.push(token);
+ return mintModule.mintMuseApiKey(token, {
+ fetch: Object.assign(
+ async () =>
+ token === KEYCHAIN
+ ? Response.json(capturedMint())
+ : Response.json(
+ { error: { type: "invalid_api_key", message: "Unauthorized" } },
+ { status: rejected }
+ ),
+ { preconnect: () => {} }
+ ) as typeof fetch,
+ });
+ },
+ });
+ await core.ensureMuseCredentialReady({ prompt: true });
+ expect(calls).toEqual([OWN, BORROWED, KEYCHAIN]);
+ expect(reads).toBe(1);
+ expect(core.currentMuseState()).toMatchObject({
+ source: "keychain",
+ key: KEY,
+ subsTierName: "Muse Code Power Usage",
+ });
+ expect(store.readMuseStore("borrowed-copy", home)).toMatchObject({
+ access_token: KEYCHAIN,
+ schema: 1,
+ subs_tier_name: "Muse Code Power Usage",
+ });
+ });
+ }
+ for (const failure of [429, 503, "unknown"] as const) {
+ test(`C1: ${failure} preserves both files and does not change source`, async () => {
+ seed();
+ const own = bytes("own-login");
+ const borrowed = bytes("borrowed-copy");
+ roles.setCredentialPromptRole("interactive-launch");
+ const unknown = new Error("unclassified mint failure");
+ if (failure === "unknown")
+ installCore({
+ mint: async (token) => {
+ calls.push(token);
+ throw unknown;
+ },
+ });
+ else {
+ status = failure;
+ body = { error: { type: "invalid_api_key", message: "Unauthorized" } };
+ }
+ const operation = core.ensureMuseCredentialReady({ prompt: true });
+ if (failure === "unknown") await expect(operation).rejects.toBe(unknown);
+ else await expect(operation).rejects.toThrow();
+ expect(calls).toEqual([OWN]);
+ expect(reads).toBe(0);
+ expect(bytes("own-login")).toBe(own);
+ expect(bytes("borrowed-copy")).toBe(borrowed);
+ expect(core.currentMuseState()).toBeUndefined();
+ });
+ }
+ for (const wrapped of [false, true]) {
+ test(`C1: actual refused fetch${wrapped ? " wrapped as cause" : ""} preserves sources`, async () => {
+ seed();
+ roles.setCredentialPromptRole("interactive-launch");
+ const own = bytes("own-login");
+ const borrowed = bytes("borrowed-copy");
+ const server = Bun.serve({
+ hostname: "127.0.0.1",
+ port: 0,
+ fetch: () => new Response("unused"),
+ });
+ const url = `http://127.0.0.1:${server.port}/mint`;
+ await server.stop(true);
+ let refusal: unknown;
+ try {
+ await fetch(url);
+ } catch (error) {
+ refusal = error;
+ }
+ expect(refusal).toBeInstanceOf(Error);
+ const failure = wrapped ? new Error("mint request failed", { cause: refusal }) : refusal;
+ installCore({
+ mint: async (token) => {
+ calls.push(token);
+ throw failure;
+ },
+ });
+ await expect(core.ensureMuseCredentialReady({ prompt: true })).rejects.toBe(failure);
+ expect(calls).toEqual([OWN]);
+ expect(reads).toBe(0);
+ expect(bytes("own-login")).toBe(own);
+ expect(bytes("borrowed-copy")).toBe(borrowed);
+ expect(core.currentMuseState()).toBeUndefined();
+ });
+ }
+ test("C4: borrowed file works in never role; missing files give exact team/MCP guidance", async () => {
+ store.writeBorrowedCopy(BORROWED, "Muse Code Power Usage", home);
+ await core.ensureMuseCredentialReady({ prompt: false });
+ expect(core.currentMuseState()).toMatchObject({ source: "borrowed-copy", key: KEY });
+ expect(calls).toEqual([BORROWED]);
+ expect(reads).toBe(0);
+ store.deleteMuseStores(home);
+ core.resetMuseCredentialState();
+ await expect(core.ensureMuseCredentialReady({ prompt: false })).rejects.toThrow(
+ "muse@ in a team slot / MCP session needs a claudish login: run `claudish login muse`, or one interactive `claudish --model muse@<model>` and allow Keychain access."
+ );
+ expect(reads).toBe(0);
+ expect(calls).toEqual([BORROWED]);
+ });
+ test("C3: approval alone does not copy a login before confirming mint", async () => {
+ roles.setCredentialPromptRole("interactive-launch");
+ let release!: (value: import("./muse-mint.js").MuseMint) => void;
+ const deferred = new Promise<import("./muse-mint.js").MuseMint>((resolve) => {
+ release = resolve;
+ });
+ let entered!: () => void;
+ const started = new Promise<void>((resolve) => {
+ entered = resolve;
+ });
+ installCore({
+ mint: async () => {
+ entered();
+ return deferred;
+ },
+ });
+ const pending = core.ensureMuseCredentialReady({ prompt: true });
+ await started;
+ expect(existsSync(store.museStorePath("borrowed-copy", home))).toBe(false);
+ expect(core.currentMuseState()).toBeUndefined();
+ release(mintModule.interpretMint(capturedMint()));
+ await pending;
+ expect(store.readMuseStore("borrowed-copy", home)).toMatchObject({
+ access_token: KEYCHAIN,
+ subs_tier_name: "Muse Code Power Usage",
+ });
+ expect(core.currentMuseState()?.key).toBe(KEY);
+ });
+ for (const failure of ["denied", "transient", "unsubscribed"] as const) {
+ test(`C3: ${failure} never writes a borrowed copy or installs a key`, async () => {
+ roles.setCredentialPromptRole("interactive-launch");
+ if (failure === "denied")
+ installCore({ keychainLogin: async () => ({ kind: "failed" as const, detail: "denied" }) });
+ else if (failure === "transient") {
+ status = 503;
+ } else body.is_subs_active = false;
+ await expect(core.ensureMuseCredentialReady({ prompt: true })).rejects.toThrow(
+ failure === "unsubscribed"
+ ? "https://accountscenter.meta.com/muse_code/?ep=no_payg"
+ : undefined
+ );
+ expect(existsSync(store.museStorePath("borrowed-copy", home))).toBe(false);
+ expect(core.currentMuseState()).toBeUndefined();
+ if (failure === "denied") expect(calls).toEqual([]);
+ });
+ }
+});
+
+describe("C2: process cache, TTL and rejected-key concurrency", () => {
+ test("concurrent resolves mint once and repeated requests reuse the key", async () => {
+ seed();
+ let release!: (v: import("./muse-mint.js").MuseMint) => void;
+ const deferred = new Promise<import("./muse-mint.js").MuseMint>((resolve) => {
+ release = resolve;
+ });
+ let entered!: () => void;
+ const started = new Promise<void>((resolve) => {
+ entered = resolve;
+ });
+ installCore({
+ mint: async (token) => {
+ calls.push(token);
+ entered();
+ return deferred;
+ },
+ });
+ const first = core.ensureMuseCredentialReady({ prompt: false });
+ await started;
+ const second = core.ensureMuseCredentialReady({ prompt: false });
+ release(mintModule.interpretMint(capturedMint()));
+ await Promise.all([first, second]);
+ await core.ensureMuseCredentialReady({ prompt: false });
+ expect(calls).toEqual([OWN]);
+ expect(core.currentMuseState()?.key).toBe(KEY);
+ });
+ test("exactly 30 minutes reuses; one millisecond later requires successful confirmation", async () => {
+ seed();
+ await core.ensureMuseCredentialReady({ prompt: false });
+ now += 30 * 60_000;
+ await core.ensureMuseCredentialReady({ prompt: false });
+ expect(calls).toEqual([OWN]);
+ now++;
+ status = 503;
+ await expect(core.ensureMuseCredentialReady({ prompt: false })).rejects.toThrow();
+ expect(calls).toEqual([OWN, OWN]);
+ status = 200;
+ body.api_key = "LLM|TESTKEY0002";
+ await core.ensureMuseCredentialReady({ prompt: false });
+ expect(calls).toEqual([OWN, OWN, OWN]);
+ expect(core.currentMuseState()).toMatchObject({ key: body.api_key, confirmedAt: now });
+ });
+ test("concurrent 401s share remint; a stale rejection cannot replace the newer key", async () => {
+ seed();
+ await core.ensureMuseCredentialReady({ prompt: false });
+ const generation = core.currentMuseState()!.generation;
+ const next = { ...mintModule.interpretMint(capturedMint()), apiKey: "LLM|TESTKEY0002" };
+ let release!: () => void;
+ const gate = new Promise<void>((resolve) => {
+ release = resolve;
+ });
+ let entered!: () => void;
+ const started = new Promise<void>((resolve) => {
+ entered = resolve;
+ });
+ installCore({
+ mint: async (token) => {
+ calls.push(token);
+ entered();
+ await gate;
+ return next;
+ },
+ });
+ const first = core.forceRefreshMuseApiKey({ rejectedKey: KEY, prompt: false });
+ await started;
+ const second = core.forceRefreshMuseApiKey({ rejectedKey: KEY, prompt: false });
+ release();
+ await Promise.all([first, second]);
+ expect(calls).toEqual([OWN, OWN]);
+ expect(core.currentMuseState()?.key).toBe(next.apiKey);
+ expect(core.currentMuseState()!.generation).toBeGreaterThan(generation);
+ const current = core.currentMuseState()!.generation;
+ await core.forceRefreshMuseApiKey({ rejectedKey: KEY, prompt: false });
+ expect(calls).toEqual([OWN, OWN]);
+ expect(core.currentMuseState()).toMatchObject({ key: next.apiKey, generation: current });
+ });
+ test("a failed remint cannot revive the rejected key from process cache", async () => {
+ store.writeMuseStore("own-login", { access_token: OWN }, home);
+ await core.ensureMuseCredentialReady({ prompt: false });
+ status = 401;
+ body = { error: { type: "invalid_api_key", message: "Unauthorized" } };
+ await expect(core.forceRefreshMuseApiKey({ rejectedKey: KEY, prompt: false })).rejects.toThrow(
+ "login"
+ );
+ await expect(core.ensureMuseCredentialReady({ prompt: false })).rejects.toThrow("login");
+ expect(calls.length).toBeGreaterThan(1);
+ expect(reads).toBe(0);
+ expect(store.readMuseStore("own-login", home)?.access_token).toBe(OWN);
+ });
+});
diff --git a/packages/cli/src/providers/meta-muse/muse-keychain.test.ts b/packages/cli/src/providers/meta-muse/muse-keychain.test.ts
new file mode 100644
index 00000000..9a09e1ec
--- /dev/null
+++ b/packages/cli/src/providers/meta-muse/muse-keychain.test.ts
@@ -0,0 +1,532 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+ existsSync,
+ mkdirSync,
+ mkdtempSync,
+ readFileSync,
+ readdirSync,
+ rmSync,
+ writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+
+const children: ReturnType<typeof Bun.spawn>[] = [];
+async function waitForChild(child: ReturnType<typeof Bun.spawn>) {
+ let timer: ReturnType<typeof setTimeout> | undefined;
+ try {
+ return await Promise.race([
+ child.exited,
+ new Promise<number>((resolve) => {
+ timer = setTimeout(() => {
+ child.kill();
+ resolve(124);
+ }, 4000);
+ }),
+ ]);
+ } finally {
+ clearTimeout(timer);
+ }
+}
+
+let home: string;
+let billing: typeof import("../../auth/credentials/billing-probe.js");
+let savedFetch: typeof fetch;
+let savedDisable: string | undefined;
+let savedFile: string | undefined;
+let generic: typeof import("../keychain.js");
+let kc: typeof import("./muse-keychain.js");
+let store: typeof import("./muse-store.js");
+let roles: typeof import("../../auth/credentials/prompt-role.js");
+let core: typeof import("./muse-credentials.js");
+let now: number;
+let commands: string[][];
+let presenceCode: number;
+let savedKill: typeof process.kill;
+let signals: Array<string | number | undefined>;
+const TOKEN = "dca:TESTTOKEN0001";
+// Corrected §7 schema. The stored api_key must never become a credential.
+const SECRET = JSON.stringify({
+ secret_schema_version: 1,
+ api_key: "LLM|TESTKEY0001",
+ access_token: TOKEN,
+});
+function restore(name: string, value: string | undefined) {
+ if (value === undefined) delete process.env[name];
+ else process.env[name] = value;
+}
+// The generic seam is always fully fake; these wrappers exercise its public API.
+function installGeneric(overrides: Partial<import("../keychain.js").KeychainDeps> = {}) {
+ generic.setKeychainTestDeps({
+ platform: () => "darwin",
+ run: (args) => {
+ commands.push(args);
+ return { code: 44, stdout: "", stderr: "absent" };
+ },
+ runAsync: async (args) => {
+ commands.push(args);
+ return { code: presenceCode, stdout: "", stderr: "" };
+ },
+ spawnAsync: (args) => {
+ commands.push(args);
+ return {
+ pid: 12345,
+ done: Promise.resolve(
+ args.includes("-w")
+ ? { code: 0, stdout: SECRET, stderr: "" }
+ : { code: presenceCode, stdout: "", stderr: presenceCode ? "denied or absent" : "" }
+ ),
+ };
+ },
+ ...overrides,
+ });
+}
+function installKeychain(overrides: Partial<import("./muse-keychain.js").MuseKeychainDeps> = {}) {
+ kc.setMuseKeychainTestDeps({
+ presence: (query) => generic.findGenericPasswordPresence(query),
+ startRead: (query) => generic.startGenericPasswordRead(query),
+ now: () => now,
+ dir: () => home,
+ env: () => ({}),
+ pid: () => 98765,
+ isAlive: () => false,
+ sleep: async (ms) => {
+ now += ms;
+ await Promise.resolve();
+ },
+ ...overrides,
+ });
+}
+beforeEach(async () => {
+ savedDisable = process.env.CLAUDISH_DISABLE_KEYCHAIN;
+ savedFile = process.env.CLAUDISH_MUSE_KEYCHAIN_FILE;
+ home = mkdtempSync(join(tmpdir(), "muse-keychain-test-"));
+ delete process.env.CLAUDISH_DISABLE_KEYCHAIN;
+ delete process.env.CLAUDISH_MUSE_KEYCHAIN_FILE;
+ commands = [];
+ now = 10000;
+ presenceCode = 0;
+ signals = [];
+ savedKill = process.kill;
+ process.kill = ((_pid: number, signal?: string | number) => {
+ signals.push(signal);
+ return true;
+ }) as typeof process.kill;
+ 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("../keychain.js");
+ installGeneric();
+ kc = await import("./muse-keychain.js");
+ store = await import("./muse-store.js");
+ kc.resetMuseKeychainState();
+ installKeychain();
+ roles = await import("../../auth/credentials/prompt-role.js");
+ roles._resetCredentialPromptRoleForTest();
+ core = await import("./muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps({
+ dir: () => home,
+ now: () => now,
+ readStore: (kind) => store.readMuseStore(kind, home),
+ writeBorrowedCopy: (token, tier) =>
+ store.writeBorrowedCopy(token, tier, home, () => new Date(now)),
+ mint: async () => {
+ throw new Error("unexpected mint");
+ },
+ keychainLogin: async () => {
+ throw new Error("unexpected core Keychain read");
+ },
+ });
+ billing = await import("../../auth/credentials/billing-probe.js");
+ billing.clearSignedArm();
+});
+afterEach(async () => {
+ for (const child of children.splice(0)) {
+ if (child.exitCode === null) child.kill();
+ await child.exited;
+ }
+ billing.clearSignedArm();
+ globalThis.fetch = savedFetch;
+ process.kill = savedKill;
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(null);
+ roles._resetCredentialPromptRoleForTest();
+ kc.resetMuseKeychainState();
+ kc.setMuseKeychainTestDeps(null);
+ generic.invalidateKeychainCache();
+ generic.setKeychainTestDeps(null);
+ restore("CLAUDISH_DISABLE_KEYCHAIN", savedDisable);
+ restore("CLAUDISH_MUSE_KEYCHAIN_FILE", savedFile);
+ rmSync(home, { recursive: true, force: true });
+ expect(signals.filter((signal) => signal !== 0)).toEqual([]);
+});
+function assertReadOnly() {
+ expect(signals.filter((signal) => signal !== 0)).toEqual([]);
+ for (const args of commands) {
+ expect(args[0]).toBe("find-generic-password");
+ expect(args).toContain("ai.meta.dev.credentials");
+ expect(args).toContain("meta");
+ expect(args).not.toContain("delete-generic-password");
+ expect(args).not.toContain("add-generic-password");
+ }
+}
+
+describe("K1: metadata presence and corrected secret schema", () => {
+ test("presence uses exact service/account without -w and memoizes for 3 seconds", async () => {
+ expect(kc.MUSE_KEYCHAIN_SERVICE).toBe("ai.meta.dev.credentials");
+ expect(kc.MUSE_KEYCHAIN_ACCOUNT).toBe("meta");
+ expect(kc.museKeychainPresenceCached()).toBe("unknown");
+ expect(commands).toEqual([]);
+ expect(await kc.museKeychainPresence()).toBe("present");
+ expect(await kc.museKeychainPresence()).toBe("present");
+ now += 2999;
+ expect(await kc.museKeychainPresence()).toBe("present");
+ expect(commands.filter((args) => !args.includes("-w"))).toHaveLength(1);
+ presenceCode = 44;
+ now += 2;
+ expect(await kc.museKeychainPresence()).toBe("absent");
+ expect(commands.filter((args) => !args.includes("-w"))).toHaveLength(2);
+ expect(kc.museKeychainPresenceCached()).toBe("absent");
+ for (const args of commands) {
+ expect(args).not.toContain("-w");
+ expect(args).not.toContain("-g");
+ }
+ assertReadOnly();
+ });
+ test("K1: Providers tab render and display use metadata only in an isolated HOME child", async () => {
+ // The script is a sibling of HOME; application mutations are confined to HOME.
+ // The existing afterEach removes this entire test-owned root.
+ const tempHome = join(home, "home");
+ mkdirSync(tempHome);
+ const scriptPath = join(home, "render-scenario.ts");
+ const script = `
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import { homedir } from "node:os";
+import { resolve, relative, isAbsolute } from "node:path";
+import { fileURLToPath } from "node:url";
+import { syncBuiltinESMExports } from "node:module";
+const realExit = process.exit.bind(process);
+const realFetch = globalThis.fetch;
+try {
+const tempHome = process.env.HOME;
+assert.equal(homedir(), tempHome);
+const isInside = path => {
+ const rel = relative(tempHome, resolve(path instanceof URL ? fileURLToPath(path) : path));
+ return rel === "" || (rel !== ".." && !rel.startsWith("../") && !isAbsolute(rel));
+};
+// Installed before application imports. Any filesystem mutation outside HOME fails
+// before it reaches the filesystem, including an atomic rename's destination.
+const writes = [];
+function checkWrite(path) {
+ assert.ok(typeof path === "string" || path instanceof URL, "untracked write target");
+ assert.ok(isInside(path), "write outside child HOME: " + path);
+ writes.push(String(path));
+}
+for (const [name, indices] of Object.entries({
+ writeFile: [0], appendFile: [0], mkdir: [0], rm: [0], rmdir: [0], unlink: [0],
+ rename: [0, 1], copyFile: [1], chmod: [0], chown: [0], truncate: [0],
+ utimes: [0], link: [1], symlink: [1], mkdtemp: [0]
+})) {
+ for (const api of [name, name + "Sync"]) {
+ if (typeof fs[api] !== "function") continue;
+ const original = fs[api];
+ fs[api] = function (...args) { for (const i of indices) checkWrite(args[i]); return original.apply(this, args); };
+ }
+ if (typeof fs.promises[name] === "function") {
+ const original = fs.promises[name];
+ fs.promises[name] = function (...args) { for (const i of indices) checkWrite(args[i]); return original.apply(this, args); };
+ }
+}
+for (const target of [fs, fs.promises]) {
+ for (const name of ["open", "openSync", "createWriteStream"]) {
+ if (typeof target[name] !== "function") continue;
+ const original = target[name];
+ target[name] = function (path, flags, ...args) {
+ if (name === "createWriteStream" || (typeof flags === "number" ? (flags & (fs.constants.O_WRONLY | fs.constants.O_RDWR | fs.constants.O_CREAT | fs.constants.O_TRUNC | fs.constants.O_APPEND)) !== 0 : /[wa+]/.test(flags ?? "r"))) checkWrite(path);
+ return original.call(this, path, flags, ...args);
+ };
+ }
+}
+const originalBunWrite = Bun.write;
+Bun.write = (path, ...args) => { checkWrite(path); return originalBunWrite(path, ...args); };
+syncBuiltinESMExports();
+// CLI logging cannot pollute the single JSON result line.
+console.log = (...args) => console.error(...args);
+const { existsSync, readFileSync, writeFileSync } = fs;
+const join = (...parts) => resolve(...parts);
+const commands = [];
+const urls = [];
+const exitCodes = [];
+process.exit = code => { exitCodes.push(code); };
+globalThis.fetch = Object.assign(async (input, init) => {
+ const url = new URL(input instanceof Request ? input.url : String(input));
+ if (url.protocol !== "http:" && url.protocol !== "https:") return realFetch(input, init);
+ urls.push(url.href);
+ throw new Error("unexpected network request");
+}, { preconnect() {} });
+
+const generic = await import(${JSON.stringify(resolve(import.meta.dir, "../keychain.js"))});
+generic.setKeychainTestDeps({ platform: () => "darwin",
+ run: args => { commands.push(args); return { code: 44, stdout: "", stderr: "absent" }; },
+ runAsync: async args => { commands.push(args); return { code: 0, stdout: "", stderr: "" }; },
+ spawnAsync: args => { commands.push(args); return { pid: undefined,
+ done: Promise.resolve({ code: 0, stdout: "", stderr: "" }) }; } });
+const kc = await import(${JSON.stringify(resolve(import.meta.dir, "./muse-keychain.js"))});
+const store = await import(${JSON.stringify(resolve(import.meta.dir, "./muse-store.js"))});
+const dir = store.defaultMuseStoreDir();
+assert.ok(isInside(dir));
+kc.resetMuseKeychainState();
+kc.setMuseKeychainTestDeps({ dir: () => dir, env: () => ({}), now: () => 10000,
+ sleep: async () => {}, pid: () => 98765, isAlive: () => false,
+ presence: query => generic.findGenericPasswordPresence(query),
+ startRead: () => { throw new Error("render must not read Keychain value"); } });
+const core = await import(${JSON.stringify(resolve(import.meta.dir, "./muse-credentials.js"))});
+const roles = await import(${JSON.stringify(resolve(import.meta.dir, "../../auth/credentials/prompt-role.js"))});
+core.resetMuseCredentialState(); roles._resetCredentialPromptRoleForTest();
+core.setMuseCoreTestDeps({ dir: () => dir, now: () => 10000,
+ readStore: kind => store.readMuseStore(kind, dir),
+ writeBorrowedCopy: (token, tier) => store.writeBorrowedCopy(token, tier, dir),
+ mint: async () => { throw new Error("unexpected mint"); },
+ keychainLogin: async () => { throw new Error("unexpected core Keychain read"); } });
+const providers = await import(${JSON.stringify(resolve(import.meta.dir, "../../tui/providers.js"))});
+const { ProvidersContent } = await import(${JSON.stringify(resolve(import.meta.dir, "../../tui/components/ProvidersContent.js"))});
+const provider = providers.getProviderDefs().find(p => p.catalogName === "meta-muse-code");
+assert.ok(provider, "Muse Providers tab entry missing");
+const config = { version: "1", defaultProfile: "", profiles: {}, apiKeys: {} };
+const readyBefore = providers.providerIsReadyForDisplay(provider, config, {});
+assert.equal(readyBefore, false);
+assert.equal(providers.providerAuthCapabilities(provider, config).oauth.supported, true);
+assert.equal(core.museCredentialStatus(dir), "unknown");
+function render(animTick) {
+ const rendered = ProvidersContent({ config, displayProviders: [provider], providerIndex: 0,
+ testResults: {}, localLiveness: {}, contentH: 20, isInputMode: false, animTick });
+ assert.notEqual(rendered, null); assert.notEqual(rendered, undefined);
+}
+render(0);
+assert.deepEqual(commands, []);
+assert.equal(await kc.museKeychainPresence(), "present");
+const count = commands.length;
+assert.ok(count > 0);
+const readyAfter = providers.providerIsReadyForDisplay(provider, config, {});
+assert.equal(readyAfter, true);
+const status = core.museCredentialStatus(dir);
+assert.equal(status, "keychain");
+assert.notEqual(providers.providerCredentialNote(provider), undefined);
+render(1);
+assert.equal(commands.length, count);
+assert.ok(commands.every(args => args[0] === "find-generic-password" && !args.includes("-w")));
+assert.deepEqual(urls, []);
+assert.ok(writes.every(isInside));
+const billing = await import(${JSON.stringify(resolve(import.meta.dir, "../../auth/credentials/billing-probe.js"))});
+billing.clearSignedArm();
+core.resetMuseCredentialState(); core.setMuseCoreTestDeps(null);
+kc.resetMuseKeychainState(); kc.setMuseKeychainTestDeps(null);
+generic.invalidateKeychainCache(); generic.setKeychainTestDeps(null);
+roles._resetCredentialPromptRoleForTest();
+process.stdout.write(JSON.stringify({ readyBefore, readyAfter, status, renders: 2,
+ commands: commands.length, valueReads: commands.filter(args => args.includes("-w")).length,
+ requests: urls.length, outsideWrites: writes.filter(path => !isInside(path)) }) + "\\n");
+realExit(0);
+} catch (error) { console.error(error); realExit(1); }
+`;
+ writeFileSync(scriptPath, script);
+ const child = Bun.spawn([process.execPath, scriptPath], {
+ cwd: tempHome,
+ env: {
+ ...process.env,
+ HOME: tempHome,
+ TMPDIR: tempHome,
+ CLAUDISH_DISABLE_KEYCHAIN: "1",
+ CLAUDISH_DISABLE_CATALOG_WARM: "1",
+ CLAUDISH_MUSE_KEYCHAIN_FILE: "",
+ },
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ children.push(child);
+ const [stdout, stderr, code] = await Promise.all([
+ new Response(child.stdout).text(),
+ new Response(child.stderr).text(),
+ waitForChild(child),
+ ]);
+ expect({ code, stderr: code === 0 ? "" : stderr }).toEqual({ code: 0, stderr: "" });
+ const lines = stdout.trim().split("\n");
+ expect(lines).toHaveLength(1);
+ const result = JSON.parse(lines[0]!);
+ expect(result).toEqual({
+ readyBefore: false,
+ readyAfter: true,
+ status: "keychain",
+ renders: 2,
+ commands: result.commands,
+ valueReads: 0,
+ requests: 0,
+ outsideWrites: [],
+ });
+ expect(result.commands).toBeGreaterThan(0);
+ expect(readFileSync(scriptPath, "utf8")).toBe(script);
+ expect(readdirSync(home).sort()).toEqual(["home", "render-scenario.ts"]);
+ });
+ test("parses only nonempty access_token; ignores api_key", () => {
+ expect(kc.parseMuseKeychainValue(SECRET)).toBe(TOKEN);
+ for (const raw of [
+ "not json",
+ "null",
+ "{}",
+ JSON.stringify({ secret_schema_version: 1, api_key: "LLM|TESTKEY0001" }),
+ JSON.stringify({ secret_schema_version: 1, access_token: "", api_key: "LLM|TESTKEY0001" }),
+ ]) {
+ expect(kc.parseMuseKeychainValue(raw)).toBeNull();
+ }
+ expect(commands).toEqual([]);
+ });
+ test("never role denies the value read with zero spawns", async () => {
+ expect(roles.credentialPromptRole()).toBe("never");
+ let used = 0;
+ expect(
+ await kc.withMuseKeychainLogin(async () => {
+ used++;
+ })
+ ).toEqual({ kind: "not-allowed" });
+ expect(used).toBe(0);
+ expect(commands).toEqual([]);
+ assertReadOnly();
+ });
+ test("value read supplies the durable token and cannot mutate Muse's item", async () => {
+ roles.setCredentialPromptRole("interactive-launch");
+ const seen: string[] = [];
+ await kc.withMuseKeychainLogin(async (token) => {
+ seen.push(token);
+ return token;
+ });
+ expect(seen).toEqual([TOKEN]);
+ expect(commands.filter((args) => args.includes("-w"))).toHaveLength(1);
+ assertReadOnly();
+ });
+ test("disabled Keychain does not issue metadata or value reads", async () => {
+ roles.setCredentialPromptRole("interactive-launch");
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ installKeychain({ env: () => ({ CLAUDISH_DISABLE_KEYCHAIN: "1" }) });
+ expect(await kc.museKeychainPresence()).toBe("absent");
+ let used = 0;
+ await kc.withMuseKeychainLogin(async () => {
+ used++;
+ });
+ expect(used).toBe(0);
+ expect(commands).toEqual([]);
+ });
+ test("non-macOS cannot issue a security process", async () => {
+ roles.setCredentialPromptRole("interactive-launch");
+ installGeneric({ platform: () => "linux" });
+ expect(await kc.museKeychainPresence()).toBe("absent");
+ let used = 0;
+ await kc.withMuseKeychainLogin(async () => {
+ used++;
+ });
+ expect(used).toBe(0);
+ expect(commands).toEqual([]);
+ });
+ for (const code of [44, 36]) {
+ test(`presence/read exit ${code} never provides a token`, async () => {
+ roles.setCredentialPromptRole("interactive-launch");
+ presenceCode = code;
+ expect(await kc.museKeychainPresence()).toBe(code === 44 ? "absent" : "failed");
+ installGeneric({
+ spawnAsync: (args) => {
+ commands.push(args);
+ return {
+ pid: 12345,
+ done: Promise.resolve({ code, stdout: "", stderr: "access denied or absent" }),
+ };
+ },
+ });
+ let used = 0;
+ await kc.withMuseKeychainLogin(async () => {
+ used++;
+ });
+ expect(used).toBe(0);
+ assertReadOnly();
+ });
+ }
+});
+
+describe("K2: joinable reads and process locks", () => {
+ test("timeout leaves read alive; late approval is joined without another spawn", async () => {
+ let finish!: (v: import("../keychain.js").KeychainRunResult) => void;
+ const done = new Promise<import("../keychain.js").KeychainRunResult>((resolve) => {
+ finish = resolve;
+ });
+ installGeneric({
+ spawnAsync: (args) => {
+ commands.push(args);
+ return {
+ pid: 12345,
+ done: args.includes("-w") ? done : Promise.resolve({ code: 0, stdout: "", stderr: "" }),
+ };
+ },
+ });
+ roles.setCredentialPromptRole("interactive-launch");
+ const seen: string[] = [];
+ const first = await kc.withMuseKeychainLogin(async (token) => {
+ seen.push(token);
+ return token;
+ }, 10);
+ expect(first).toEqual({ kind: "timeout" });
+ expect(seen).toEqual([]);
+ expect(commands.filter((args) => args.includes("-w"))).toHaveLength(1);
+ finish({ code: 0, stdout: SECRET, stderr: "" });
+ await kc.withMuseKeychainLogin(async (token) => {
+ seen.push(token);
+ return token;
+ }, 1000);
+ expect(seen).toEqual([TOKEN]);
+ expect(commands.filter((args) => args.includes("-w"))).toHaveLength(1);
+ assertReadOnly();
+ });
+ test("live-pid lock waits and consumes the winner's borrowed copy without spawning", async () => {
+ const lock = join(home, "muse-keychain-read.lock");
+ writeFileSync(lock, JSON.stringify({ pid: 22222, startedAt: now }));
+ let waits = 0;
+ installKeychain({
+ isAlive: (pid) => pid === 22222,
+ sleep: async (ms) => {
+ waits++;
+ now += ms;
+ store.writeBorrowedCopy(TOKEN, "Muse Code Power Usage", home);
+ rmSync(lock, { force: true });
+ },
+ });
+ roles.setCredentialPromptRole("interactive-launch");
+ const seen: string[] = [];
+ await kc.withMuseKeychainLogin(async (token) => {
+ seen.push(token);
+ return token;
+ }, 1000);
+ expect(waits).toBeGreaterThan(0);
+ expect(seen).toEqual([TOKEN]);
+ expect(commands).toEqual([]);
+ expect(existsSync(lock)).toBe(false);
+ });
+ test("dead-pid lock is removed and a new read succeeds", async () => {
+ const lock = join(home, "muse-keychain-read.lock");
+ writeFileSync(lock, JSON.stringify({ pid: 22222, startedAt: now }));
+ installKeychain({ isAlive: () => false });
+ roles.setCredentialPromptRole("interactive-launch");
+ const seen: string[] = [];
+ await kc.withMuseKeychainLogin(async (token) => {
+ seen.push(token);
+ });
+ expect(seen).toEqual([TOKEN]);
+ expect(existsSync(lock)).toBe(false);
+ expect(commands.filter((args) => args.includes("-w"))).toHaveLength(1);
+ assertReadOnly();
+ });
+});
diff --git a/packages/cli/src/providers/meta-muse/muse-launch.test.ts b/packages/cli/src/providers/meta-muse/muse-launch.test.ts
new file mode 100644
index 00000000..58304fcd
--- /dev/null
+++ b/packages/cli/src/providers/meta-muse/muse-launch.test.ts
@@ -0,0 +1,289 @@
+import { afterEach, beforeEach, 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 savedEnv: Record<string, string | undefined>;
+let savedFetch: typeof fetch;
+let savedExit: typeof process.exit;
+// Any unexpected CLI exit must fail the case instead of terminating Bun's runner.
+class UnexpectedProcessExit extends Error {
+ constructor(code?: string | number | null) {
+ super(`RUN5_PROCESS_EXIT:${code ?? 0}`);
+ this.name = "UnexpectedProcessExit";
+ }
+}
+beforeEach(() => {
+ savedEnv = { CLAUDISH_DISABLE_KEYCHAIN: process.env.CLAUDISH_DISABLE_KEYCHAIN };
+ home = mkdtempSync(join(tmpdir(), "muse-run5-"));
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ savedExit = process.exit;
+ process.exit = (code?: string | number | null): never => {
+ throw new UnexpectedProcessExit(code);
+ };
+ savedFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(
+ async () => {
+ throw new Error("Unexpected network in Run 5 test");
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+});
+function restoreHarness() {
+ process.exit = savedExit;
+ globalThis.fetch = savedFetch;
+ for (const [key, value] of Object.entries(savedEnv)) {
+ if (value === undefined) delete process.env[key];
+ else process.env[key] = value;
+ }
+ rmSync(home, { recursive: true, force: true });
+}
+
+// HOME is not an isolation seam in Bun. Every filesystem-capable dependency
+// below is explicit and test-owned; omitted production defaults are forbidden.
+function fakeCoreDeps(
+ overrides: Partial<import("./muse-credentials.js").MuseCoreDeps> = {}
+): import("./muse-credentials.js").MuseCoreDeps {
+ return {
+ dir: () => home,
+ now: () => 1792088000000,
+ readStore: () => null,
+ writeBorrowedCopy: () => {
+ throw new Error("Unexpected borrowed-copy write");
+ },
+ mint: async () => {
+ throw new Error("Unexpected mint");
+ },
+ keychainLogin: async () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+function fakeMuseKeychainDeps(
+ overrides: Partial<import("./muse-keychain.js").MuseKeychainDeps> = {}
+): import("./muse-keychain.js").MuseKeychainDeps {
+ return {
+ dir: () => home,
+ env: () => ({}),
+ now: () => 1792088000000,
+ sleep: async () => {
+ throw new Error("Unexpected Keychain wait");
+ },
+ pid: () => 424242,
+ isAlive: () => false,
+ presence: async () => ({ kind: "absent" }),
+ startRead: () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+let previousConfigPath: string | null;
+const restoreRegistrations: (() => void)[] = [];
+beforeEach(async () => {
+ const keychain = await import("../keychain.js");
+ const forbidden = () => {
+ throw new Error("Real Keychain process forbidden");
+ };
+ keychain.setKeychainTestDeps({
+ platform: () => "darwin",
+ run: forbidden,
+ runAsync: async () => forbidden(),
+ spawnAsync: forbidden,
+ });
+ const core = await import("./muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(fakeCoreDeps());
+ const museKeychain = await import("./muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(fakeMuseKeychainDeps());
+ (await import("../../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ const config = await import("../../config-override.js");
+ previousConfigPath = config.getConfigFileOverride();
+ config.setConfigFileOverride(join(home, "config.json"));
+});
+afterEach(async () => {
+ for (const restore of restoreRegistrations.splice(0).reverse()) restore();
+ const core = await import("./muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(null);
+ const museKeychain = await import("./muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(null);
+ const keychain = await import("../keychain.js");
+ keychain.invalidateKeychainCache();
+ keychain.setKeychainTestDeps(null);
+ (await import("../../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ (await import("../../auth/credentials/billing-probe.js")).clearSignedArm();
+ (await import("../model-discovery.js")).invalidateModelDiscovery("meta-muse-code");
+ (await import("../all-models-cache.js"))._clearAllModelsCacheMemo();
+ (await import("../catalog-client.js"))._resetCatalogClient();
+ (await import("../../config-override.js")).setConfigFileOverride(previousConfigPath);
+ restoreHarness();
+});
+
+test("P2: explicit Muse slots prepare; unrelated explicit providers do not", async () => {
+ const { museSlots } = await import("./muse-launch.js");
+ expect(museSlots(["[email protected]", "[email protected]", null, 42, ""])).toEqual({
+ explicit: true,
+ bare: false,
+ });
+ expect(museSlots(["[email protected]", "cx@gpt-6-astra", null])).toEqual({
+ explicit: false,
+ bare: false,
+ });
+});
+
+test("P2: today's bare Muse name needs no Muse login with no published mapping", async () => {
+ const { _setCatalogEntriesForTest, _resetCatalogClient } = await import("../catalog-client.js");
+ const { museSlots, prepareMuseLoginForLaunch } = await import("./muse-launch.js");
+ const { setMuseCoreTestDeps, resetMuseCredentialState } = await import("./muse-credentials.js");
+ const { setCredentialPromptRole } = await import("../../auth/credentials/prompt-role.js");
+ const role = setCredentialPromptRole("never");
+ let reads = 0;
+ resetMuseCredentialState();
+ setMuseCoreTestDeps({
+ ...fakeCoreDeps(),
+ dir: () => home,
+ readStore: () => {
+ reads++;
+ return null;
+ },
+ keychainLogin: async () => {
+ throw new Error("Keychain must not be read");
+ },
+ });
+ try {
+ _setCatalogEntriesForTest([]);
+ expect(museSlots(["muse-spark-1.3"])).toEqual({ explicit: false, bare: false });
+ expect(await prepareMuseLoginForLaunch(["muse-spark-1.3"])).toEqual({ kind: "not-needed" });
+ expect(reads).toBe(0);
+ } finally {
+ resetMuseCredentialState();
+ setMuseCoreTestDeps(null);
+ setCredentialPromptRole(role);
+ _resetCatalogClient();
+ }
+});
+
+test("P2: explicit never-role slot with no file is fatal with login guidance", async () => {
+ const { prepareMuseLoginForLaunch } = await import("./muse-launch.js");
+ const { setMuseCoreTestDeps, resetMuseCredentialState } = await import("./muse-credentials.js");
+ const { setCredentialPromptRole } = await import("../../auth/credentials/prompt-role.js");
+ const role = setCredentialPromptRole("never");
+ let keychainReads = 0;
+ resetMuseCredentialState();
+ setMuseCoreTestDeps({
+ ...fakeCoreDeps(),
+ dir: () => home,
+ readStore: () => null,
+ keychainLogin: async () => {
+ keychainReads++;
+ throw new Error("unexpected Keychain read");
+ },
+ });
+ try {
+ const result = await prepareMuseLoginForLaunch(["[email protected]"]);
+ expect(result.kind).toBe("fatal");
+ if (result.kind !== "fatal") throw new Error(JSON.stringify(result));
+ expect(result.message).toContain("claudish login muse");
+ expect(keychainReads).toBe(0);
+ } finally {
+ resetMuseCredentialState();
+ setMuseCoreTestDeps(null);
+ setCredentialPromptRole(role);
+ }
+});
+
+test.skip("P2 BLOCKED: future mapped bare slots require phase 17 Muse route binding; no public binding setter", () => {});
+
+test("P2: never-role borrowed copy prepares discovery without reading Keychain", async () => {
+ const { prepareMuseLoginForLaunch } = await import("./muse-launch.js");
+ const { setMuseCoreTestDeps, resetMuseCredentialState, currentMuseState } = await import(
+ "./muse-credentials.js"
+ );
+ const { setCredentialPromptRole } = await import("../../auth/credentials/prompt-role.js");
+ const d = await import("../model-discovery.js");
+ await import("../model-discovery-builtins.js");
+ const originalFetcher = d.getModelDiscoveryFetcher("muse-code-models");
+ if (!originalFetcher) throw new Error("Muse discovery fetcher is not registered");
+ restoreRegistrations.push(() =>
+ d.registerModelDiscoveryFetcher("muse-code-models", originalFetcher)
+ );
+ const role = setCredentialPromptRole("never");
+ let keychainReads = 0;
+ let mints = 0;
+ resetMuseCredentialState();
+ setMuseCoreTestDeps({
+ ...fakeCoreDeps(),
+ dir: () => home,
+ readStore: (kind) =>
+ kind === "borrowed-copy"
+ ? { access_token: "dca:TESTTOKEN0001", subs_tier_name: "Muse Code Power Usage" }
+ : null,
+ keychainLogin: async () => {
+ keychainReads++;
+ throw new Error("unexpected Keychain read");
+ },
+ mint: async (token) => {
+ expect(token).toBe("dca:TESTTOKEN0001");
+ mints++;
+ return { apiKey: "LLM|TESTKEY0001", subsTierName: "Muse Code Power Usage" };
+ },
+ });
+ d.invalidateModelDiscovery("meta-muse-code");
+ d.registerModelDiscoveryFetcher("muse-code-models", async () => ({
+ kind: "models",
+ models: [{ id: "muse-wonder-full-1.0", contextWindow: 1007997 }],
+ }));
+ try {
+ expect(await prepareMuseLoginForLaunch(["[email protected]"])).toEqual({
+ kind: "ready",
+ });
+ expect(currentMuseState()?.source).toBe("borrowed-copy");
+ expect(await d.discoverContextWindow("meta-muse-code", "muse-wonder-full-1.0")).toBe(1007997);
+ expect(keychainReads).toBe(0);
+ expect(mints).toBe(1);
+ } finally {
+ d.registerModelDiscoveryFetcher("muse-code-models", originalFetcher);
+ d.invalidateModelDiscovery("meta-muse-code");
+ resetMuseCredentialState();
+ setMuseCoreTestDeps(null);
+ setCredentialPromptRole(role);
+ }
+});
+
+test("P2: a real failed loopback fetch during mint warns rather than becoming fatal", async () => {
+ const { prepareMuseLoginForLaunch } = await import("./muse-launch.js");
+ const { setMuseCoreTestDeps, resetMuseCredentialState } = await import("./muse-credentials.js");
+ const { setCredentialPromptRole } = await import("../../auth/credentials/prompt-role.js");
+ const role = setCredentialPromptRole("never");
+ const server = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => new Response("unused") });
+ const closedUrl = server.url.href;
+ await server.stop(true);
+ resetMuseCredentialState();
+ setMuseCoreTestDeps({
+ ...fakeCoreDeps(),
+ dir: () => home,
+ readStore: (kind) => (kind === "borrowed-copy" ? { access_token: "dca:TESTTOKEN0001" } : null),
+ mint: async () => {
+ await savedFetch(closedUrl);
+ throw new Error("closed endpoint unexpectedly answered");
+ },
+ keychainLogin: async () => {
+ throw new Error("Keychain must not be read");
+ },
+ });
+ try {
+ const result = await prepareMuseLoginForLaunch(["[email protected]"]);
+ expect(result.kind).toBe("warn");
+ if (result.kind !== "warn") throw new Error(JSON.stringify(result));
+ expect(result.message.length).toBeGreaterThan(0);
+ } finally {
+ resetMuseCredentialState();
+ setMuseCoreTestDeps(null);
+ setCredentialPromptRole(role);
+ }
+});
diff --git a/packages/cli/src/providers/meta-muse/muse-mint.test.ts b/packages/cli/src/providers/meta-muse/muse-mint.test.ts
new file mode 100644
index 00000000..74d6743d
--- /dev/null
+++ b/packages/cli/src/providers/meta-muse/muse-mint.test.ts
@@ -0,0 +1,231 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+// contract/wire-capture.md §8 shape; sent credentials use ASCII test placeholders.
+const ACCESS_TOKEN = "dca:TESTTOKEN0001";
+const CAPTURE = {
+ api_key: "LLM|TESTKEY0001",
+ base_url: "https://api.meta.ai/v1",
+ has_payment_method: true,
+ require_payment: false,
+ is_subs_active: true,
+ can_subscribe: false,
+ show_subs_upsell: true,
+ user_full_name: "TEST USER",
+ user_email: "[email protected]",
+ user_avatar_url: null,
+ payment_method: "TEST PAYMENT METHOD",
+ action_url: null,
+ subs_tier_id: "<tier-id>",
+ subs_tier_name: "Muse Code Power Usage",
+ is_subs_upgrade_available: true,
+ subs_usage: {
+ window: { used_percent: 1, window_duration_mins: 300, resets_at: 1792136182 },
+ weekly: { used_percent: 0, resets_at: 1792368000 },
+ tier: "<tier-id>",
+ },
+};
+const SUBSCRIBE = "https://accountscenter.meta.com/muse_code/?ep=no_payg";
+
+type MintModule = typeof import("./muse-mint.js");
+type FailureModule = typeof import("../../handlers/shared/auth-failure.js");
+let mint: MintModule;
+let failures: FailureModule;
+// Mint and interpretation use no directory; every mint call supplies fake fetch.
+let priorGuard: string | undefined;
+
+beforeEach(async () => {
+ priorGuard = process.env.CLAUDISH_DISABLE_KEYCHAIN;
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ mint = await import("./muse-mint.js");
+ failures = await import("../../handlers/shared/auth-failure.js");
+});
+
+afterEach(async () => {
+ if (priorGuard === undefined) delete process.env.CLAUDISH_DISABLE_KEYCHAIN;
+ else process.env.CLAUDISH_DISABLE_KEYCHAIN = priorGuard;
+});
+
+function adapter(reply: () => Response | Promise<Response>) {
+ const requests: Request[] = [];
+ const fetcher = Object.assign(
+ async (...args: Parameters<typeof fetch>) => {
+ requests.push(new Request(args[0], args[1]));
+ return reply();
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+ return { fetcher, requests };
+}
+
+async function rejected(promise: Promise<unknown>): Promise<Error> {
+ try {
+ await promise;
+ } catch (error) {
+ expect(error).toBeInstanceOf(Error);
+ return error as Error;
+ }
+ throw new Error("Expected mint to reject, but it returned a key");
+}
+
+describe("M1 — fixed mint request and returned key", () => {
+ test("POSTs the durable access token and capture headers to Meta only", async () => {
+ const io = adapter(() => Response.json(CAPTURE));
+ const result = await mint.mintMuseApiKey(ACCESS_TOKEN, { fetch: io.fetcher });
+ expect(io.requests).toHaveLength(1);
+ const request = io.requests[0]!;
+ expect(request.url).toBe("https://api.meta.ai/muse-code/key");
+ expect(request.method).toBe("POST");
+ expect(request.headers.get("authorization")).toBe(`Bearer ${ACCESS_TOKEN}`);
+ expect(request.headers.get("x-api-version")).toBe("1.0.0");
+ expect(request.headers.get("content-type")).toBe("application/json");
+ expect(await request.json()).toEqual({ onboard: false });
+ expect(result.apiKey).toBe(CAPTURE.api_key);
+ expect(result.apiKey).not.toBe(ACCESS_TOKEN);
+ expect(result.subsTierId).toBe(CAPTURE.subs_tier_id);
+ expect(result.subsTierName).toBe(CAPTURE.subs_tier_name);
+ });
+});
+
+describe("M2 — exact entitlement booleans", () => {
+ test("accepts the captured true/false confirmation", () => {
+ expect(mint.interpretMint({ ...CAPTURE })).toMatchObject({
+ apiKey: CAPTURE.api_key,
+ subsTierId: CAPTURE.subs_tier_id,
+ subsTierName: CAPTURE.subs_tier_name,
+ });
+ });
+
+ // Explicit mutations of §8, not additional captured responses.
+ for (const field of ["is_subs_active", "require_payment"] as const) {
+ const wrongBoolean = field !== "is_subs_active";
+ for (const value of [wrongBoolean, undefined, null, "true", "false", 0, 1]) {
+ test(`rejects ${field}=${String(value)} with the default subscribe URL`, () => {
+ const body: Record<string, unknown> = { ...CAPTURE, [field]: value };
+ if (value === undefined) delete body[field];
+ let error: unknown;
+ try {
+ mint.interpretMint(body);
+ } catch (caught) {
+ error = caught;
+ }
+ expect(error).toBeInstanceOf(mint.MuseSubscriptionRequiredError);
+ expect(failures.classifyAuthFailure(error)).toMatchObject({ kind: "terminal" });
+ expect((error as Error).message).toContain(`subscribe at ${SUBSCRIBE}`);
+ });
+ }
+ }
+
+ test("uses the response action URL for an inactive subscription", () => {
+ // Action URL is an explicit mutation using the documented subscribe URL.
+ const action = "https://accountscenter.meta.com/muse_code/?ep=no_payg&test=1";
+ expect(() =>
+ mint.interpretMint({ ...CAPTURE, is_subs_active: false, action_url: action })
+ ).toThrow(`subscribe at ${action}`);
+ });
+
+ test("does not return an empty minted key even with confirmed entitlement", () => {
+ expect(() => mint.interpretMint({ ...CAPTURE, api_key: "" })).toThrow(/empty.*key/i);
+ });
+
+ test("the network mint boundary also refuses an unconfirmed result", async () => {
+ const io = adapter(() => Response.json({ ...CAPTURE, require_payment: null }));
+ const error = await rejected(mint.mintMuseApiKey(ACCESS_TOKEN, { fetch: io.fetcher }));
+ expect(error).toBeInstanceOf(mint.MuseSubscriptionRequiredError);
+ expect(error.message).toContain(SUBSCRIBE);
+ expect(io.requests).toHaveLength(1);
+ });
+});
+
+describe("M3 — mint rejection versus temporary service faults", () => {
+ for (const status of [401, 403]) {
+ test(`HTTP ${status} is terminal and names login`, async () => {
+ // §7's synthetic invalid-key body, status explicitly mutated for 403.
+ const io = adapter(() =>
+ Response.json(
+ {
+ error: { type: "invalid_api_key", message: "Unauthorized" },
+ },
+ { status }
+ )
+ );
+ const error = await rejected(mint.mintMuseApiKey(ACCESS_TOKEN, { fetch: io.fetcher }));
+ expect(error).toBeInstanceOf(mint.MuseLoginExpiredError);
+ expect(failures.classifyAuthFailure(error)).toMatchObject({ kind: "terminal" });
+ expect(error.message).toContain("claudish login muse");
+ expect(io.requests).toHaveLength(1);
+ });
+ }
+
+ for (const status of [429, 500, 502, 503]) {
+ test(`HTTP ${status} is retryable with its upstream status`, async () => {
+ // Status-only mutation: no invented Meta error payload.
+ const io = adapter(() => new Response(null, { status }));
+ const error = await rejected(mint.mintMuseApiKey(ACCESS_TOKEN, { fetch: io.fetcher }));
+ expect(error).toBeInstanceOf(mint.MuseMintTransientError);
+ expect(error).toMatchObject({ transient: true, upstreamStatus: status });
+ expect(failures.classifyAuthFailure(error)).toMatchObject({
+ kind: "transient",
+ });
+ expect(error.message).toContain(String(status));
+ expect(io.requests).toHaveLength(1);
+ });
+ }
+
+ for (const kind of ["non-JSON", "broken stream"] as const) {
+ test(`a 200 ${kind} response cannot become a dead login`, async () => {
+ const io = adapter(() =>
+ kind === "non-JSON"
+ ? new Response("<html>", { headers: { "content-type": "application/json" } })
+ : new Response(
+ new ReadableStream<Uint8Array>({
+ start(controller) {
+ controller.enqueue(new TextEncoder().encode('{"api_key":'));
+ controller.error(new Error("test body stream interrupted"));
+ },
+ }),
+ { headers: { "content-type": "application/json" } }
+ )
+ );
+ const error = await rejected(mint.mintMuseApiKey(ACCESS_TOKEN, { fetch: io.fetcher }));
+ expect(error).not.toBeInstanceOf(mint.MuseLoginExpiredError);
+ expect(error).not.toBeInstanceOf(mint.MuseSubscriptionRequiredError);
+ expect(error.message.length).toBeGreaterThan(0);
+ expect(["transient", "unknown", "connection"]).toContain(
+ failures.classifyAuthFailure(error).kind
+ );
+ expect(io.requests).toHaveLength(1);
+ });
+ }
+
+ for (const wrap of [false, true]) {
+ test(`a real refused loopback fetch remains retryable (wrapped=${wrap})`, async () => {
+ const server = Bun.serve({
+ hostname: "127.0.0.1",
+ port: 0,
+ fetch: () => new Response("unused"),
+ });
+ const url = `http://127.0.0.1:${server.port}/mint`;
+ await server.stop(true);
+ let real: unknown;
+ try {
+ await fetch(url);
+ } catch (error) {
+ real = error;
+ }
+ expect(real).toBeInstanceOf(Error);
+ expect(failures.classifyAuthFailure(real).kind).toBe("connection");
+ const fault = wrap ? new Error("mint transport failed", { cause: real }) : real;
+ const requests: Request[] = [];
+ const fetcher = Object.assign(
+ async (...args: Parameters<typeof fetch>) => {
+ requests.push(new Request(args[0], args[1]));
+ throw fault;
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+ const error = await rejected(mint.mintMuseApiKey(ACCESS_TOKEN, { fetch: fetcher }));
+ expect(failures.classifyAuthFailure(error).kind).toBe("connection");
+ expect(requests.map((request) => request.url)).toEqual(["https://api.meta.ai/muse-code/key"]);
+ });
+ }
+});
diff --git a/packages/cli/src/providers/meta-muse/muse-models.test.ts b/packages/cli/src/providers/meta-muse/muse-models.test.ts
new file mode 100644
index 00000000..9b2b545f
--- /dev/null
+++ b/packages/cli/src/providers/meta-muse/muse-models.test.ts
@@ -0,0 +1,291 @@
+import { afterEach, beforeEach, 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 savedEnv: Record<string, string | undefined>;
+let savedFetch: typeof fetch;
+let savedExit: typeof process.exit;
+// Any unexpected CLI exit must fail the case instead of terminating Bun's runner.
+class UnexpectedProcessExit extends Error {
+ constructor(code?: string | number | null) {
+ super(`RUN5_PROCESS_EXIT:${code ?? 0}`);
+ this.name = "UnexpectedProcessExit";
+ }
+}
+beforeEach(() => {
+ savedEnv = { CLAUDISH_DISABLE_KEYCHAIN: process.env.CLAUDISH_DISABLE_KEYCHAIN };
+ home = mkdtempSync(join(tmpdir(), "muse-run5-"));
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ savedExit = process.exit;
+ process.exit = (code?: string | number | null): never => {
+ throw new UnexpectedProcessExit(code);
+ };
+ savedFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(
+ async () => {
+ throw new Error("Unexpected network in Run 5 test");
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+});
+function restoreHarness() {
+ process.exit = savedExit;
+ globalThis.fetch = savedFetch;
+ for (const [key, value] of Object.entries(savedEnv)) {
+ if (value === undefined) delete process.env[key];
+ else process.env[key] = value;
+ }
+ rmSync(home, { recursive: true, force: true });
+}
+
+// HOME is not an isolation seam in Bun. Every filesystem-capable dependency
+// below is explicit and test-owned; omitted production defaults are forbidden.
+function fakeCoreDeps(
+ overrides: Partial<import("./muse-credentials.js").MuseCoreDeps> = {}
+): import("./muse-credentials.js").MuseCoreDeps {
+ return {
+ dir: () => home,
+ now: () => 1792088000000,
+ readStore: () => null,
+ writeBorrowedCopy: () => {
+ throw new Error("Unexpected borrowed-copy write");
+ },
+ mint: async () => {
+ throw new Error("Unexpected mint");
+ },
+ keychainLogin: async () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+function fakeMuseKeychainDeps(
+ overrides: Partial<import("./muse-keychain.js").MuseKeychainDeps> = {}
+): import("./muse-keychain.js").MuseKeychainDeps {
+ return {
+ dir: () => home,
+ env: () => ({}),
+ now: () => 1792088000000,
+ sleep: async () => {
+ throw new Error("Unexpected Keychain wait");
+ },
+ pid: () => 424242,
+ isAlive: () => false,
+ presence: async () => ({ kind: "absent" }),
+ startRead: () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+let previousConfigPath: string | null;
+const restoreRegistrations: (() => void)[] = [];
+beforeEach(async () => {
+ const keychain = await import("../keychain.js");
+ const forbidden = () => {
+ throw new Error("Real Keychain process forbidden");
+ };
+ keychain.setKeychainTestDeps({
+ platform: () => "darwin",
+ run: forbidden,
+ runAsync: async () => forbidden(),
+ spawnAsync: forbidden,
+ });
+ const core = await import("./muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(fakeCoreDeps());
+ const museKeychain = await import("./muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(fakeMuseKeychainDeps());
+ (await import("../../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ const config = await import("../../config-override.js");
+ previousConfigPath = config.getConfigFileOverride();
+ config.setConfigFileOverride(join(home, "config.json"));
+});
+afterEach(async () => {
+ for (const restore of restoreRegistrations.splice(0).reverse()) restore();
+ const core = await import("./muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(null);
+ const museKeychain = await import("./muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(null);
+ const keychain = await import("../keychain.js");
+ keychain.invalidateKeychainCache();
+ keychain.setKeychainTestDeps(null);
+ (await import("../../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ (await import("../../auth/credentials/billing-probe.js")).clearSignedArm();
+ (await import("../model-discovery.js")).invalidateModelDiscovery("meta-muse-code");
+ (await import("../all-models-cache.js"))._clearAllModelsCacheMemo();
+ (await import("../catalog-client.js"))._resetCatalogClient();
+ (await import("../../config-override.js")).setConfigFileOverride(previousConfigPath);
+ restoreHarness();
+});
+
+// Capture-derived reconstruction from wire-capture.md §4: reported metadata fields.
+function row(id: string, overrides: Record<string, unknown> = {}) {
+ return {
+ id,
+ object: "model",
+ created: 0,
+ owned_by: "meta",
+ metadata: {
+ "muse-code": {
+ name: id,
+ family: "avocado",
+ is_hidden: false,
+ reasoning: true,
+ temperature: false,
+ tool_call: true,
+ modalities: { input: ["text", "image"], output: ["text"] },
+ limit: { context: 1007997, output: 128000 },
+ options: {
+ reasoningEffort: "high",
+ forceReasoning: true,
+ include: ["reasoning.encrypted_content"],
+ },
+ variants: {
+ minimal: { reasoningEffort: "minimal" },
+ high: { reasoningEffort: "high" },
+ max: { reasoningEffort: "max" },
+ },
+ background_agent_model: "muse-spark-1.3",
+ ...overrides,
+ },
+ },
+ };
+}
+
+test("N1: fixed models URL and capture-derived name/window metadata", async () => {
+ const { MUSE_MODELS_URL, parseMuseModels } = await import("./muse-models.js");
+ expect(MUSE_MODELS_URL).toBe("https://api.meta.ai/muse-code/models");
+ const models = parseMuseModels({
+ data: [row("muse-wonder-full-1.0", { name: "Muse Wonder Full" })],
+ });
+ expect(models).toHaveLength(1);
+ expect(models?.[0]).toMatchObject({
+ id: "muse-wonder-full-1.0",
+ displayName: "Muse Wonder Full",
+ contextWindow: 1007997,
+ });
+});
+
+test("N1: hidden rows are excluded and non-chat rows reported; exact contributor entitlement is retained", async () => {
+ const { parseMuseModels } = await import("./muse-models.js");
+ const models = parseMuseModels({
+ data: [
+ row("muse-wonder-full-1.0-contributor"),
+ row("muse-wonder-full-1.0"),
+ row("muse-image-1.0", { is_hidden: true }),
+ // Explicit negative mutation of captured modalities, not an additional capture.
+ row("muse-spark-1.3", { modalities: { input: ["image"], output: ["image"] } }),
+ ],
+ });
+ expect(models?.map((model) => model.id)).toEqual([
+ "muse-wonder-full-1.0-contributor",
+ "muse-wonder-full-1.0",
+ "muse-spark-1.3",
+ ]);
+ expect(models?.find((model) => model.id === "muse-spark-1.3")?.reported).toBe("not-chat");
+ expect(models?.some((model) => model.id === "muse-image-1.0")).toBe(false);
+});
+
+test("N1: malformed bodies cannot become a successful model list", async () => {
+ const { parseMuseModels } = await import("./muse-models.js");
+ for (const body of [null, "not JSON", { error: "login required" }, { data: "bad" }]) {
+ expect(parseMuseModels(body)).toBeNull();
+ }
+});
+
+test("N1: capture metadata reports chat and tools through declared projection fields", async () => {
+ const { parseMuseModels } = await import("./muse-models.js");
+ expect(parseMuseModels({ data: [row("muse-spark-1.3")] })?.[0]).toMatchObject({
+ reported: "chat",
+ supportsTools: true,
+ });
+ expect(
+ parseMuseModels({ data: [row("muse-spark-1.3", { tool_call: false })] })?.[0].supportsTools
+ ).toBe(false);
+});
+
+test("N1: minted bearer fetches fixed models root; no login makes zero requests", async () => {
+ const core = await import("./muse-credentials.js");
+ const { fetchMuseCodeModelsCatalog } = await import("./muse-models.js");
+ const { credentials } = await import("../../auth/credentials/authority.js");
+ const { MuseCodeCredentialProvider } = await import(
+ "../../auth/credentials/muse-code-credential.js"
+ );
+ const { setCredentialPromptRole } = await import("../../auth/credentials/prompt-role.js");
+ const { clearSignedArm } = await import("../../auth/credentials/billing-probe.js");
+ const prior = credentials.get("meta-muse-code");
+ if (!prior) throw new Error("missing default Muse credential");
+ restoreRegistrations.push(() => {
+ credentials.register(prior);
+ credentials.invalidate("meta-muse-code");
+ });
+ const role = setCredentialPromptRole("never");
+ let present = true;
+ let mints = 0;
+ const requests: { url: string; headers: unknown }[] = [];
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps({
+ ...fakeCoreDeps(),
+ dir: () => home,
+ readStore: () => (present ? { access_token: "dca:TESTTOKEN0001" } : null),
+ keychainLogin: async () => {
+ throw new Error("Keychain forbidden");
+ },
+ mint: async () => {
+ mints++;
+ return { apiKey: "LLM|TESTKEY0001" };
+ },
+ });
+ credentials.register(new MuseCodeCredentialProvider());
+ globalThis.fetch = Object.assign(
+ async (input: string | URL | Request, init?: RequestInit) => {
+ requests.push({
+ url: input instanceof Request ? input.url : String(input),
+ headers: init?.headers,
+ });
+ return Response.json({ data: [row("muse-spark-1.3")] });
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+ try {
+ const result = await fetchMuseCodeModelsCatalog();
+ expect(result.kind).toBe("models");
+ if (result.kind !== "models") throw new Error(JSON.stringify(result));
+ expect(result.models[0]).toMatchObject({
+ id: "muse-spark-1.3",
+ contextWindow: 1007997,
+ supportsTools: true,
+ reported: "chat",
+ });
+ expect(requests).toHaveLength(1);
+ expect(requests[0].url).toBe("https://api.meta.ai/muse-code/models");
+ expect(JSON.stringify(requests[0].headers)).toContain("Bearer LLM|TESTKEY0001");
+ expect(mints).toBe(1);
+ present = false;
+ core.resetMuseCredentialState();
+ credentials.invalidate("meta-muse-code");
+ const absent = await fetchMuseCodeModelsCatalog();
+ expect(absent.kind).toBe("failed");
+ if (absent.kind !== "failed") throw new Error(JSON.stringify(absent));
+ expect(absent.failure.kind).toBe("no-credentials");
+ expect(absent.failure.detail).toContain("login");
+ expect(requests).toHaveLength(1);
+ } finally {
+ credentials.register(prior);
+ credentials.invalidate("meta-muse-code");
+ clearSignedArm();
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(null);
+ setCredentialPromptRole(role);
+ const { invalidateModelDiscovery } = await import("../model-discovery.js");
+ invalidateModelDiscovery("meta-muse-code");
+ }
+});
+
+test.skip("N1 BLOCKED: DiscoveredModel declares neither output-token limit nor input/output modality projection fields", () => {});
diff --git a/packages/cli/src/providers/meta-muse/muse-store.test.ts b/packages/cli/src/providers/meta-muse/muse-store.test.ts
new file mode 100644
index 00000000..a4088936
--- /dev/null
+++ b/packages/cli/src/providers/meta-muse/muse-store.test.ts
@@ -0,0 +1,156 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { MuseBorrowedCopy, MuseStoreKind } from "./muse-store.js";
+
+// ASCII durable-token placeholder with the prefix from wire-capture.md §7.
+// Wrapper fields are the exported
+// claudish store contract, not a claim about a Meta endpoint response.
+const TOKEN = "dca:TESTTOKEN0001";
+const TIER = "Muse Code Power Usage";
+let store: typeof import("./muse-store.js");
+let home: string;
+// Every store operation receives dir explicitly; HOME is not an isolation seam.
+let dir: string;
+let priorGuard: string | undefined;
+
+beforeEach(async () => {
+ priorGuard = process.env.CLAUDISH_DISABLE_KEYCHAIN;
+ home = await mkdtemp(join(tmpdir(), "muse-store-test-"));
+ dir = join(home, ".claudish");
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ await mkdir(dir);
+ store = await import("./muse-store.js");
+});
+
+afterEach(async () => {
+ if (priorGuard === undefined) delete process.env.CLAUDISH_DISABLE_KEYCHAIN;
+ else process.env.CLAUDISH_DISABLE_KEYCHAIN = priorGuard;
+ await rm(home, { recursive: true, force: true });
+});
+
+describe("S1 — durable token validity and complete private stores", () => {
+ test("uses the two documented claudish filenames inside the supplied directory", () => {
+ expect(store.museStorePath("own-login", dir)).toBe(join(dir, "meta-muse-oauth.json"));
+ expect(store.museStorePath("borrowed-copy", dir)).toBe(join(dir, "meta-muse-borrowed.json"));
+ });
+
+ test("accepts a nonempty access token without requiring obsolete refresh/expiry fields", () => {
+ expect(store.isValidMuseStore({ access_token: TOKEN })).toBe(true);
+ expect(store.isValidMuseStore({ access_token: TOKEN, subs_tier_name: TIER })).toBe(true);
+ });
+
+ const invalid: unknown[] = [
+ null,
+ undefined,
+ {},
+ [],
+ "corrupt",
+ { access_token: "" },
+ { access_token: null },
+ { access_token: 1 },
+ { api_key: "LLM|TESTKEY0001" },
+ ];
+ for (const [index, value] of invalid.entries()) {
+ test(`rejects invalid store value ${index}: ${JSON.stringify(value)}`, () => {
+ expect(store.isValidMuseStore(value)).toBe(false);
+ });
+ }
+
+ for (const kind of ["own-login", "borrowed-copy"] as const) {
+ test(`${kind}: missing, malformed and empty-token files are unreadable`, async () => {
+ expect(await store.readMuseStore(kind, dir)).toBeFalsy();
+ const path = store.museStorePath(kind, dir);
+ for (const raw of [
+ '{"access_token":',
+ "null",
+ "{}",
+ '{"access_token":""}',
+ '{"api_key":"LLM|TESTKEY0001"}',
+ ]) {
+ await writeFile(path, raw, { mode: 0o600 });
+ expect(await store.readMuseStore(kind, dir)).toBeFalsy();
+ }
+ });
+
+ test(`${kind}: replaces the complete document and leaves only a 0600 final file`, async () => {
+ const path = store.museStorePath(kind, dir);
+ await writeFile(path, JSON.stringify({ access_token: TOKEN, obsolete: true }), {
+ mode: 0o600,
+ });
+ const replacement = { access_token: TOKEN, subs_tier_name: TIER };
+ await store.writeMuseStore(kind, replacement, dir);
+ expect(JSON.parse(await readFile(path, "utf8"))).toEqual(replacement);
+ expect(await store.readMuseStore(kind, dir)).toEqual(replacement);
+ expect((await stat(path)).mode & 0o777).toBe(0o600);
+ expect(await readdir(dir)).toEqual([
+ kind === "own-login" ? "meta-muse-oauth.json" : "meta-muse-borrowed.json",
+ ]);
+ // Replacing with a shorter document must not retain bytes or old fields.
+ await store.writeMuseStore(kind, { access_token: TOKEN }, dir);
+ expect(JSON.parse(await readFile(path, "utf8"))).toEqual({ access_token: TOKEN });
+ expect((await stat(path)).mode & 0o777).toBe(0o600);
+ });
+
+ test(`${kind}: creates a new complete file with mode 0600`, async () => {
+ const record = { access_token: TOKEN, subs_tier_name: TIER };
+ await store.writeMuseStore(kind, record, dir);
+ const path = store.museStorePath(kind, dir);
+ expect(JSON.parse(await readFile(path, "utf8"))).toEqual(record);
+ expect((await stat(path)).mode & 0o777).toBe(0o600);
+ });
+ }
+
+ test("borrowed copy retains schema, confirming tier and a valid copy timestamp on disk and read", async () => {
+ const copiedAt = new Date("2026-10-16T03:33:37.000Z");
+ store.writeBorrowedCopy(TOKEN, TIER, dir, () => copiedAt);
+ const path = store.museStorePath("borrowed-copy", dir);
+ const raw: MuseBorrowedCopy = JSON.parse(await readFile(path, "utf8"));
+ expect(raw.schema).toBe(1);
+ expect(raw.access_token).toBe(TOKEN);
+ expect(raw.subs_tier_name).toBe(TIER);
+ expect(typeof raw.copied_at).toBe("string");
+ expect(new Date(raw.copied_at).toISOString()).toBe(raw.copied_at);
+ expect(raw.copied_at).toBe(copiedAt.toISOString());
+ expect(await store.readMuseStore("borrowed-copy", dir)).toEqual({ ...raw });
+ expect((await stat(path)).mode & 0o777).toBe(0o600);
+ expect(await readdir(dir)).toEqual(["meta-muse-borrowed.json"]);
+ });
+
+ test("reads the exported borrowed wrapper without discarding its timestamp or tier", async () => {
+ const record: MuseBorrowedCopy = {
+ schema: 1,
+ access_token: TOKEN,
+ copied_at: "2026-10-16T03:33:37.000Z",
+ subs_tier_name: TIER,
+ };
+ await writeFile(store.museStorePath("borrowed-copy", dir), JSON.stringify(record), {
+ mode: 0o600,
+ });
+ expect(await store.readMuseStore("borrowed-copy", dir)).toEqual({ ...record });
+ });
+});
+
+describe("S2 — delete only claudish's own two stores", () => {
+ test("deletes both stores, preserves unrelated files, and is repeatable", async () => {
+ await store.writeMuseStore("own-login", { access_token: TOKEN }, dir);
+ await store.writeBorrowedCopy(TOKEN, TIER, dir);
+ const sentinel = join(dir, "config.json");
+ const museDir = join(home, ".config", "muse");
+ await mkdir(museDir, { recursive: true });
+ const museSentinel = join(museDir, "auth.json");
+ await writeFile(sentinel, "unrelated claudish configuration");
+ await writeFile(museSentinel, "unrelated Muse CLI configuration");
+ await store.deleteMuseStores(dir);
+ for (const kind of ["own-login", "borrowed-copy"] satisfies MuseStoreKind[]) {
+ expect(await store.readMuseStore(kind, dir)).toBeFalsy();
+ expect(await Bun.file(store.museStorePath(kind, dir)).exists()).toBe(false);
+ }
+ expect(await readdir(dir)).toEqual(["config.json"]);
+ expect(await readFile(sentinel, "utf8")).toBe("unrelated claudish configuration");
+ expect(await readFile(museSentinel, "utf8")).toBe("unrelated Muse CLI configuration");
+ await store.deleteMuseStores(dir);
+ expect(await readFile(sentinel, "utf8")).toBe("unrelated claudish configuration");
+ });
+});
diff --git a/packages/cli/src/providers/model-discovery.muse-code.test.ts b/packages/cli/src/providers/model-discovery.muse-code.test.ts
new file mode 100644
index 00000000..13f67c49
--- /dev/null
+++ b/packages/cli/src/providers/model-discovery.muse-code.test.ts
@@ -0,0 +1,199 @@
+import { afterEach, beforeEach, 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 savedEnv: Record<string, string | undefined>;
+let savedFetch: typeof fetch;
+let savedExit: typeof process.exit;
+// Any unexpected CLI exit must fail the case instead of terminating Bun's runner.
+class UnexpectedProcessExit extends Error {
+ constructor(code?: string | number | null) {
+ super(`RUN5_PROCESS_EXIT:${code ?? 0}`);
+ this.name = "UnexpectedProcessExit";
+ }
+}
+beforeEach(() => {
+ savedEnv = { CLAUDISH_DISABLE_KEYCHAIN: process.env.CLAUDISH_DISABLE_KEYCHAIN };
+ home = mkdtempSync(join(tmpdir(), "muse-run5-"));
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ savedExit = process.exit;
+ process.exit = (code?: string | number | null): never => {
+ throw new UnexpectedProcessExit(code);
+ };
+ savedFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(
+ async () => {
+ throw new Error("Unexpected network in Run 5 test");
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+});
+function restoreHarness() {
+ process.exit = savedExit;
+ globalThis.fetch = savedFetch;
+ for (const [key, value] of Object.entries(savedEnv)) {
+ if (value === undefined) delete process.env[key];
+ else process.env[key] = value;
+ }
+ rmSync(home, { recursive: true, force: true });
+}
+
+// HOME is not an isolation seam in Bun. Every filesystem-capable dependency
+// below is explicit and test-owned; omitted production defaults are forbidden.
+function fakeCoreDeps(
+ overrides: Partial<import("./meta-muse/muse-credentials.js").MuseCoreDeps> = {}
+): import("./meta-muse/muse-credentials.js").MuseCoreDeps {
+ return {
+ dir: () => home,
+ now: () => 1792088000000,
+ readStore: () => null,
+ writeBorrowedCopy: () => {
+ throw new Error("Unexpected borrowed-copy write");
+ },
+ mint: async () => {
+ throw new Error("Unexpected mint");
+ },
+ keychainLogin: async () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+function fakeMuseKeychainDeps(
+ overrides: Partial<import("./meta-muse/muse-keychain.js").MuseKeychainDeps> = {}
+): import("./meta-muse/muse-keychain.js").MuseKeychainDeps {
+ return {
+ dir: () => home,
+ env: () => ({}),
+ now: () => 1792088000000,
+ sleep: async () => {
+ throw new Error("Unexpected Keychain wait");
+ },
+ pid: () => 424242,
+ isAlive: () => false,
+ presence: async () => ({ kind: "absent" }),
+ startRead: () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+let previousConfigPath: string | null;
+const restoreRegistrations: (() => void)[] = [];
+beforeEach(async () => {
+ const keychain = await import("./keychain.js");
+ const forbidden = () => {
+ throw new Error("Real Keychain process forbidden");
+ };
+ keychain.setKeychainTestDeps({
+ platform: () => "darwin",
+ run: forbidden,
+ runAsync: async () => forbidden(),
+ spawnAsync: forbidden,
+ });
+ const core = await import("./meta-muse/muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(fakeCoreDeps());
+ const museKeychain = await import("./meta-muse/muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(fakeMuseKeychainDeps());
+ (await import("../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ const config = await import("../config-override.js");
+ previousConfigPath = config.getConfigFileOverride();
+ config.setConfigFileOverride(join(home, "config.json"));
+});
+afterEach(async () => {
+ for (const restore of restoreRegistrations.splice(0).reverse()) restore();
+ const core = await import("./meta-muse/muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(null);
+ const museKeychain = await import("./meta-muse/muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(null);
+ const keychain = await import("./keychain.js");
+ keychain.invalidateKeychainCache();
+ keychain.setKeychainTestDeps(null);
+ (await import("../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ (await import("../auth/credentials/billing-probe.js")).clearSignedArm();
+ (await import("./model-discovery.js")).invalidateModelDiscovery("meta-muse-code");
+ (await import("./all-models-cache.js"))._clearAllModelsCacheMemo();
+ (await import("./catalog-client.js"))._resetCatalogClient();
+ (await import("../config-override.js")).setConfigFileOverride(previousConfigPath);
+ restoreHarness();
+});
+
+let restoreFetcher: (() => void) | undefined;
+afterEach(() => {
+ restoreFetcher?.();
+ restoreFetcher = undefined;
+});
+
+async function installFetcher() {
+ const discovery = await import("./model-discovery.js");
+ await import("./model-discovery-builtins.js");
+ // Save the built-in registration before replacing it.
+ const { fetchMuseCodeModelsCatalog } = await import("./meta-muse/muse-models.js");
+ const original = discovery.getModelDiscoveryFetcher("muse-code-models");
+ if (!original) throw new Error("Muse discovery fetcher must be registered before replacement");
+ expect(typeof fetchMuseCodeModelsCatalog).toBe("function");
+ discovery.invalidateModelDiscovery("meta-muse-code");
+ restoreFetcher = () => {
+ discovery.registerModelDiscoveryFetcher("muse-code-models", original);
+ discovery.invalidateModelDiscovery("meta-muse-code");
+ };
+ return discovery;
+}
+
+test("N2: discovery partitions opt-in ids, keeps exact entitlement and reported window", async () => {
+ const d = await installFetcher();
+ const { providerServesModel } = await import("./model-availability.js");
+ let calls = 0;
+ // Projection of the §4 capture into the public fetcher result. Contributor first.
+ d.registerModelDiscoveryFetcher("muse-code-models", async () => {
+ calls++;
+ return {
+ kind: "models",
+ models: [
+ { id: "muse-wonder-full-1.0-contributor", contextWindow: 1007997 },
+ { id: "muse-wonder-full-1.0", contextWindow: 1007997 },
+ ],
+ };
+ });
+ const outcome = await d.discoverProviderModelsCatalog("meta-muse-code");
+ expect(outcome.kind).toBe("served");
+ if (outcome.kind !== "served") throw new Error(JSON.stringify(outcome));
+ expect(outcome.models.map((m) => m.id)).toEqual(["muse-wonder-full-1.0"]);
+ expect(outcome.optInIds).toEqual(["muse-wonder-full-1.0-contributor"]);
+ expect(d.rankDiscoveredModels(outcome.models).map((m) => m.id)).toEqual(["muse-wonder-full-1.0"]);
+ expect(await providerServesModel("meta-muse-code", "muse-wonder-full-1.0-contributor")).toBe(
+ "serves"
+ );
+ expect(await d.discoverContextWindow("meta-muse-code", "muse-wonder-full-1.0")).toBe(1007997);
+ expect(calls).toBe(1);
+});
+
+test("N2: a later success clears the prior failure and uses new reported context", async () => {
+ const d = await installFetcher();
+ let calls = 0;
+ d.registerModelDiscoveryFetcher("muse-code-models", async () => {
+ calls++;
+ if (calls === 1)
+ return {
+ kind: "failed",
+ failure: {
+ kind: "no-credentials",
+ detail: "Muse Code login not available in this process",
+ },
+ };
+ // Negative fixture mutation: different served context verifies it is data-driven.
+ return { kind: "models", models: [{ id: "muse-spark-1.3", contextWindow: 123456 }] };
+ });
+ expect((await d.discoverProviderModelsCatalog("meta-muse-code")).kind).toBe("failed");
+ expect(d.getDiscoveryFailure("meta-muse-code")?.kind).toBe("no-credentials");
+ expect((await d.discoverProviderModelsCatalog("meta-muse-code")).kind).toBe("served");
+ expect(d.getDiscoveryFailure("meta-muse-code")).toBeUndefined();
+ expect(await d.discoverContextWindow("meta-muse-code", "muse-spark-1.3")).toBe(123456);
+ expect(calls).toBe(2);
+});
diff --git a/packages/cli/src/providers/probe-catalog.muse-code.test.ts b/packages/cli/src/providers/probe-catalog.muse-code.test.ts
new file mode 100644
index 00000000..48e4cd07
--- /dev/null
+++ b/packages/cli/src/providers/probe-catalog.muse-code.test.ts
@@ -0,0 +1,381 @@
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+
+const children: ReturnType<typeof Bun.spawn>[] = [];
+
+afterEach(async () => {
+ for (const child of children.splice(0)) {
+ if (child.exitCode === null) child.kill();
+ await child.exited;
+ }
+});
+async function waitForChild(child: ReturnType<typeof Bun.spawn>, stderr: Promise<string>) {
+ let timer: ReturnType<typeof setTimeout> | undefined;
+ try {
+ return await Promise.race([
+ child.exited,
+ new Promise<never>((_resolve, reject) => {
+ timer = setTimeout(() => {
+ if (child.exitCode === null) child.kill();
+ void stderr.then((message) => {
+ reject(new Error(`Probe child did not exit within 10 seconds: ${message}`));
+ }, reject);
+ }, 10000);
+ }),
+ ]);
+ } finally {
+ clearTimeout(timer);
+ }
+}
+
+let home: string;
+let savedEnv: Record<string, string | undefined>;
+let savedFetch: typeof fetch;
+let savedExit: typeof process.exit;
+// Any unexpected CLI exit must fail the case instead of terminating Bun's runner.
+class UnexpectedProcessExit extends Error {
+ constructor(code?: string | number | null) {
+ super(`RUN5_PROCESS_EXIT:${code ?? 0}`);
+ this.name = "UnexpectedProcessExit";
+ }
+}
+beforeEach(() => {
+ savedEnv = { CLAUDISH_DISABLE_KEYCHAIN: process.env.CLAUDISH_DISABLE_KEYCHAIN };
+ home = mkdtempSync(join(tmpdir(), "muse-run5-"));
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ savedExit = process.exit;
+ process.exit = (code?: string | number | null): never => {
+ throw new UnexpectedProcessExit(code);
+ };
+ savedFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(
+ async () => {
+ throw new Error("Unexpected network in Run 5 test");
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+});
+function restoreHarness() {
+ process.exit = savedExit;
+ globalThis.fetch = savedFetch;
+ for (const [key, value] of Object.entries(savedEnv)) {
+ if (value === undefined) delete process.env[key];
+ else process.env[key] = value;
+ }
+ rmSync(home, { recursive: true, force: true });
+}
+
+// HOME is not an isolation seam in Bun. Every filesystem-capable dependency
+// below is explicit and test-owned; omitted production defaults are forbidden.
+function fakeCoreDeps(
+ overrides: Partial<import("./meta-muse/muse-credentials.js").MuseCoreDeps> = {}
+): import("./meta-muse/muse-credentials.js").MuseCoreDeps {
+ return {
+ dir: () => home,
+ now: () => 1792088000000,
+ readStore: () => null,
+ writeBorrowedCopy: () => {
+ throw new Error("Unexpected borrowed-copy write");
+ },
+ mint: async () => {
+ throw new Error("Unexpected mint");
+ },
+ keychainLogin: async () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+function fakeMuseKeychainDeps(
+ overrides: Partial<import("./meta-muse/muse-keychain.js").MuseKeychainDeps> = {}
+): import("./meta-muse/muse-keychain.js").MuseKeychainDeps {
+ return {
+ dir: () => home,
+ env: () => ({}),
+ now: () => 1792088000000,
+ sleep: async () => {
+ throw new Error("Unexpected Keychain wait");
+ },
+ pid: () => 424242,
+ isAlive: () => false,
+ presence: async () => ({ kind: "absent" }),
+ startRead: () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+let previousConfigPath: string | null;
+const restoreRegistrations: (() => void)[] = [];
+beforeEach(async () => {
+ const keychain = await import("./keychain.js");
+ const forbidden = () => {
+ throw new Error("Real Keychain process forbidden");
+ };
+ keychain.setKeychainTestDeps({
+ platform: () => "darwin",
+ run: forbidden,
+ runAsync: async () => forbidden(),
+ spawnAsync: forbidden,
+ });
+ const core = await import("./meta-muse/muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(fakeCoreDeps());
+ const museKeychain = await import("./meta-muse/muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(fakeMuseKeychainDeps());
+ (await import("../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ const config = await import("../config-override.js");
+ previousConfigPath = config.getConfigFileOverride();
+ config.setConfigFileOverride(join(home, "config.json"));
+});
+afterEach(async () => {
+ for (const restore of restoreRegistrations.splice(0).reverse()) restore();
+ const core = await import("./meta-muse/muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(null);
+ const museKeychain = await import("./meta-muse/muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(null);
+ const keychain = await import("./keychain.js");
+ keychain.invalidateKeychainCache();
+ keychain.setKeychainTestDeps(null);
+ (await import("../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ (await import("../auth/credentials/billing-probe.js")).clearSignedArm();
+ (await import("./model-discovery.js")).invalidateModelDiscovery("meta-muse-code");
+ (await import("./all-models-cache.js"))._clearAllModelsCacheMemo();
+ (await import("./catalog-client.js"))._resetCatalogClient();
+ (await import("../config-override.js")).setConfigFileOverride(previousConfigPath);
+ restoreHarness();
+});
+
+// HOME must be present at process start: keep default-path consumers in Bun children.
+// The callback and fake builders are serialized after Bun has stripped TypeScript.
+async function runHomeScenario(scenario: () => Promise<Record<string, unknown>>) {
+ const absoluteImports = (source: string) =>
+ source.replace(
+ /import\((["'])(\.[^"']+)\1\)/g,
+ (_match, _quote, path) => `import(${JSON.stringify(resolve(import.meta.dir, path))})`
+ );
+ const scriptPath = join(home, "scenario.ts");
+ const setup = `
+ import { expect } from "bun:test";
+ import fs from "node:fs";
+ import fsp from "node:fs/promises";
+ import { syncBuiltinESMExports } from "node:module";
+ import { join, resolve, relative, isAbsolute } from "node:path";
+ import { fileURLToPath } from "node:url";
+ import { homedir } from "node:os";
+ const realExit = process.exit.bind(process);
+ try {
+ const home = process.env.HOME;
+ expect(homedir()).toBe(home);
+ process.exit = code => { throw new Error("RUN5_CHILD_EXIT:" + (code ?? 0)); };
+ const savedFetch = globalThis.fetch;
+ const networkUrls = [];
+ globalThis.fetch = Object.assign(async (input, init) => {
+ const url = new URL(input instanceof Request ? input.url : String(input));
+ if (url.protocol !== "http:" && url.protocol !== "https:") return savedFetch(input, init);
+ networkUrls.push(url.href);
+ throw new Error("Unexpected child network: " + url.href);
+ }, { preconnect() {} });
+ // Audit and reject filesystem mutations outside the child's owned HOME.
+ // Apply before implementation imports, including their singleton setup.
+ const outsideWrites = [];
+ const writes = [];
+ function checkWrite(path) {
+ if (typeof path === "number") return; // fd was checked when opened
+ const target = resolve(path instanceof URL ? fileURLToPath(path) : String(path));
+ const rel = relative(home, target);
+ if (rel === ".." || rel.startsWith("../") || isAbsolute(rel)) {
+ outsideWrites.push(target);
+ throw new Error("Outside-HOME mutation forbidden: " + target);
+ }
+ writes.push(rel);
+ }
+ for (const api of [fs, fsp]) {
+ for (const name of ["writeFile", "writeFileSync", "appendFile", "appendFileSync", "mkdir", "mkdirSync",
+ "rm", "rmSync", "rmdir", "rmdirSync", "unlink", "unlinkSync", "chmod", "chmodSync",
+ "truncate", "truncateSync", "utimes", "utimesSync", "createWriteStream", "mkdtemp", "mkdtempSync"]) {
+ const original = api[name];
+ if (original) api[name] = function(path, ...args) { checkWrite(path); return original.call(this, path, ...args); };
+ }
+ for (const name of ["rename", "renameSync", "copyFile", "copyFileSync", "cp", "cpSync", "link", "linkSync", "symlink", "symlinkSync"]) {
+ const original = api[name];
+ if (original) api[name] = function(from, to, ...args) {
+ if (name.startsWith("rename")) checkWrite(from);
+ checkWrite(to); return original.call(this, from, to, ...args);
+ };
+ }
+ for (const name of ["open", "openSync"]) {
+ const original = api[name];
+ if (original) api[name] = function(path, flags, ...args) {
+ if (typeof flags === "number" ? (flags & 3) !== 0 || (flags & (fs.constants.O_CREAT | fs.constants.O_TRUNC)) !== 0 : /[wa+]/.test(flags)) checkWrite(path);
+ return original.call(this, path, flags, ...args);
+ };
+ }
+ }
+ const bunWrite = Bun.write;
+ Bun.write = (path, ...args) => { checkWrite(path); return bunWrite(path, ...args); };
+ syncBuiltinESMExports();
+ `;
+ const initialization = `
+ let keychainOperations = 0;
+ const forbidden = () => { keychainOperations++; throw new Error("Real Keychain process forbidden"); };
+ const generic = await import(${JSON.stringify(resolve(import.meta.dir, "../providers/keychain.js"))});
+ generic.setKeychainTestDeps({ platform: () => "darwin", run: forbidden, runAsync: async () => forbidden(), spawnAsync: forbidden });
+ const coreSetup = await import(${JSON.stringify(resolve(import.meta.dir, "../providers/meta-muse/muse-credentials.js"))});
+ coreSetup.resetMuseCredentialState(); coreSetup.setMuseCoreTestDeps(fakeCoreDeps());
+ const keychainSetup = await import(${JSON.stringify(resolve(import.meta.dir, "../providers/meta-muse/muse-keychain.js"))});
+ keychainSetup.resetMuseKeychainState(); keychainSetup.setMuseKeychainTestDeps(fakeMuseKeychainDeps());
+ (await import(${JSON.stringify(resolve(import.meta.dir, "../auth/credentials/prompt-role.js"))}))._resetCredentialPromptRoleForTest();
+ (await import(${JSON.stringify(resolve(import.meta.dir, "../config-override.js"))})).setConfigFileOverride(join(home, "config.json"));
+ `;
+ writeFileSync(
+ scriptPath,
+ setup +
+ absoluteImports(fakeCoreDeps.toString()) +
+ "\n" +
+ absoluteImports(fakeMuseKeychainDeps.toString()) +
+ initialization +
+ `\nconst result = await (${absoluteImports(scenario.toString())})();\n` +
+ "expect(outsideWrites).toEqual([]);\nexpect(keychainOperations).toBe(0);\nexpect(networkUrls).toEqual([]);\nconsole.log(JSON.stringify({ ...result, outsideWrites, writes, keychainOperations, networkUrls }));\nrealExit(0);\n} catch (error) { console.error(error); realExit(1); }\n"
+ );
+ const child = Bun.spawn([process.execPath, scriptPath], {
+ cwd: home,
+ env: {
+ ...process.env,
+ HOME: home,
+ TMPDIR: home,
+ CLAUDISH_DISABLE_KEYCHAIN: "1",
+ CLAUDISH_DISABLE_CATALOG_WARM: "1",
+ },
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ children.push(child);
+ const stderrPromise = new Response(child.stderr).text();
+ const [stdout, stderr, exitCode] = await Promise.all([
+ new Response(child.stdout).text(),
+ stderrPromise,
+ waitForChild(child, stderrPromise),
+ ]);
+ expect(exitCode, `probe child exit ${exitCode} (124 means 4-second timeout): ${stderr}`).toBe(0);
+ const lines = stdout.trim().split("\n");
+ expect(lines, stderr).toHaveLength(1);
+ const result = JSON.parse(lines[0]);
+ expect(result.outsideWrites).toEqual([]);
+ expect(result.keychainOperations).toBe(0);
+ expect(result.networkUrls).toEqual([]);
+ return result;
+}
+
+test("N4: probe cache round-trips only through an explicit temporary path", async () => {
+ const p = await import("./probe-catalog.js");
+ const path = join(home, "probe-models.json");
+ const data = {
+ version: 3 as const,
+ generationId: "g-probe-wave4",
+ generatedAt: new Date().toISOString(),
+ providers: { "meta-muse-code": "muse-spark-1.3-contributor", meta: "muse-spark-1.3" },
+ unavailable: {},
+ };
+ p.writeProbeModelsCache(data, path);
+ expect(p.readProbeModelsCache(path)).toEqual(data);
+});
+test("N4: default-home cached probe picks exclude contributor ids", async () => {
+ const result = await runHomeScenario(async () => {
+ const p = await import("./probe-catalog.js");
+ const { existsSync } = await import("node:fs");
+ p.writeProbeModelsCache({
+ version: 3,
+ generationId: "g-probe-wave5",
+ generatedAt: new Date().toISOString(),
+ providers: { "meta-muse-code": "muse-spark-1.3-contributor", meta: "muse-spark-1.3" },
+ unavailable: {},
+ });
+ return {
+ contributor: p.getProbeModel("meta-muse-code"),
+ plain: p.getProbeModel("meta"),
+ cacheExists: existsSync(p.PROBE_MODELS_CACHE_PATH),
+ };
+ });
+ expect(result).toMatchObject({ contributor: null, plain: "muse-spark-1.3", cacheExists: true });
+});
+
+test("N4: endpoint-discovered picks exclude contributor ids in an isolated child", async () => {
+ const result = await runHomeScenario(async () => {
+ const { createProxyServer } = await import("../proxy-server.js");
+ const { discoverProbeModelFromEndpoint } = await import("./probe-catalog.js");
+ const { getConfigFileOverride, setConfigFileOverride } = await import("../config-override.js");
+ const d = await import("./model-discovery.js");
+ await import("./model-discovery-builtins.js");
+ const { credentials } = await import("../auth/credentials/authority.js");
+ const { clearSignedArm } = await import("../auth/credentials/billing-probe.js");
+ const { _clearProbeDiscoveryCache } = await import("./transport/probe-discovery.js");
+ const prior = credentials.get("meta-muse-code");
+ const fetcher = d.getModelDiscoveryFetcher("muse-code-models");
+ if (!prior || !fetcher) throw new Error("missing registrations");
+ const oldConfig = getConfigFileOverride();
+ setConfigFileOverride(join(home, "config.json"));
+ credentials.register({
+ catalogName: "meta-muse-code",
+ isAvailable: async () => true,
+ getRequestAuth: async () => ({ headers: {}, arm: "oauth" }),
+ });
+ let ids = ["muse-spark-1.3-contributor", "muse-spark-1.3"];
+ d.registerModelDiscoveryFetcher("muse-code-models", async () => ({
+ kind: "models",
+ models: ids.map((id) => ({ id, reported: "chat" })),
+ }));
+ d.invalidateModelDiscovery("meta-muse-code");
+ _clearProbeDiscoveryCache();
+ let loopbackRequests = 0;
+ let proxy: Awaited<ReturnType<typeof createProxyServer>> | undefined;
+ const blockedFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(
+ (input: string | URL | Request, init?: RequestInit) => {
+ const url = new URL(input instanceof Request ? input.url : String(input));
+ if (url.protocol !== "http:" && url.protocol !== "https:") return savedFetch(input, init);
+ if (
+ url.protocol === "http:" &&
+ ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname)
+ ) {
+ loopbackRequests++;
+ return savedFetch(input, init);
+ }
+ return blockedFetch(input, init);
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+ try {
+ proxy = await createProxyServer(0, "", "[email protected]", false, undefined, undefined, {
+ quiet: true,
+ });
+ const plain = (await discoverProbeModelFromEndpoint(proxy.url, "meta-muse-code")).model;
+ expect(plain).toBe("muse-spark-1.3");
+ ids = ["muse-spark-1.3-contributor"];
+ d.invalidateModelDiscovery("meta-muse-code");
+ _clearProbeDiscoveryCache();
+ proxy.invalidateHandlerCache("meta-muse-code");
+ const contributorOnly = (await discoverProbeModelFromEndpoint(proxy.url, "meta-muse-code"))
+ .model;
+ expect(contributorOnly).toBeNull();
+ return { plain, contributorOnly, loopbackRequests };
+ } finally {
+ await proxy?.shutdown();
+ globalThis.fetch = blockedFetch;
+ credentials.register(prior);
+ credentials.invalidate("meta-muse-code");
+ clearSignedArm();
+ d.registerModelDiscoveryFetcher("muse-code-models", fetcher);
+ d.invalidateModelDiscovery("meta-muse-code");
+ _clearProbeDiscoveryCache();
+ setConfigFileOverride(oldConfig);
+ }
+ });
+ expect(result).toMatchObject({ plain: "muse-spark-1.3", contributorOnly: null });
+ expect(result.loopbackRequests).toBeGreaterThanOrEqual(2);
+}, 20000);
diff --git a/packages/cli/src/providers/probe-live.muse-code.test.ts b/packages/cli/src/providers/probe-live.muse-code.test.ts
new file mode 100644
index 00000000..04ce71f6
--- /dev/null
+++ b/packages/cli/src/providers/probe-live.muse-code.test.ts
@@ -0,0 +1,285 @@
+import { afterEach, beforeEach, 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 savedEnv: Record<string, string | undefined>;
+let savedFetch: typeof fetch;
+let savedExit: typeof process.exit;
+// Any unexpected CLI exit must fail the case instead of terminating Bun's runner.
+class UnexpectedProcessExit extends Error {
+ constructor(code?: string | number | null) {
+ super(`RUN5_PROCESS_EXIT:${code ?? 0}`);
+ this.name = "UnexpectedProcessExit";
+ }
+}
+beforeEach(() => {
+ savedEnv = { CLAUDISH_DISABLE_KEYCHAIN: process.env.CLAUDISH_DISABLE_KEYCHAIN };
+ home = mkdtempSync(join(tmpdir(), "muse-run5-"));
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ savedExit = process.exit;
+ process.exit = (code?: string | number | null): never => {
+ throw new UnexpectedProcessExit(code);
+ };
+ savedFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(
+ async () => {
+ throw new Error("Unexpected network in Run 5 test");
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+});
+function restoreHarness() {
+ process.exit = savedExit;
+ globalThis.fetch = savedFetch;
+ for (const [key, value] of Object.entries(savedEnv)) {
+ if (value === undefined) delete process.env[key];
+ else process.env[key] = value;
+ }
+ rmSync(home, { recursive: true, force: true });
+}
+
+// HOME is not an isolation seam in Bun. Every filesystem-capable dependency
+// below is explicit and test-owned; omitted production defaults are forbidden.
+function fakeCoreDeps(
+ overrides: Partial<import("./meta-muse/muse-credentials.js").MuseCoreDeps> = {}
+): import("./meta-muse/muse-credentials.js").MuseCoreDeps {
+ return {
+ dir: () => home,
+ now: () => 1792088000000,
+ readStore: () => null,
+ writeBorrowedCopy: () => {
+ throw new Error("Unexpected borrowed-copy write");
+ },
+ mint: async () => {
+ throw new Error("Unexpected mint");
+ },
+ keychainLogin: async () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+function fakeMuseKeychainDeps(
+ overrides: Partial<import("./meta-muse/muse-keychain.js").MuseKeychainDeps> = {}
+): import("./meta-muse/muse-keychain.js").MuseKeychainDeps {
+ return {
+ dir: () => home,
+ env: () => ({}),
+ now: () => 1792088000000,
+ sleep: async () => {
+ throw new Error("Unexpected Keychain wait");
+ },
+ pid: () => 424242,
+ isAlive: () => false,
+ presence: async () => ({ kind: "absent" }),
+ startRead: () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+let previousConfigPath: string | null;
+const restoreRegistrations: (() => void)[] = [];
+beforeEach(async () => {
+ const keychain = await import("./keychain.js");
+ const forbidden = () => {
+ throw new Error("Real Keychain process forbidden");
+ };
+ keychain.setKeychainTestDeps({
+ platform: () => "darwin",
+ run: forbidden,
+ runAsync: async () => forbidden(),
+ spawnAsync: forbidden,
+ });
+ const core = await import("./meta-muse/muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(fakeCoreDeps());
+ const museKeychain = await import("./meta-muse/muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(fakeMuseKeychainDeps());
+ (await import("../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ const config = await import("../config-override.js");
+ previousConfigPath = config.getConfigFileOverride();
+ config.setConfigFileOverride(join(home, "config.json"));
+});
+afterEach(async () => {
+ for (const restore of restoreRegistrations.splice(0).reverse()) restore();
+ const core = await import("./meta-muse/muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(null);
+ const museKeychain = await import("./meta-muse/muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(null);
+ const keychain = await import("./keychain.js");
+ keychain.invalidateKeychainCache();
+ keychain.setKeychainTestDeps(null);
+ (await import("../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ (await import("../auth/credentials/billing-probe.js")).clearSignedArm();
+ (await import("./model-discovery.js")).invalidateModelDiscovery("meta-muse-code");
+ (await import("./all-models-cache.js"))._clearAllModelsCacheMemo();
+ (await import("./catalog-client.js"))._resetCatalogClient();
+ (await import("../config-override.js")).setConfigFileOverride(previousConfigPath);
+ restoreHarness();
+});
+
+test("U2: probe preserves upstream 401 and adds login action for terminal login errors", async () => {
+ const { probeLink } = await import("./probe-live.js");
+ let requests = 0;
+ // Claudish error envelope, not a fabricated Meta endpoint response.
+ const server = Bun.serve({
+ hostname: "127.0.0.1",
+ port: 0,
+ fetch: () => {
+ requests++;
+ return Response.json(
+ {
+ type: "error",
+ error: {
+ type: "invalid_request_error",
+ message:
+ "Your Muse Code login has expired: run `claudish login muse` (or `muse login`).",
+ upstream_status: 401,
+ },
+ },
+ { status: 400, headers: { "x-claudish-auth-verdict": "terminal" } }
+ );
+ },
+ });
+ globalThis.fetch = Object.assign(
+ (input: string | URL | Request, init?: RequestInit) => {
+ const url = new URL(input instanceof Request ? input.url : String(input));
+ if (url.origin !== server.url.origin) throw new Error(`Unexpected URL: ${url}`);
+ return savedFetch(input, init);
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+ try {
+ const result = await probeLink(
+ server.url.origin,
+ { provider: "meta-muse-code", modelSpec: "[email protected]", hasCredentials: true },
+ 2000
+ );
+ expect(result.state).toBe("auth-failed");
+ expect(result.httpStatus).toBe(401);
+ expect(result.errorMessage).toContain("login");
+ expect(result.actionHint).toContain("claudish login muse");
+ expect(requests).toBe(1);
+ } finally {
+ await server.stop(true);
+ }
+});
+
+test("U2: unsubscribed probe offers subscribe URL rather than a login action", async () => {
+ const { probeLink } = await import("./probe-live.js");
+ const url = "https://accountscenter.meta.com/muse_code/?ep=no_payg";
+ const server = Bun.serve({
+ hostname: "127.0.0.1",
+ port: 0,
+ fetch: () =>
+ Response.json(
+ {
+ type: "error",
+ error: {
+ type: "invalid_request_error",
+ message: `Your Meta account has no active Muse Code subscription (or needs a payment method): subscribe at ${url}.`,
+ upstream_status: 403,
+ },
+ },
+ { status: 400, headers: { "x-claudish-auth-verdict": "terminal" } }
+ ),
+ });
+ globalThis.fetch = Object.assign(
+ (input: string | URL | Request, init?: RequestInit) => {
+ const target = new URL(input instanceof Request ? input.url : String(input));
+ if (target.origin !== server.url.origin) throw new Error(`Unexpected URL: ${target}`);
+ return savedFetch(input, init);
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+ try {
+ const result = await probeLink(
+ server.url.origin,
+ { provider: "meta-muse-code", modelSpec: "[email protected]", hasCredentials: true },
+ 2000
+ );
+ expect(result.state).toBe("auth-failed");
+ expect(result.httpStatus).toBe(403);
+ expect(result.actionHint).toContain(`subscribe at ${url}`);
+ expect(result.actionHint).not.toContain("login");
+ } finally {
+ await server.stop(true);
+ }
+});
+
+for (const upstreamStatus of [401, 403]) {
+ test(`U2: real ComposedHandler terminal response retains upstream ${upstreamStatus} through probe`, async () => {
+ const { Hono } = await import("hono");
+ const { ComposedHandler } = await import("../handlers/composed-handler.js");
+ const { probeLink } = await import("./probe-live.js");
+ const { clearSignedArm } = await import("../auth/credentials/billing-probe.js");
+ const subscribe = "https://accountscenter.meta.com/muse_code/?ep=no_payg";
+ const message =
+ upstreamStatus === 401
+ ? "Your Muse Code login has expired: run `claudish login muse` (or `muse login`)."
+ : `Your Meta account has no active Muse Code subscription (or needs a payment method): subscribe at ${subscribe}.`;
+ let authCalls = 0;
+ // A classified application error at the auth boundary, not a Meta wire fixture.
+ const failure = Object.assign(new Error(message), { terminal: true, upstreamStatus });
+ const handler = new ComposedHandler(
+ {
+ name: "meta-muse-code",
+ displayName: "Muse Code",
+ streamFormat: "openai-responses-sse",
+ getEndpoint: () => "https://api.meta.ai/v1/responses",
+ getHeaders: async () => ({}),
+ refreshAuth: async () => {
+ authCalls++;
+ throw failure;
+ },
+ },
+ "muse-spark-1.3",
+ 0
+ );
+ const app = new Hono();
+ app.all("*", async (c) => handler.handle(c, await c.req.json()));
+ const server = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: app.fetch });
+ const observed: { status: number; verdict: string | null }[] = [];
+ globalThis.fetch = Object.assign(
+ async (input: string | URL | Request, init?: RequestInit) => {
+ if (
+ new URL(input instanceof Request ? input.url : String(input)).origin !== server.url.origin
+ )
+ throw new Error("upstream request forbidden");
+ const response = await savedFetch(input, init);
+ observed.push({
+ status: response.status,
+ verdict: response.headers.get("x-claudish-auth-verdict"),
+ });
+ return response;
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+ try {
+ const result = await probeLink(
+ server.url.origin,
+ { provider: "meta-muse-code", modelSpec: "[email protected]", hasCredentials: true },
+ 2000
+ );
+ expect(observed).toEqual([{ status: 400, verdict: "terminal" }]);
+ expect(authCalls).toBe(1);
+ expect(result.state).toBe("auth-failed");
+ expect(result.httpStatus).toBe(upstreamStatus);
+ expect(result.actionHint).toContain(
+ upstreamStatus === 401 ? "claudish login muse" : `subscribe at ${subscribe}`
+ );
+ if (upstreamStatus === 403) expect(result.actionHint).not.toContain("login");
+ } finally {
+ await server.stop(true);
+ await handler.shutdown();
+ clearSignedArm();
+ }
+ });
+}
diff --git a/packages/cli/src/providers/provider-definitions.muse-code.test.ts b/packages/cli/src/providers/provider-definitions.muse-code.test.ts
new file mode 100644
index 00000000..56b44ebb
--- /dev/null
+++ b/packages/cli/src/providers/provider-definitions.muse-code.test.ts
@@ -0,0 +1,151 @@
+import { afterEach, beforeEach, 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 savedEnv: Record<string, string | undefined>;
+let savedFetch: typeof fetch;
+let savedExit: typeof process.exit;
+// Any unexpected CLI exit must fail the case instead of terminating Bun's runner.
+class UnexpectedProcessExit extends Error {
+ constructor(code?: string | number | null) {
+ super(`RUN5_PROCESS_EXIT:${code ?? 0}`);
+ this.name = "UnexpectedProcessExit";
+ }
+}
+beforeEach(() => {
+ savedEnv = { CLAUDISH_DISABLE_KEYCHAIN: process.env.CLAUDISH_DISABLE_KEYCHAIN };
+ home = mkdtempSync(join(tmpdir(), "muse-run5-"));
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ savedExit = process.exit;
+ process.exit = (code?: string | number | null): never => {
+ throw new UnexpectedProcessExit(code);
+ };
+ savedFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(
+ async () => {
+ throw new Error("Unexpected network in Run 5 test");
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+});
+function restoreHarness() {
+ process.exit = savedExit;
+ globalThis.fetch = savedFetch;
+ for (const [key, value] of Object.entries(savedEnv)) {
+ if (value === undefined) delete process.env[key];
+ else process.env[key] = value;
+ }
+ rmSync(home, { recursive: true, force: true });
+}
+
+// HOME is not an isolation seam in Bun. Every filesystem-capable dependency
+// below is explicit and test-owned; omitted production defaults are forbidden.
+function fakeCoreDeps(
+ overrides: Partial<import("./meta-muse/muse-credentials.js").MuseCoreDeps> = {}
+): import("./meta-muse/muse-credentials.js").MuseCoreDeps {
+ return {
+ dir: () => home,
+ now: () => 1792088000000,
+ readStore: () => null,
+ writeBorrowedCopy: () => {
+ throw new Error("Unexpected borrowed-copy write");
+ },
+ mint: async () => {
+ throw new Error("Unexpected mint");
+ },
+ keychainLogin: async () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+function fakeMuseKeychainDeps(
+ overrides: Partial<import("./meta-muse/muse-keychain.js").MuseKeychainDeps> = {}
+): import("./meta-muse/muse-keychain.js").MuseKeychainDeps {
+ return {
+ dir: () => home,
+ env: () => ({}),
+ now: () => 1792088000000,
+ sleep: async () => {
+ throw new Error("Unexpected Keychain wait");
+ },
+ pid: () => 424242,
+ isAlive: () => false,
+ presence: async () => ({ kind: "absent" }),
+ startRead: () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+let previousConfigPath: string | null;
+const restoreRegistrations: (() => void)[] = [];
+beforeEach(async () => {
+ const keychain = await import("./keychain.js");
+ const forbidden = () => {
+ throw new Error("Real Keychain process forbidden");
+ };
+ keychain.setKeychainTestDeps({
+ platform: () => "darwin",
+ run: forbidden,
+ runAsync: async () => forbidden(),
+ spawnAsync: forbidden,
+ });
+ const core = await import("./meta-muse/muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(fakeCoreDeps());
+ const museKeychain = await import("./meta-muse/muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(fakeMuseKeychainDeps());
+ (await import("../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ const config = await import("../config-override.js");
+ previousConfigPath = config.getConfigFileOverride();
+ config.setConfigFileOverride(join(home, "config.json"));
+});
+afterEach(async () => {
+ for (const restore of restoreRegistrations.splice(0).reverse()) restore();
+ const core = await import("./meta-muse/muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(null);
+ const museKeychain = await import("./meta-muse/muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(null);
+ const keychain = await import("./keychain.js");
+ keychain.invalidateKeychainCache();
+ keychain.setKeychainTestDeps(null);
+ (await import("../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ (await import("../auth/credentials/billing-probe.js")).clearSignedArm();
+ (await import("./model-discovery.js")).invalidateModelDiscovery("meta-muse-code");
+ (await import("./all-models-cache.js"))._clearAllModelsCacheMemo();
+ (await import("./catalog-client.js"))._resetCatalogClient();
+ (await import("../config-override.js")).setConfigFileOverride(previousConfigPath);
+ restoreHarness();
+});
+
+test("D1a: Muse and Meta have separate shortcuts, tiers, credentials and factories", async () => {
+ const { getShortcuts, getProviderByName } = await import("./provider-definitions.js");
+ const { catalogRouteForProvider } = await import("./catalog-route-bindings.js");
+ const { SUBSCRIPTION_PROVIDERS } = await import("../handlers/shared/remote-provider-types.js");
+ const shortcuts = getShortcuts();
+ expect(shortcuts.muse).toBe("meta-muse-code");
+ expect(shortcuts.meta).toBe("meta");
+ expect(shortcuts.meta).not.toBe("ollamacloud");
+ const muse = getProviderByName("meta-muse-code");
+ const meta = getProviderByName("meta");
+ expect(muse).toBeDefined();
+ expect(meta).toBeDefined();
+ expect(muse?.tier).toBe("subscription");
+ expect(meta?.tier).toBe("native");
+ expect(muse?.apiKeyEnvVar).toBe("");
+ expect(meta?.apiKeyEnvVar).toBe("META_API_KEY");
+ expect(typeof muse?.createHandler).toBe("function");
+ expect(typeof meta?.createHandler).toBe("function");
+ expect(catalogRouteForProvider("meta")).toEqual({
+ routeId: "meta",
+ routeProfileId: "direct-api",
+ });
+ expect(SUBSCRIPTION_PROVIDERS.has("meta-muse-code")).toBe(true);
+ expect(SUBSCRIPTION_PROVIDERS.has("meta")).toBe(false);
+});
diff --git a/packages/cli/src/providers/provider-profiles.muse-code.test.ts b/packages/cli/src/providers/provider-profiles.muse-code.test.ts
new file mode 100644
index 00000000..a1b9b505
--- /dev/null
+++ b/packages/cli/src/providers/provider-profiles.muse-code.test.ts
@@ -0,0 +1,386 @@
+import { afterEach, beforeEach, 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 savedEnv: Record<string, string | undefined>;
+let savedFetch: typeof fetch;
+let savedExit: typeof process.exit;
+// Any unexpected CLI exit must fail the case instead of terminating Bun's runner.
+class UnexpectedProcessExit extends Error {
+ constructor(code?: string | number | null) {
+ super(`RUN5_PROCESS_EXIT:${code ?? 0}`);
+ this.name = "UnexpectedProcessExit";
+ }
+}
+beforeEach(() => {
+ savedEnv = { CLAUDISH_DISABLE_KEYCHAIN: process.env.CLAUDISH_DISABLE_KEYCHAIN };
+ home = mkdtempSync(join(tmpdir(), "muse-run5-"));
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ savedExit = process.exit;
+ process.exit = (code?: string | number | null): never => {
+ throw new UnexpectedProcessExit(code);
+ };
+ savedFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(
+ async () => {
+ throw new Error("Unexpected network in Run 5 test");
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+});
+function restoreHarness() {
+ process.exit = savedExit;
+ globalThis.fetch = savedFetch;
+ for (const [key, value] of Object.entries(savedEnv)) {
+ if (value === undefined) delete process.env[key];
+ else process.env[key] = value;
+ }
+ rmSync(home, { recursive: true, force: true });
+}
+
+// HOME is not an isolation seam in Bun. Every filesystem-capable dependency
+// below is explicit and test-owned; omitted production defaults are forbidden.
+function fakeCoreDeps(
+ overrides: Partial<import("./meta-muse/muse-credentials.js").MuseCoreDeps> = {}
+): import("./meta-muse/muse-credentials.js").MuseCoreDeps {
+ return {
+ dir: () => home,
+ now: () => 1792088000000,
+ readStore: () => null,
+ writeBorrowedCopy: () => {
+ throw new Error("Unexpected borrowed-copy write");
+ },
+ mint: async () => {
+ throw new Error("Unexpected mint");
+ },
+ keychainLogin: async () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+function fakeMuseKeychainDeps(
+ overrides: Partial<import("./meta-muse/muse-keychain.js").MuseKeychainDeps> = {}
+): import("./meta-muse/muse-keychain.js").MuseKeychainDeps {
+ return {
+ dir: () => home,
+ env: () => ({}),
+ now: () => 1792088000000,
+ sleep: async () => {
+ throw new Error("Unexpected Keychain wait");
+ },
+ pid: () => 424242,
+ isAlive: () => false,
+ presence: async () => ({ kind: "absent" }),
+ startRead: () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+let previousConfigPath: string | null;
+const restoreRegistrations: (() => void)[] = [];
+beforeEach(async () => {
+ const keychain = await import("./keychain.js");
+ const forbidden = () => {
+ throw new Error("Real Keychain process forbidden");
+ };
+ keychain.setKeychainTestDeps({
+ platform: () => "darwin",
+ run: forbidden,
+ runAsync: async () => forbidden(),
+ spawnAsync: forbidden,
+ });
+ const core = await import("./meta-muse/muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(fakeCoreDeps());
+ const museKeychain = await import("./meta-muse/muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(fakeMuseKeychainDeps());
+ (await import("../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ const config = await import("../config-override.js");
+ previousConfigPath = config.getConfigFileOverride();
+ config.setConfigFileOverride(join(home, "config.json"));
+});
+afterEach(async () => {
+ for (const restore of restoreRegistrations.splice(0).reverse()) restore();
+ const core = await import("./meta-muse/muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(null);
+ const museKeychain = await import("./meta-muse/muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(null);
+ const keychain = await import("./keychain.js");
+ keychain.invalidateKeychainCache();
+ keychain.setKeychainTestDeps(null);
+ (await import("../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ (await import("../auth/credentials/billing-probe.js")).clearSignedArm();
+ (await import("./model-discovery.js")).invalidateModelDiscovery("meta-muse-code");
+ (await import("./all-models-cache.js"))._clearAllModelsCacheMemo();
+ (await import("./catalog-client.js"))._resetCatalogClient();
+ (await import("../config-override.js")).setConfigFileOverride(previousConfigPath);
+ restoreHarness();
+});
+
+test("T4: Muse builds an explicit handler without a subscription route binding", async () => {
+ const { museCodeProfile } = await import("./provider-profiles.js");
+ const { catalogRouteForProvider } = await import("./catalog-route-bindings.js");
+ const { _resetCatalogClient } = await import("./catalog-client.js");
+ const { _clearAllModelsCacheMemo } = await import("./all-models-cache.js");
+ try {
+ _resetCatalogClient();
+ _clearAllModelsCacheMemo();
+ expect(catalogRouteForProvider("meta-muse-code")).toBeUndefined();
+ const handler = await museCodeProfile.createHandler({
+ provider: {
+ name: "meta-muse-code",
+ baseUrl: "https://api.meta.ai/v1",
+ apiPath: "/responses",
+ apiKeyEnvVar: "",
+ prefixes: ["muse@"],
+ },
+ modelName: "muse-wonder-full-1.0",
+ targetModel: "[email protected]",
+ apiKey: "",
+ port: 0,
+ sharedOpts: {},
+ catalogCachePath: join(home, "missing-catalog.json"),
+ });
+ expect(handler).not.toBeNull();
+ expect(handler).toBeDefined();
+ await handler?.shutdown();
+ } finally {
+ _resetCatalogClient();
+ _clearAllModelsCacheMemo();
+ }
+});
+
+test("T4: missing owner wire supplies no fabricated support, including Wonder-full", async () => {
+ const { ownerWireForModel } = await import("./meta-muse/muse-wire.js");
+ const { _clearAllModelsCacheMemo } = await import("./all-models-cache.js");
+ try {
+ for (const model of ["muse-wonder-full-1.0", "muse-spark-1.3", "unknown-model"]) {
+ expect(ownerWireForModel(model, join(home, "missing-catalog.json"))).toBeUndefined();
+ }
+ } finally {
+ _clearAllModelsCacheMemo();
+ }
+});
+
+test("T4: Muse borrows Meta owner wire and clamps outgoing effort to changed advertised values", async () => {
+ const { Hono } = await import("hono");
+ const { writeAllModelsCache, _clearAllModelsCacheMemo } = await import("./all-models-cache.js");
+ const { _setCatalogEntriesForTest, _resetCatalogClient } = await import("./catalog-client.js");
+ const { createHandlerForProvider } = await import("./provider-profiles.js");
+ const { ownerWireForModel } = await import("./meta-muse/muse-wire.js");
+ const { credentials } = await import("../auth/credentials/authority.js");
+ const { clearSignedArm } = await import("../auth/credentials/billing-probe.js");
+ const d = await import("./model-discovery.js");
+ await import("./model-discovery-builtins.js");
+ const prior = credentials.get("meta-muse-code");
+ const priorMeta = credentials.get("meta");
+ const fetcher = d.getModelDiscoveryFetcher("muse-code-models");
+ if (!prior || !priorMeta || !fetcher) throw new Error("missing default registration");
+ restoreRegistrations.push(() => {
+ credentials.register(prior);
+ credentials.register(priorMeta);
+ credentials.invalidate("meta-muse-code");
+ credentials.invalidate("meta");
+ d.registerModelDiscoveryFetcher("muse-code-models", fetcher);
+ });
+ credentials.register({
+ catalogName: "meta-muse-code",
+ isAvailable: async () => true,
+ getRequestAuth: async () => ({
+ headers: { Authorization: "Bearer LLM|TESTKEY0001" },
+ arm: "oauth",
+ }),
+ });
+ credentials.register({
+ catalogName: "meta",
+ isAvailable: async () => true,
+ getRequestAuth: async () => ({
+ headers: { Authorization: "Bearer TESTMETEREDKEY0001" },
+ arm: "api-key",
+ }),
+ });
+ d.registerModelDiscoveryFetcher("muse-code-models", async () => ({
+ kind: "models",
+ models: [{ id: "muse-spark-1.3", reported: "chat", contextWindow: 262144 }],
+ }));
+ const requests: any[] = [];
+ globalThis.fetch = Object.assign(
+ async (input: string | URL | Request, init?: RequestInit) => {
+ expect(input instanceof Request ? input.url : String(input)).toBe(
+ "https://api.meta.ai/v1/responses"
+ );
+ requests.push(JSON.parse(String(init?.body)));
+ return new Response("data: [DONE]\n\n", { headers: { "content-type": "text/event-stream" } });
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+ try {
+ for (const effort of ["high", "medium"] as const) {
+ const path = join(home, `catalog-${effort}.json`);
+ const wire: import("./connection-wire.js").KnownWire = {
+ status: "known",
+ api: "responses",
+ tokenParam: "max_output_tokens",
+ toolsWithReasoning: "ok",
+ reasoning: {
+ status: "supported",
+ enable: [],
+ disable: { status: "not_applicable" },
+ effort: {
+ path: "/reasoning/effort",
+ values: { minimal: "minimal", [effort]: effort },
+ default: effort,
+ },
+ mode: { status: "unknown" },
+ },
+ speed: { status: "unknown" },
+ evidence: [],
+ };
+ const entry = {
+ modelId: "muse-spark-1.3",
+ provider: "meta",
+ aliases: [],
+ inputModalities: ["text"],
+ outputModalities: ["text"],
+ aggregators: [
+ {
+ sourceProviderId: "meta",
+ sourceCollectorId: "contract-fixture",
+ confidence: "api_official" as const,
+ routeStatus: "mapped" as const,
+ route: { routeId: "meta", routeProfileId: "direct-api" },
+ externalModelId: "muse-spark-1.3",
+ wire,
+ },
+ ],
+ };
+ writeAllModelsCache(
+ {
+ version: 3,
+ lastUpdated: new Date().toISOString(),
+ catalogGenerationId: `g-${effort}`,
+ entries: [entry],
+ models: [{ id: entry.modelId }],
+ plans: [],
+ routeRegistry: {
+ generationId: `g-${effort}`,
+ registry: {
+ registryVersion: "3.7.0",
+ routes: {
+ meta: {
+ profiles: {
+ "direct-api": {
+ kind: "direct",
+ nativeModelProviders: ["meta"],
+ apis: { responses: { baseUrl: "https://api.meta.ai/v1" } },
+ },
+ },
+ },
+ },
+ },
+ },
+ },
+ path
+ );
+ _clearAllModelsCacheMemo();
+ _setCatalogEntriesForTest([entry]);
+ d.invalidateModelDiscovery("meta-muse-code");
+ expect(ownerWireForModel(entry.modelId, path)?.wire).toEqual(wire);
+ for (const name of ["meta-muse-code", "meta"]) {
+ const handler = await createHandlerForProvider({
+ provider: {
+ name,
+ baseUrl: "https://api.meta.ai/v1",
+ apiPath: "/responses",
+ apiKeyEnvVar: name === "meta" ? "META_API_KEY" : "",
+ prefixes: [name === "meta" ? "meta@" : "muse@"],
+ },
+ modelName: entry.modelId,
+ targetModel: `${name === "meta" ? "meta" : "muse"}@muse-spark-1.3`,
+ apiKey: name === "meta" ? "TESTMETEREDKEY0001" : "",
+ port: 0,
+ catalogCachePath: path,
+ sharedOpts: { effortOverride: "max" },
+ });
+ if (!handler) throw new Error("Muse handler absent");
+ const app = new Hono();
+ app.post("/", (c) =>
+ handler.handle(c, {
+ model: entry.modelId,
+ max_tokens: 64,
+ stream: true,
+ messages: [{ role: "user", content: "PONG" }],
+ })
+ );
+ try {
+ await (await app.request("http://localhost/", { method: "POST" })).text();
+ } finally {
+ await handler.shutdown();
+ }
+ expect(requests.at(-1)?.reasoning?.effort).toBe(effort);
+ }
+ // The public wire shaper also accepts raw effort strings, including ultra.
+ const { shapeRequestFromWire } = await import("./wire-request.js");
+ const payload: Record<string, unknown> = {};
+ const unknown = shapeRequestFromWire(payload, wire, { effort: "ultra", maxTokens: 64 });
+ expect((payload.reasoning as { effort?: string } | undefined)?.effort).toBeUndefined();
+ expect(payload.max_output_tokens).toBe(64);
+ expect(unknown.sentEffort).toBeUndefined();
+ expect(unknown.notes.length).toBeGreaterThan(0);
+ const ranked: Record<string, unknown> = {};
+ const clamped = shapeRequestFromWire(ranked, wire, { effort: "max", maxTokens: 64 });
+ expect(ranked).toMatchObject({ reasoning: { effort }, max_output_tokens: 64 });
+ expect(clamped.sentEffort).toBe(effort);
+ }
+ expect(requests).toHaveLength(4);
+ } finally {
+ credentials.register(prior);
+ credentials.register(priorMeta);
+ credentials.invalidate("meta-muse-code");
+ credentials.invalidate("meta");
+ clearSignedArm();
+ d.registerModelDiscoveryFetcher("muse-code-models", fetcher);
+ d.invalidateModelDiscovery("meta-muse-code");
+ _resetCatalogClient();
+ _clearAllModelsCacheMemo();
+ }
+}, 30000);
+
+test("T4: cold registry wait returns within the public five-second budget", async () => {
+ const { museCodeProfile } = await import("./provider-profiles.js");
+ const { _resetCatalogClient } = await import("./catalog-client.js");
+ const { _clearAllModelsCacheMemo } = await import("./all-models-cache.js");
+ _resetCatalogClient();
+ _clearAllModelsCacheMemo();
+ const started = performance.now();
+ const handler = await museCodeProfile.createHandler({
+ provider: {
+ name: "meta-muse-code",
+ baseUrl: "https://api.meta.ai/v1",
+ apiPath: "/responses",
+ apiKeyEnvVar: "",
+ prefixes: ["muse@"],
+ },
+ modelName: "muse-wonder-full-1.0",
+ targetModel: "[email protected]",
+ apiKey: "",
+ port: 0,
+ catalogCachePath: join(home, "cold.json"),
+ sharedOpts: {},
+ });
+ try {
+ expect(handler).not.toBeNull();
+ expect(performance.now() - started).toBeLessThan(6500);
+ } finally {
+ await handler?.shutdown();
+ _resetCatalogClient();
+ _clearAllModelsCacheMemo();
+ }
+}, 8000);
diff --git a/packages/cli/src/providers/routing-rules.muse-code.test.ts b/packages/cli/src/providers/routing-rules.muse-code.test.ts
new file mode 100644
index 00000000..40ef4993
--- /dev/null
+++ b/packages/cli/src/providers/routing-rules.muse-code.test.ts
@@ -0,0 +1,344 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { CredentialProvider } from "../auth/credentials/types.js";
+import type { AggregatorEntry } from "../model-loader.js";
+import type { DiskCacheV3, SlimModelEntry } from "./all-models-cache.js";
+
+let home: string;
+let savedKeychain: string | undefined;
+let cachePath: string;
+let savedFetch: typeof globalThis.fetch;
+let cache: typeof import("./all-models-cache.js");
+
+function connection(id: string, routeId = "meta", routeProfileId = "direct-api"): AggregatorEntry {
+ return {
+ sourceProviderId: routeId,
+ sourceCollectorId: routeId,
+ confidence: "api_official",
+ routeStatus: "mapped",
+ route: { routeId, routeProfileId },
+ externalModelId: id,
+ };
+}
+function seed(aggregators: AggregatorEntry[]): SlimModelEntry {
+ return {
+ contractVersion: 3,
+ modelId: "muse-spark-1.3",
+ provider: "meta",
+ aliases: [],
+ aggregators,
+ };
+}
+function disk(entries: SlimModelEntry[]): DiskCacheV3 {
+ return {
+ version: 3,
+ lastUpdated: new Date().toISOString(),
+ catalogGenerationId: "g-run3-fixture",
+ entries,
+ models: entries.map((entry) => ({ id: entry.modelId })),
+ plans: [],
+ };
+}
+beforeEach(async () => {
+ // All disk access uses the explicit cache path; HOME is not an isolation seam.
+ home = mkdtempSync(join(tmpdir(), "claudish-run3-"));
+ savedKeychain = process.env.CLAUDISH_DISABLE_KEYCHAIN;
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ cachePath = join(home, "all-models.json");
+ savedFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(
+ async () => {
+ throw new Error("Run 3 tests forbid network requests");
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+ cache = await import("./all-models-cache.js");
+ cache._clearAllModelsCacheMemo();
+});
+afterEach(() => {
+ cache?._clearAllModelsCacheMemo();
+ if (savedFetch) globalThis.fetch = savedFetch;
+ if (savedKeychain === undefined) delete process.env.CLAUDISH_DISABLE_KEYCHAIN;
+ else process.env.CLAUDISH_DISABLE_KEYCHAIN = savedKeychain;
+ rmSync(home, { recursive: true, force: true });
+});
+
+let routing: typeof import("./routing-rules.js");
+let gathering: typeof import("./route-candidates.js");
+let catalog: typeof import("./catalog-client.js");
+beforeEach(async () => {
+ routing = await import("./routing-rules.js");
+ gathering = await import("./route-candidates.js");
+ catalog = await import("./catalog-client.js");
+ catalog._resetCatalogClient();
+});
+afterEach(() => {
+ catalog?._setCatalogEntriesForTest(null);
+ catalog?._resetCatalogClient();
+});
+
+const fakeAvailability = new Map<string, boolean>();
+const previousCredentials = new Map<string, CredentialProvider>();
+let authority: typeof import("../auth/credentials/authority.js");
+let billing: typeof import("../auth/credentials/billing-probe.js");
+let discovery: typeof import("./model-discovery.js");
+const credentialNames = ["meta", "meta-muse-code", "openrouter", "opencode-zen", "opencode-zen-go"];
+beforeEach(async () => {
+ authority = await import("../auth/credentials/authority.js");
+ billing = await import("../auth/credentials/billing-probe.js");
+ discovery = await import("./model-discovery.js");
+ // Verify restoration is possible before replacing any registrations.
+ previousCredentials.clear();
+ for (const name of credentialNames) {
+ const previous = authority.credentials.get(name);
+ if (!previous) throw new Error(`No original credential registration for ${name}`);
+ previousCredentials.set(name, previous);
+ }
+ for (const name of credentialNames) {
+ fakeAvailability.set(name, true);
+ authority.credentials.register({
+ catalogName: name,
+ isAvailable: async () => fakeAvailability.get(name) === true,
+ describeReadiness: async () => ({
+ readiness: fakeAvailability.get(name) ? "present" : "absent",
+ }),
+ getRequestAuth: async () => ({
+ headers: {},
+ arm: name === "meta-muse-code" ? "oauth" : "api-key",
+ }),
+ });
+ }
+ billing.clearSignedArm();
+ discovery.invalidateModelDiscovery();
+});
+afterEach(() => {
+ for (const previous of previousCredentials.values()) authority.credentials.register(previous);
+ previousCredentials.clear();
+ fakeAvailability.clear();
+ billing?.clearSignedArm();
+ discovery?.invalidateModelDiscovery();
+});
+
+function routingFixture(modelId = "muse-spark-1.3"): SlimModelEntry {
+ // Cloud models catalog seeds, NOT Meta endpoint responses. Architecture §3(b).
+ return {
+ ...seed([
+ connection(`${modelId}-contributor`, "meta", "direct-api"),
+ connection(modelId, "meta", "direct-api"),
+ connection(`${modelId}-contributor`, "opencode", "go-subscription"),
+ connection(`${modelId}-contributor-free`, "opencode", "zen"),
+ connection(modelId, "opencode", "zen"),
+ connection(`${modelId}-contributor`, "openrouter", "gateway"),
+ connection(modelId, "openrouter", "gateway"),
+ ]),
+ modelId,
+ provider: modelId.startsWith("gemini") ? "google" : "meta",
+ };
+}
+function install(entry: SlimModelEntry, unsupportedPlan = true): void {
+ const data = disk([entry]);
+ if (unsupportedPlan)
+ data.plans = [
+ {
+ id: "meta-muse-code",
+ contractVersion: 3,
+ modelDiscovery: "catalog",
+ routeStatus: "unsupported",
+ routeReason: "no_reviewed_consumer_route",
+ },
+ ];
+ writeFileSync(cachePath, JSON.stringify(data));
+ cache._clearAllModelsCacheMemo();
+ catalog._setCatalogEntriesForTest([entry]);
+}
+
+describe("R1/R3: catalog candidate boundaries", () => {
+ test.each([true, false])(
+ "R1: unsupported/missing plan never synthesizes Muse (plan present=%s)",
+ (present) => {
+ install(routingFixture(), present);
+ const result = gathering.gatherRouteCandidates("muse-spark-1.3", cachePath);
+ expect(result.catalogMiss).toBe(false);
+ expect(result.candidates.map((candidate) => candidate.provider)).not.toContain(
+ "meta-muse-code"
+ );
+ expect(result.candidates[0]?.provider).toBe("meta");
+ expect(result.candidates[0]?.wireId).toBe("muse-spark-1.3");
+ expect(result.candidates.map((candidate) => candidate.provider)).toContain("openrouter");
+ }
+ );
+
+ test("R1: explicit muse@ builds without a subscription route binding", () => {
+ install(routingFixture());
+ expect(routing.buildRoutingChain(["[email protected]"], "muse-spark-1.3", cachePath)).toEqual(
+ [expect.objectContaining({ provider: "meta-muse-code", modelSpec: "[email protected]" })]
+ );
+ });
+
+ test.each(["muse-spark-1.3", "gemini-4-argon"])(
+ "R3: %s excludes Go with content-use reason",
+ (modelId) => {
+ install(routingFixture(modelId));
+ const result = gathering.gatherRouteCandidates(modelId, cachePath);
+ expect(result.candidates.map((candidate) => candidate.provider)).not.toContain(
+ "opencode-zen-go"
+ );
+ expect(result.excluded).toContainEqual(
+ expect.objectContaining({
+ outcome: "excluded-by-content-use",
+ candidate: expect.objectContaining({
+ provider: "opencode-zen-go",
+ wireId: `${modelId}-contributor`,
+ }),
+ })
+ );
+ expect(result.candidates.length).toBeGreaterThan(0);
+ expect(
+ result.candidates.every((candidate) => !/-contributor(?:-free)?$/i.test(candidate.wireId))
+ ).toBe(true);
+ }
+ );
+
+ test("R3: contributor-first Meta/Zen/OpenRouter choices all retain plain wire ids", () => {
+ install(routingFixture());
+ const result = gathering.gatherRouteCandidates("muse-spark-1.3", cachePath);
+ for (const provider of ["meta", "opencode-zen", "openrouter"]) {
+ expect(result.candidates).toContainEqual(
+ expect.objectContaining({ provider, wireId: "muse-spark-1.3" })
+ );
+ }
+ });
+
+ test("R3: zgo user rule excludes a contributor-only mapping", async () => {
+ install(routingFixture("gemini-4-argon"));
+ const routes = routing.buildRoutingChain(["zgo"], "gemini-4-argon", cachePath);
+ expect(routes).toEqual([]);
+ const explanation = await routing.explainRoute("gemini-4-argon", {
+ rules: { "gemini-4-argon": ["zgo"] },
+ defaultProvider: "openrouter",
+ cachePath,
+ });
+ expect(explanation.source).toBe("user-rule");
+ expect(explanation.candidates).toContainEqual(
+ expect.objectContaining({
+ provider: "opencode-zen-go",
+ outcome: "excluded-by-content-use",
+ })
+ );
+ expect(
+ explanation.candidates
+ .filter((row) => row.outcome === "kept")
+ .some((row) => row.provider === "opencode-zen-go")
+ ).toBe(false);
+ });
+
+ test("R3: configured Go fallback cannot synthesize an opt-in wire id", () => {
+ install(routingFixture("gemini-4-argon"));
+ const result = routing.buildCatalogChain("gemini-4-argon", "opencode-zen-go", cachePath);
+ expect(result.catalogReadable).toBe(true);
+ expect(result.routes.length).toBeGreaterThan(0);
+ expect(result.routes.some((route) => /-contributor(?:-free)?$/i.test(route.modelSpec))).toBe(
+ false
+ );
+ expect(result.routes.map((route) => route.provider)).not.toContain("opencode-zen-go");
+ });
+
+ test.each([
+ ["meta", "muse-spark-1.3"],
+ ["zgo", "gemini-4-argon"],
+ ])("R3: typed %s contributor spec survives verbatim", (shortcut, modelId) => {
+ install(routingFixture(modelId));
+ const routes = routing.buildRoutingChain(
+ [`${shortcut}@${modelId}-contributor`],
+ modelId,
+ cachePath
+ );
+ expect(routes).toHaveLength(1);
+ expect(routes[0]!.modelSpec.split("@")[1]).toBe(`${modelId}-contributor`);
+ expect(routes[0]!.provider).toBe(shortcut === "meta" ? "meta" : "opencode-zen-go");
+ });
+
+ test.each([true, false])(
+ "R1: real route/explanation filters Meta credential (available=%s)",
+ async (available) => {
+ install(routingFixture());
+ fakeAvailability.set("meta", available);
+ const explanation = await routing.explainRoute("muse-spark-1.3", {
+ rules: {},
+ defaultProvider: "openrouter",
+ cachePath,
+ });
+ expect(explanation.outcome).toEqual({ kind: "ok" });
+ expect(explanation.candidates.find((row) => row.provider === "meta")?.outcome).toBe(
+ available ? "kept" : "no-credential"
+ );
+ expect(explanation.candidates.some((row) => row.provider === "meta-muse-code")).toBe(false);
+ const plan = await routing.route("muse-spark-1.3", {}, "openrouter", cachePath);
+ expect(plan.kind).toBe("ok");
+ if (plan.kind !== "ok") throw new Error(plan.reason);
+ expect(plan.primary.provider).toBe(available ? "meta" : "opencode-zen");
+ expect(
+ [plan.primary, ...plan.fallbacks].every(
+ (row) => !/-contributor(?:-free)?$/i.test(row.modelSpec)
+ )
+ ).toBe(true);
+ }
+ );
+
+ test("R1: explicit muse@ passes credential filtering without a plan binding", async () => {
+ install(routingFixture());
+ const plan = await routing.route("[email protected]", {}, "openrouter", cachePath);
+ expect(plan.kind).toBe("ok");
+ if (plan.kind !== "ok") throw new Error(plan.reason);
+ expect(plan.primary).toEqual(
+ expect.objectContaining({ provider: "meta-muse-code", modelSpec: "[email protected]" })
+ );
+ });
+
+ test.each(["muse-spark-1.3", "gemini-4-argon"])(
+ "R3: credential-filtered explanation retains %s content-use exclusion",
+ async (modelId) => {
+ install(routingFixture(modelId));
+ const explanation = await routing.explainRoute(modelId, {
+ rules: {},
+ defaultProvider: "opencode-zen-go",
+ cachePath,
+ });
+ expect(explanation.candidates).toContainEqual(
+ expect.objectContaining({
+ provider: "opencode-zen-go",
+ wireId: `${modelId}-contributor`,
+ outcome: "excluded-by-content-use",
+ })
+ );
+ expect(explanation.candidates.filter((row) => row.outcome === "kept").length).toBeGreaterThan(
+ 0
+ );
+ expect(
+ explanation.candidates
+ .filter((row) => row.outcome === "kept")
+ .every((row) => !/-contributor(?:-free)?$/i.test(row.wireId))
+ ).toBe(true);
+ }
+ );
+ test.each([
+ ["meta", "muse-spark-1.3"],
+ ["zgo", "gemini-4-argon"],
+ ])("R3: real explicit %s route retains the contributor id", async (shortcut, modelId) => {
+ install(routingFixture(modelId));
+ const plan = await routing.route(
+ `${shortcut}@${modelId}-contributor`,
+ {},
+ "openrouter",
+ cachePath
+ );
+ expect(plan.kind).toBe("ok");
+ if (plan.kind !== "ok") throw new Error(plan.reason);
+ expect(plan.primary.modelSpec.split("@")[1]).toBe(`${modelId}-contributor`);
+ expect(plan.primary.provider).toBe(shortcut === "meta" ? "meta" : "opencode-zen-go");
+ });
+
+ test.skip("R2 BLOCKED: future supported-plan binding and membership require coherent public binding seam (phase 17)", () => {});
+});
diff --git a/packages/cli/src/providers/transport/meta-muse-code.test.ts b/packages/cli/src/providers/transport/meta-muse-code.test.ts
new file mode 100644
index 00000000..513d9d35
--- /dev/null
+++ b/packages/cli/src/providers/transport/meta-muse-code.test.ts
@@ -0,0 +1,687 @@
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const children: ReturnType<typeof Bun.spawn>[] = [];
+afterEach(() => {
+ for (const child of children.splice(0)) {
+ if (child.exitCode === null) child.kill();
+ }
+});
+async function waitForChild(child: ReturnType<typeof Bun.spawn>) {
+ let timer: ReturnType<typeof setTimeout> | undefined;
+ try {
+ return await Promise.race([
+ child.exited,
+ new Promise<number>((resolve) => {
+ timer = setTimeout(() => {
+ child.kill();
+ resolve(124);
+ }, 4000);
+ }),
+ ]);
+ } finally {
+ clearTimeout(timer);
+ }
+}
+
+let home: string;
+let savedEnv: Record<string, string | undefined>;
+let savedFetch: typeof fetch;
+let savedExit: typeof process.exit;
+// Any unexpected CLI exit must fail the case instead of terminating Bun's runner.
+class UnexpectedProcessExit extends Error {
+ constructor(code?: string | number | null) {
+ super(`RUN5_PROCESS_EXIT:${code ?? 0}`);
+ this.name = "UnexpectedProcessExit";
+ }
+}
+beforeEach(() => {
+ savedEnv = { CLAUDISH_DISABLE_KEYCHAIN: process.env.CLAUDISH_DISABLE_KEYCHAIN };
+ home = mkdtempSync(join(tmpdir(), "muse-run5-"));
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ savedExit = process.exit;
+ process.exit = (code?: string | number | null): never => {
+ throw new UnexpectedProcessExit(code);
+ };
+ savedFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(
+ async () => {
+ throw new Error("Unexpected network in Run 5 test");
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+});
+function restoreHarness() {
+ process.exit = savedExit;
+ globalThis.fetch = savedFetch;
+ for (const [key, value] of Object.entries(savedEnv)) {
+ if (value === undefined) delete process.env[key];
+ else process.env[key] = value;
+ }
+ rmSync(home, { recursive: true, force: true });
+}
+
+// HOME is not an isolation seam in Bun. Every filesystem-capable dependency
+// below is explicit and test-owned; omitted production defaults are forbidden.
+function fakeCoreDeps(
+ overrides: Partial<import("../meta-muse/muse-credentials.js").MuseCoreDeps> = {}
+): import("../meta-muse/muse-credentials.js").MuseCoreDeps {
+ return {
+ dir: () => home,
+ now: () => 1792088000000,
+ readStore: () => null,
+ writeBorrowedCopy: () => {
+ throw new Error("Unexpected borrowed-copy write");
+ },
+ mint: async () => {
+ throw new Error("Unexpected mint");
+ },
+ keychainLogin: async () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+function fakeMuseKeychainDeps(
+ overrides: Partial<import("../meta-muse/muse-keychain.js").MuseKeychainDeps> = {}
+): import("../meta-muse/muse-keychain.js").MuseKeychainDeps {
+ return {
+ dir: () => home,
+ env: () => ({}),
+ now: () => 1792088000000,
+ sleep: async () => {
+ throw new Error("Unexpected Keychain wait");
+ },
+ pid: () => 424242,
+ isAlive: () => false,
+ presence: async () => ({ kind: "absent" }),
+ startRead: () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+let previousConfigPath: string | null;
+const restoreRegistrations: (() => void)[] = [];
+beforeEach(async () => {
+ const keychain = await import("../keychain.js");
+ const forbidden = () => {
+ throw new Error("Real Keychain process forbidden");
+ };
+ keychain.setKeychainTestDeps({
+ platform: () => "darwin",
+ run: forbidden,
+ runAsync: async () => forbidden(),
+ spawnAsync: forbidden,
+ });
+ const core = await import("../meta-muse/muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(fakeCoreDeps());
+ const museKeychain = await import("../meta-muse/muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(fakeMuseKeychainDeps());
+ (await import("../../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ const config = await import("../../config-override.js");
+ previousConfigPath = config.getConfigFileOverride();
+ config.setConfigFileOverride(join(home, "config.json"));
+});
+afterEach(async () => {
+ for (const restore of restoreRegistrations.splice(0).reverse()) restore();
+ const core = await import("../meta-muse/muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(null);
+ const museKeychain = await import("../meta-muse/muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(null);
+ const keychain = await import("../keychain.js");
+ keychain.invalidateKeychainCache();
+ keychain.setKeychainTestDeps(null);
+ (await import("../../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ (await import("../../auth/credentials/billing-probe.js")).clearSignedArm();
+ (await import("../model-discovery.js")).invalidateModelDiscovery("meta-muse-code");
+ (await import("../all-models-cache.js"))._clearAllModelsCacheMemo();
+ (await import("../catalog-client.js"))._resetCatalogClient();
+ (await import("../../config-override.js")).setConfigFileOverride(previousConfigPath);
+ restoreHarness();
+});
+
+test("T2: mint ignores hostile endpoint env and uses the fixed HTTPS Meta root", async () => {
+ const names = ["META_BASE_URL", "MUSE_BASE_URL", "MUSE_CODE_BASE_URL"] as const;
+ const saved = new Map(names.map((name) => [name, process.env[name]]));
+ const requests: { url: string; authorization: string | null; body: unknown }[] = [];
+ let hostileRequests = 0;
+ const hostile = Bun.serve({
+ hostname: "127.0.0.1",
+ port: 0,
+ fetch: () => {
+ hostileRequests++;
+ return new Response("must not receive a Muse credential", { status: 500 });
+ },
+ });
+ try {
+ for (const name of names) process.env[name] = hostile.url.origin;
+ const { mintMuseApiKey } = await import("../meta-muse/muse-mint.js");
+ const { MUSE_MODELS_URL } = await import("../meta-muse/muse-models.js");
+ // §8 response structure with ASCII credential placeholders and a hostile base_url mutation.
+ await mintMuseApiKey("dca:TESTTOKEN0001", {
+ fetch: Object.assign(
+ async (input: string | URL | Request, init?: RequestInit) => {
+ const authorization = new Headers(init?.headers).get("authorization");
+ expect(typeof init?.body).toBe("string");
+ requests.push({
+ url: input instanceof Request ? input.url : String(input),
+ authorization,
+ body: JSON.parse(String(init?.body)),
+ });
+ return Response.json({
+ api_key: "LLM|TESTKEY0001",
+ base_url: hostile.url.origin,
+ has_payment_method: true,
+ require_payment: false,
+ is_subs_active: true,
+ can_subscribe: false,
+ show_subs_upsell: true,
+ user_full_name: "TEST USER",
+ user_email: "[email protected]",
+ user_avatar_url: null,
+ payment_method: "TEST PAYMENT METHOD",
+ action_url: null,
+ subs_tier_id: "<tier-id>",
+ subs_tier_name: "Muse Code Power Usage",
+ is_subs_upgrade_available: true,
+ subs_usage: {
+ window: { used_percent: 1, window_duration_mins: 300, resets_at: 1792136182 },
+ weekly: { used_percent: 0, resets_at: 1792368000 },
+ tier: "<tier-id>",
+ },
+ });
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch,
+ });
+ expect(requests).toEqual([
+ {
+ url: "https://api.meta.ai/muse-code/key",
+ authorization: "Bearer dca:TESTTOKEN0001",
+ body: { onboard: false },
+ },
+ ]);
+ expect(MUSE_MODELS_URL).toBe("https://api.meta.ai/muse-code/models");
+ expect(hostileRequests).toBe(0);
+ } finally {
+ for (const [name, value] of saved) {
+ if (value === undefined) delete process.env[name];
+ else process.env[name] = value;
+ }
+ await hostile.stop(true);
+ }
+});
+
+// Install the real credential implementation through the declared authority seam.
+async function withTransport(
+ run: (
+ t: import("./meta-muse-code.js").MuseCodeTransport,
+ counts: { mints: number }
+ ) => Promise<void>,
+ baseUrl = "https://api.meta.ai/v1"
+) {
+ const core = await import("../meta-muse/muse-credentials.js");
+ const d = await import("../model-discovery.js");
+ await import("../model-discovery-builtins.js");
+ const { credentials } = await import("../../auth/credentials/authority.js");
+ const { MuseCodeCredentialProvider } = await import(
+ "../../auth/credentials/muse-code-credential.js"
+ );
+ const { setCredentialPromptRole } = await import("../../auth/credentials/prompt-role.js");
+ const { clearSignedArm } = await import("../../auth/credentials/billing-probe.js");
+ const { MuseCodeTransport } = await import("./meta-muse-code.js");
+ const prior = credentials.get("meta-muse-code");
+ if (!prior) throw new Error("default Muse credential missing");
+ const fetcher = d.getModelDiscoveryFetcher("muse-code-models");
+ if (!fetcher) throw new Error("default discovery missing");
+ restoreRegistrations.push(() => {
+ credentials.register(prior);
+ credentials.invalidate("meta-muse-code");
+ d.registerModelDiscoveryFetcher("muse-code-models", fetcher);
+ });
+ const role = setCredentialPromptRole("never");
+ const counts = { mints: 0 };
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps({
+ ...fakeCoreDeps(),
+ dir: () => home,
+ readStore: (kind) => (kind === "borrowed-copy" ? { access_token: "dca:TESTTOKEN0001" } : null),
+ keychainLogin: async () => {
+ throw new Error("Keychain forbidden");
+ },
+ mint: async () => ({ apiKey: ++counts.mints === 1 ? "LLM|TESTKEY0001" : "LLM|TESTKEY0002" }),
+ });
+ credentials.register(new MuseCodeCredentialProvider());
+ d.invalidateModelDiscovery("meta-muse-code");
+ d.registerModelDiscoveryFetcher("muse-code-models", async () => ({
+ kind: "models",
+ models: [{ id: "muse-spark-1.3", contextWindow: 262144, reported: "chat" }],
+ }));
+ const transport = new MuseCodeTransport(
+ {
+ name: "meta-muse-code",
+ baseUrl,
+ apiPath: "/hostile",
+ prefixes: ["muse@"],
+ apiKeyEnvVar: "",
+ streamFormatOverride: "openai-responses-sse",
+ },
+ "muse-spark-1.3",
+ "constructor-key-must-not-sign"
+ );
+ try {
+ await run(transport, counts);
+ } finally {
+ credentials.register(prior);
+ credentials.invalidate("meta-muse-code");
+ clearSignedArm();
+ d.registerModelDiscoveryFetcher("muse-code-models", fetcher);
+ d.invalidateModelDiscovery("meta-muse-code");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(null);
+ setCredentialPromptRole(role);
+ }
+}
+
+test("T1: Responses endpoint, minted bearer and stateless tool/reasoning payload", async () => {
+ await withTransport(async (t, counts) => {
+ await t.refreshAuth();
+ expect(t.getEndpoint()).toBe("https://api.meta.ai/v1/responses");
+ expect(t.overrideStreamFormat() ?? t.streamFormat).toBe("openai-responses-sse");
+ expect(
+ Object.entries(await t.getHeaders()).find(
+ ([name]) => name.toLowerCase() === "authorization"
+ )?.[1]
+ ).toBe("Bearer LLM|TESTKEY0001");
+ // Tool-round-trip item structures from §2.3 with ASCII placeholder values.
+ const input = [
+ {
+ type: "reasoning",
+ id: "rs_TEST0001:rs_TEST0002",
+ encrypted_content: "Q-PaDgTESTENCRYPTED0001",
+ },
+ {
+ type: "function_call",
+ id: "fc_TEST0001",
+ call_id: "call_TEST0001",
+ name: "muse.read_file",
+ arguments: '{"path":"note.txt"}',
+ },
+ {
+ type: "function_call_output",
+ call_id: "call_TEST0001",
+ output: "Read text file `note.txt`.\n1|The secret word is MANGO-42.",
+ },
+ ];
+ const payload = t.transformPayload({
+ model: "muse-spark-1.3",
+ input,
+ store: true,
+ reasoning: { effort: "high" },
+ });
+ expect(payload).toMatchObject({ store: false, reasoning: { summary: "auto", effort: "high" } });
+ expect(payload.include).toContain("reasoning.encrypted_content");
+ expect(payload.input).toEqual(input);
+ expect(counts.mints).toBe(1);
+ });
+});
+
+test("T1: subscription_usage after completed preserves text, tools, usage and one completion", async () => {
+ const { Hono } = await import("hono");
+ const { createResponsesStreamHandler } = await import(
+ "../../handlers/shared/stream-parsers/openai-responses-sse.js"
+ );
+ // Capture-derived reconstruction: §2.4 event fields, §2.3 tool item.
+ const call = {
+ type: "function_call",
+ id: "fc_TEST0001",
+ call_id: "call_TEST0001",
+ name: "muse.read_file",
+ arguments: '{"path":"note.txt"}',
+ };
+ const reasoning = {
+ type: "reasoning",
+ id: "rs_TEST0001:rs_TEST0002",
+ encrypted_content: "Q-PaDgTESTENCRYPTED0001",
+ };
+ const events = [
+ { type: "response.created", response: { id: "resp_[redacted]" } },
+ {
+ type: "response.output_item.added",
+ output_index: 0,
+ item: { type: "message", id: "msg_[redacted]", role: "assistant", content: [] },
+ },
+ { type: "response.output_text.delta", output_index: 0, content_index: 0, delta: "PONG" },
+ { type: "response.output_item.added", output_index: 2, item: reasoning },
+ { type: "response.output_item.done", output_index: 2, item: reasoning },
+ { type: "response.output_item.added", output_index: 1, item: { ...call, arguments: "" } },
+ {
+ type: "response.function_call_arguments.delta",
+ output_index: 1,
+ item_id: call.id,
+ delta: call.arguments,
+ },
+ { type: "response.output_item.done", output_index: 1, item: call },
+ {
+ type: "response.completed",
+ response: {
+ id: "resp_[redacted]",
+ usage: {
+ input_tokens: 27,
+ input_tokens_details: { cached_tokens: 0 },
+ output_tokens: 9,
+ output_tokens_details: { reasoning_tokens: 2 },
+ },
+ },
+ },
+ {
+ type: "response.subscription_usage",
+ subscription: {
+ tier: "<tier-id>",
+ weekly: { resets_at: 1792368000, used_percent: 0 },
+ window: { resets_at: 1792088451, used_percent: 2, window_duration_mins: 300 },
+ },
+ },
+ ];
+ const wire =
+ events
+ .map(
+ (e, sequence_number) =>
+ `event: ${e.type}\ndata: ${JSON.stringify({ ...e, sequence_number })}\n\n`
+ )
+ .join("") + "data: [DONE]\n\n";
+ const usage: number[][] = [];
+ let ends = 0;
+ const app = new Hono();
+ app.get("/", (c) =>
+ createResponsesStreamHandler(
+ c,
+ new Response(wire, { headers: { "content-type": "text/event-stream" } }),
+ {
+ modelName: "muse-spark-1.3",
+ onTokenUpdate: (i, o) => usage.push([i, o]),
+ onTurnEnd: () => {
+ ends++;
+ },
+ }
+ )
+ );
+ const response = await app.request("http://localhost/");
+ const body = await response.text();
+ expect(response.status).toBe(200);
+ expect(body).toContain("PONG");
+ expect(body).toContain("muse.read_file");
+ expect(body).toContain("note.txt");
+ expect(body.match(/event: message_stop/g) ?? []).toHaveLength(1);
+ expect(usage.at(-1)).toEqual([27, 9]);
+ expect(ends).toBe(1);
+ // Replay the parsed reasoning cache through the Responses converter on the
+ // next Anthropic tool-result turn; use the public adapter constructor/methods.
+ const { CodexAPIFormat } = await import("../../adapters/codex-api-format.js");
+ const adapter = new CodexAPIFormat("muse-spark-1.3", "openai-responses-sse", {
+ codexExtras: false,
+ });
+ const emittedTool = body.split("\n\n").flatMap((frame) => {
+ const data = frame.split("\n").find((line) => line.startsWith("data: "));
+ if (!data || data.slice(6) === "[DONE]") return [];
+ const event = JSON.parse(data.slice(6));
+ return event.type === "content_block_start" && event.content_block?.type === "tool_use"
+ ? [event.content_block]
+ : [];
+ });
+ expect(emittedTool).toHaveLength(1);
+ expect(typeof emittedTool[0].id).toBe("string");
+ expect(emittedTool[0].id.length).toBeGreaterThan(0);
+ const emittedToolId = emittedTool[0].id;
+ const original = {
+ model: "muse-spark-1.3",
+ max_tokens: 64,
+ stream: true,
+ messages: [
+ {
+ role: "assistant",
+ content: [
+ { type: "tool_use", id: emittedToolId, name: call.name, input: { path: "note.txt" } },
+ ],
+ },
+ {
+ role: "user",
+ content: [
+ {
+ type: "tool_result",
+ tool_use_id: emittedToolId,
+ content: "Read text file `note.txt`.\n1|The secret word is MANGO-42.",
+ },
+ ],
+ },
+ ],
+ };
+ const replay = adapter.buildPayload(original, adapter.convertMessages(original), []);
+ expect(replay.input).toEqual(
+ expect.arrayContaining([
+ expect.objectContaining({
+ type: "reasoning",
+ encrypted_content: reasoning.encrypted_content,
+ }),
+ expect.objectContaining({
+ type: "function_call",
+ call_id: emittedToolId,
+ name: call.name,
+ arguments: call.arguments,
+ }),
+ expect.objectContaining({
+ type: "function_call_output",
+ call_id: emittedToolId,
+ output: "Read text file `note.txt`.\n1|The secret word is MANGO-42.",
+ }),
+ ])
+ );
+});
+
+test("T2: hostile provider/config/.env cannot redirect inference or models", async () => {
+ const { getConfigFileOverride, setConfigFileOverride } = await import("../../config-override.js");
+ const { getProviderByName, getEffectiveBaseUrl } = await import("../provider-definitions.js");
+ const previous = getConfigFileOverride();
+ const names = ["META_BASE_URL", "MUSE_BASE_URL", "MUSE_CODE_BASE_URL"];
+ const saved = names.map((n) => [n, process.env[n]] as const);
+ let hostileRequests = 0;
+ const hostile = Bun.serve({
+ hostname: "127.0.0.1",
+ port: 0,
+ fetch: () => {
+ hostileRequests++;
+ return new Response("forbidden");
+ },
+ });
+ const urls: string[] = [];
+ try {
+ for (const n of names) process.env[n] = hostile.url.origin;
+ writeFileSync(join(home, ".env"), names.map((n) => `${n}=${hostile.url.origin}`).join("\n"));
+ const config = join(home, "config.json");
+ writeFileSync(
+ config,
+ JSON.stringify({
+ version: "1",
+ defaultProfile: "default",
+ profiles: {},
+ endpoints: { "meta-muse-code": hostile.url.origin, muse: hostile.url.origin },
+ })
+ );
+ setConfigFileOverride(config);
+ const def = getProviderByName("meta-muse-code");
+ if (!def) throw new Error("Muse definition missing");
+ expect(new URL(getEffectiveBaseUrl(def)).hostname).toBe("api.meta.ai");
+ await withTransport(async (t) => {
+ await t.refreshAuth();
+ globalThis.fetch = Object.assign(
+ async (input: string | URL | Request) => {
+ const url = input instanceof Request ? input.url : String(input);
+ urls.push(url);
+ if (url === "https://api.meta.ai/muse-code/models") return Response.json({ data: [] });
+ if (url === "https://api.meta.ai/v1/responses")
+ return new Response("data: [DONE]\n\n", {
+ headers: { "content-type": "text/event-stream" },
+ });
+ throw new Error(`Unexpected URL ${url}`);
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+ const { fetchMuseCodeModelsCatalog } = await import("../meta-muse/muse-models.js");
+ await fetchMuseCodeModelsCatalog();
+ await fetch(t.getEndpoint(), {
+ method: "POST",
+ headers: await t.getHeaders(),
+ body: JSON.stringify(t.transformPayload({ input: [] })),
+ });
+ }, hostile.url.origin);
+ expect(urls).toEqual([
+ "https://api.meta.ai/muse-code/models",
+ "https://api.meta.ai/v1/responses",
+ ]);
+ expect(hostileRequests).toBe(0);
+ // Bun's fresh process loads this test-owned .env before any module import.
+ // Remove the parent overrides so that this assertion actually tests .env.
+ const childEnv: Record<string, string | undefined> = {
+ ...process.env,
+ HOME: home,
+ TMPDIR: home,
+ CLAUDISH_DISABLE_KEYCHAIN: "1",
+ CLAUDISH_DISABLE_CATALOG_WARM: "1",
+ };
+ for (const n of names) delete childEnv[n];
+ const script = `
+const realExit = process.exit.bind(process);
+process.on("uncaughtException", error => { console.error(error); realExit(1); });
+process.on("unhandledRejection", error => { console.error(error); realExit(1); });
+ globalThis.fetch = async () => { throw new Error("network forbidden"); };
+ const { setConfigFileOverride } = await import(${JSON.stringify(new URL("../../config-override.js", import.meta.url).href)});
+ setConfigFileOverride(${JSON.stringify(config)});
+ const core = await import(${JSON.stringify(new URL("../meta-muse/muse-credentials.js", import.meta.url).href)});
+ core.setMuseCoreTestDeps({ dir: () => ${JSON.stringify(home)}, now: () => 1792088000000,
+ readStore: () => null, writeBorrowedCopy: () => { throw new Error("write forbidden"); },
+ keychainLogin: async () => { throw new Error("Keychain forbidden"); },
+ mint: async () => { throw new Error("mint forbidden"); } });
+ const { MuseCodeTransport } = await import(${JSON.stringify(new URL("./meta-muse-code.js", import.meta.url).href)});
+ const { MUSE_MODELS_URL } = await import(${JSON.stringify(new URL("../meta-muse/muse-models.js", import.meta.url).href)});
+ const t = new MuseCodeTransport({ name: "meta-muse-code", baseUrl: process.env.MUSE_CODE_BASE_URL,
+ apiPath: "/hostile", apiKeyEnvVar: "", prefixes: ["muse@"] }, "muse-spark-1.3", "");
+ console.log(JSON.stringify([process.env.MUSE_CODE_BASE_URL, t.getEndpoint(), MUSE_MODELS_URL]));
+ realExit(0);
+ `;
+ const child = Bun.spawn([process.execPath, "--eval", script], {
+ cwd: home,
+ env: childEnv,
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ children.push(child);
+ const [stdout, stderr, exit] = await Promise.all([
+ new Response(child.stdout).text(),
+ new Response(child.stderr).text(),
+ waitForChild(child),
+ ]);
+ expect({ exit, stderr }).toEqual({ exit: 0, stderr: "" });
+ expect(JSON.parse(stdout.trim())).toEqual([
+ hostile.url.origin,
+ "https://api.meta.ai/v1/responses",
+ "https://api.meta.ai/muse-code/models",
+ ]);
+ } finally {
+ setConfigFileOverride(previous);
+ for (const [n, v] of saved) {
+ if (v === undefined) delete process.env[n];
+ else process.env[n] = v;
+ }
+ await hostile.stop(true);
+ }
+});
+
+for (const freshRejected of [false, true]) {
+ test(`T3: handler remints once after 401; fresh-key rejection=${freshRejected}`, async () => {
+ await withTransport(async (t, counts) => {
+ const { Hono } = await import("hono");
+ const { ComposedHandler } = await import("../../handlers/composed-handler.js");
+ const requests: { url: string; headers: unknown }[] = [];
+ globalThis.fetch = Object.assign(
+ async (input: string | URL | Request, init?: RequestInit) => {
+ const url = input instanceof Request ? input.url : String(input);
+ expect(url).toBe("https://api.meta.ai/v1/responses");
+ requests.push({ url, headers: init?.headers });
+ if (requests.length === 2 && !freshRejected) {
+ // Capture-derived reconstruction from §2.4.
+ const events = [
+ { type: "response.created", response: { id: "resp_[redacted]" } },
+ {
+ type: "response.output_item.added",
+ output_index: 0,
+ item: { type: "message", id: "msg_[redacted]", role: "assistant", content: [] },
+ },
+ {
+ type: "response.output_text.delta",
+ output_index: 0,
+ content_index: 0,
+ delta: "PONG",
+ },
+ {
+ type: "response.completed",
+ response: { id: "resp_[redacted]", usage: { input_tokens: 27, output_tokens: 9 } },
+ },
+ ];
+ return new Response(
+ events.map((e) => `event: ${e.type}\ndata: ${JSON.stringify(e)}\n\n`).join("") +
+ "data: [DONE]\n\n",
+ { headers: { "content-type": "text/event-stream" } }
+ );
+ }
+ // Captured §7 synthetic invalid-key body, repeated on rejected refresh.
+ return Response.json(
+ { error: { type: "invalid_api_key", message: "Unauthorized" } },
+ { status: 401 }
+ );
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+ const handler = new ComposedHandler(t, "[email protected]", "muse-spark-1.3", 0);
+ const app = new Hono();
+ app.post("/", (c) =>
+ handler.handle(c, {
+ model: "muse-spark-1.3",
+ messages: [{ role: "user", content: "PONG" }],
+ max_tokens: 16,
+ stream: true,
+ })
+ );
+ try {
+ const response = await app.request("http://localhost/", { method: "POST" });
+ expect(response.status).toBe(freshRejected ? 400 : 200);
+ const body = await response.text();
+ if (freshRejected) {
+ expect(response.headers.get("x-claudish-auth-verdict")).toBe("terminal");
+ expect(body).toContain("claudish login muse");
+ } else expect(body).toContain("PONG");
+ expect(counts.mints).toBe(2);
+ expect(requests).toHaveLength(2);
+ expect(JSON.stringify(requests[0].headers)).toContain("Bearer LLM|TESTKEY0001");
+ expect(JSON.stringify(requests[1].headers)).toContain("Bearer LLM|TESTKEY0002");
+ expect(JSON.stringify(requests)).not.toContain("constructor-key-must-not-sign");
+ } finally {
+ await handler.shutdown();
+ }
+ });
+ });
+}
+
+// The parser and Responses converter share a process-wide reasoning cache.
+beforeEach(async () => {
+ (await import("../../adapters/reasoning-cache.js")).clearReasoningCache();
+});
+afterEach(async () => {
+ (await import("../../adapters/reasoning-cache.js")).clearReasoningCache();
+});
diff --git a/packages/cli/src/proxy-server.muse-code.test.ts b/packages/cli/src/proxy-server.muse-code.test.ts
new file mode 100644
index 00000000..38d1beca
--- /dev/null
+++ b/packages/cli/src/proxy-server.muse-code.test.ts
@@ -0,0 +1,426 @@
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+
+const children: ReturnType<typeof Bun.spawn>[] = [];
+afterEach(() => {
+ for (const child of children.splice(0)) {
+ if (child.exitCode === null) child.kill();
+ }
+});
+async function waitForChild(child: ReturnType<typeof Bun.spawn>) {
+ let timer: ReturnType<typeof setTimeout> | undefined;
+ try {
+ return await Promise.race([
+ child.exited,
+ new Promise<number>((resolve) => {
+ timer = setTimeout(() => {
+ child.kill();
+ resolve(124);
+ }, 4000);
+ }),
+ ]);
+ } finally {
+ clearTimeout(timer);
+ }
+}
+
+let home: string;
+let savedEnv: Record<string, string | undefined>;
+let savedFetch: typeof fetch;
+let savedExit: typeof process.exit;
+// Any unexpected CLI exit must fail the case instead of terminating Bun's runner.
+class UnexpectedProcessExit extends Error {
+ constructor(code?: string | number | null) {
+ super(`RUN5_PROCESS_EXIT:${code ?? 0}`);
+ this.name = "UnexpectedProcessExit";
+ }
+}
+beforeEach(() => {
+ savedEnv = { CLAUDISH_DISABLE_KEYCHAIN: process.env.CLAUDISH_DISABLE_KEYCHAIN };
+ home = mkdtempSync(join(tmpdir(), "muse-run5-"));
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ savedExit = process.exit;
+ process.exit = (code?: string | number | null): never => {
+ throw new UnexpectedProcessExit(code);
+ };
+ savedFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(
+ async () => {
+ throw new Error("Unexpected network in Run 5 test");
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+});
+function restoreHarness() {
+ process.exit = savedExit;
+ globalThis.fetch = savedFetch;
+ for (const [key, value] of Object.entries(savedEnv)) {
+ if (value === undefined) delete process.env[key];
+ else process.env[key] = value;
+ }
+ rmSync(home, { recursive: true, force: true });
+}
+
+// HOME is not an isolation seam in Bun. Every filesystem-capable dependency
+// below is explicit and test-owned; omitted production defaults are forbidden.
+function fakeCoreDeps(
+ overrides: Partial<import("./providers/meta-muse/muse-credentials.js").MuseCoreDeps> = {}
+): import("./providers/meta-muse/muse-credentials.js").MuseCoreDeps {
+ return {
+ dir: () => home,
+ now: () => 1792088000000,
+ readStore: () => null,
+ writeBorrowedCopy: () => {
+ throw new Error("Unexpected borrowed-copy write");
+ },
+ mint: async () => {
+ throw new Error("Unexpected mint");
+ },
+ keychainLogin: async () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+function fakeMuseKeychainDeps(
+ overrides: Partial<import("./providers/meta-muse/muse-keychain.js").MuseKeychainDeps> = {}
+): import("./providers/meta-muse/muse-keychain.js").MuseKeychainDeps {
+ return {
+ dir: () => home,
+ env: () => ({}),
+ now: () => 1792088000000,
+ sleep: async () => {
+ throw new Error("Unexpected Keychain wait");
+ },
+ pid: () => 424242,
+ isAlive: () => false,
+ presence: async () => ({ kind: "absent" }),
+ startRead: () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+let previousConfigPath: string | null;
+const restoreRegistrations: (() => void)[] = [];
+beforeEach(async () => {
+ const keychain = await import("./providers/keychain.js");
+ const forbidden = () => {
+ throw new Error("Real Keychain process forbidden");
+ };
+ keychain.setKeychainTestDeps({
+ platform: () => "darwin",
+ run: forbidden,
+ runAsync: async () => forbidden(),
+ spawnAsync: forbidden,
+ });
+ const core = await import("./providers/meta-muse/muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(fakeCoreDeps());
+ const museKeychain = await import("./providers/meta-muse/muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(fakeMuseKeychainDeps());
+ (await import("./auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ const config = await import("./config-override.js");
+ previousConfigPath = config.getConfigFileOverride();
+ config.setConfigFileOverride(join(home, "config.json"));
+});
+afterEach(async () => {
+ for (const restore of restoreRegistrations.splice(0).reverse()) restore();
+ const core = await import("./providers/meta-muse/muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(null);
+ const museKeychain = await import("./providers/meta-muse/muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(null);
+ const keychain = await import("./providers/keychain.js");
+ keychain.invalidateKeychainCache();
+ keychain.setKeychainTestDeps(null);
+ (await import("./auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ (await import("./auth/credentials/billing-probe.js")).clearSignedArm();
+ (await import("./providers/model-discovery.js")).invalidateModelDiscovery("meta-muse-code");
+ (await import("./providers/all-models-cache.js"))._clearAllModelsCacheMemo();
+ (await import("./providers/catalog-client.js"))._resetCatalogClient();
+ (await import("./config-override.js")).setConfigFileOverride(previousConfigPath);
+ restoreHarness();
+});
+
+// HOME must be present at process start: keep default-path consumers in Bun children.
+// The callback and fake builders are serialized after Bun has stripped TypeScript.
+async function runHomeScenario(
+ scenario: (transportAvailable: boolean) => Promise<Record<string, unknown>>,
+ transportAvailable: boolean
+) {
+ const absoluteImports = (source: string) =>
+ source.replace(
+ /import\((["'])(\.[^"']+)\1\)/g,
+ (_match, _quote, path) => `import(${JSON.stringify(resolve(import.meta.dir, path))})`
+ );
+ const scriptPath = join(home, "scenario.ts");
+ const setup = `
+ import { expect } from "bun:test";
+ import fs from "node:fs";
+ import fsp from "node:fs/promises";
+ import { syncBuiltinESMExports } from "node:module";
+ import { join, resolve, relative, isAbsolute } from "node:path";
+ import { fileURLToPath } from "node:url";
+ import { homedir } from "node:os";
+const realExit = process.exit.bind(process);
+process.on("uncaughtException", error => { console.error(error); realExit(1); });
+process.on("unhandledRejection", error => { console.error(error); realExit(1); });
+ const home = process.env.HOME;
+ expect(homedir()).toBe(home);
+ process.exit = code => { throw new Error("RUN5_CHILD_EXIT:" + (code ?? 0)); };
+ const savedFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(async (input, init) => {
+ const url = new URL(input instanceof Request ? input.url : String(input));
+ if (url.protocol !== "http:" && url.protocol !== "https:") return savedFetch(input, init);
+ throw new Error("Unexpected child network: " + url.href);
+ }, { preconnect() {} });
+ // Audit and reject filesystem mutations outside the child's owned HOME.
+ // Apply before implementation imports, including their singleton setup.
+ const outsideWrites = [];
+ const writes = [];
+ function checkWrite(path) {
+ if (typeof path === "number") return; // fd was checked when opened
+ const target = resolve(path instanceof URL ? fileURLToPath(path) : String(path));
+ const rel = relative(home, target);
+ if (rel === ".." || rel.startsWith("../") || isAbsolute(rel)) {
+ outsideWrites.push(target);
+ throw new Error("Outside-HOME mutation forbidden: " + target);
+ }
+ writes.push(rel);
+ }
+ for (const api of [fs, fsp]) {
+ for (const name of ["writeFile", "writeFileSync", "appendFile", "appendFileSync", "mkdir", "mkdirSync",
+ "rm", "rmSync", "rmdir", "rmdirSync", "unlink", "unlinkSync", "chmod", "chmodSync",
+ "truncate", "truncateSync", "utimes", "utimesSync", "createWriteStream", "mkdtemp", "mkdtempSync"]) {
+ const original = api[name];
+ if (original) api[name] = function(path, ...args) { checkWrite(path); return original.call(this, path, ...args); };
+ }
+ for (const name of ["rename", "renameSync", "copyFile", "copyFileSync", "cp", "cpSync", "link", "linkSync", "symlink", "symlinkSync"]) {
+ const original = api[name];
+ if (original) api[name] = function(from, to, ...args) {
+ if (name.startsWith("rename")) checkWrite(from);
+ checkWrite(to); return original.call(this, from, to, ...args);
+ };
+ }
+ for (const name of ["open", "openSync"]) {
+ const original = api[name];
+ if (original) api[name] = function(path, flags, ...args) {
+ if (typeof flags === "number" ? (flags & 3) !== 0 || (flags & (fs.constants.O_CREAT | fs.constants.O_TRUNC)) !== 0 : /[wa+]/.test(flags)) checkWrite(path);
+ return original.call(this, path, flags, ...args);
+ };
+ }
+ }
+ const bunWrite = Bun.write;
+ Bun.write = (path, ...args) => { checkWrite(path); return bunWrite(path, ...args); };
+ syncBuiltinESMExports();
+ `;
+ const initialization = `
+ let keychainOperations = 0;
+ const forbidden = () => { keychainOperations++; throw new Error("Real Keychain process forbidden"); };
+ const generic = await import(${JSON.stringify(resolve(import.meta.dir, "./providers/keychain.js"))});
+ generic.setKeychainTestDeps({ platform: () => "darwin", run: forbidden, runAsync: async () => forbidden(), spawnAsync: forbidden });
+ const coreSetup = await import(${JSON.stringify(resolve(import.meta.dir, "./providers/meta-muse/muse-credentials.js"))});
+ coreSetup.resetMuseCredentialState(); coreSetup.setMuseCoreTestDeps(fakeCoreDeps());
+ const keychainSetup = await import(${JSON.stringify(resolve(import.meta.dir, "./providers/meta-muse/muse-keychain.js"))});
+ keychainSetup.resetMuseKeychainState(); keychainSetup.setMuseKeychainTestDeps(fakeMuseKeychainDeps());
+ (await import(${JSON.stringify(resolve(import.meta.dir, "./auth/credentials/prompt-role.js"))}))._resetCredentialPromptRoleForTest();
+ (await import(${JSON.stringify(resolve(import.meta.dir, "./config-override.js"))})).setConfigFileOverride(join(home, "config.json"));
+ `;
+ writeFileSync(
+ scriptPath,
+ setup +
+ absoluteImports(fakeCoreDeps.toString()) +
+ "\n" +
+ absoluteImports(fakeMuseKeychainDeps.toString()) +
+ initialization +
+ `\nconst result = await (${absoluteImports(scenario.toString())})(${JSON.stringify(transportAvailable)});\n` +
+ "expect(outsideWrites).toEqual([]);\nexpect(keychainOperations).toBe(0);\nconsole.log(JSON.stringify({ ...result, outsideWrites, writes, keychainOperations }));\nrealExit(0);\n"
+ );
+ const child = Bun.spawn([process.execPath, scriptPath], {
+ cwd: home,
+ env: {
+ ...process.env,
+ HOME: home,
+ TMPDIR: home,
+ CLAUDISH_DISABLE_KEYCHAIN: "1",
+ CLAUDISH_DISABLE_CATALOG_WARM: "1",
+ },
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ children.push(child);
+ const [stdout, stderr, exitCode] = await Promise.all([
+ new Response(child.stdout).text(),
+ new Response(child.stderr).text(),
+ waitForChild(child),
+ ]);
+ expect(exitCode, stderr).toBe(0);
+ const lines = stdout.trim().split("\n");
+ expect(lines, stderr).toHaveLength(1);
+ const result = JSON.parse(lines[0]);
+ expect(result.outsideWrites).toEqual([]);
+ expect(result.keychainOperations).toBe(0);
+ return result;
+}
+
+for (const transportAvailable of [true, false]) {
+ test(`N5: isolated-home Muse probe-discover before binding with transport=${transportAvailable}; borrowed concurrent requests never read Keychain`, async () => {
+ const scenario = async (transportAvailable: boolean) => {
+ const { createProxyServer } = await import("./proxy-server.js");
+ const { discoverProbeModelFromEndpoint } = await import("./providers/probe-catalog.js");
+ const { catalogRouteForProvider } = await import("./providers/catalog-route-bindings.js");
+ const { getProviderByName } = await import("./providers/provider-definitions.js");
+ const { getConfigFileOverride, setConfigFileOverride } = await import("./config-override.js");
+ const { _clearProbeDiscoveryCache } = await import(
+ "./providers/transport/probe-discovery.js"
+ );
+ const core = await import("./providers/meta-muse/muse-credentials.js");
+ const keychain = await import("./providers/meta-muse/muse-keychain.js");
+ const { setCredentialPromptRole } = await import("./auth/credentials/prompt-role.js");
+ const { credentials } = await import("./auth/credentials/authority.js");
+ const { MuseCodeCredentialProvider } = await import(
+ "./auth/credentials/muse-code-credential.js"
+ );
+ const { clearSignedArm } = await import("./auth/credentials/billing-probe.js");
+ const d = await import("./providers/model-discovery.js");
+ await import("./providers/model-discovery-builtins.js");
+ const prior = credentials.get("meta-muse-code");
+ const fetcher = d.getModelDiscoveryFetcher("muse-code-models");
+ const definition = getProviderByName("meta-muse-code");
+ if (!prior || !fetcher || !definition) throw new Error("missing Muse registration");
+ const factory = definition.createHandler;
+ const config = getConfigFileOverride();
+ setConfigFileOverride(join(home, "config.json"));
+ const role = setCredentialPromptRole("never");
+ let reads = 0;
+ let mints = 0;
+ let factoryCalls = 0;
+ let upstream = 0;
+ const statuses: number[] = [];
+ keychain.resetMuseKeychainState();
+ keychain.setMuseKeychainTestDeps({
+ ...fakeMuseKeychainDeps(),
+ dir: () => home,
+ presence: async () => {
+ reads++;
+ return { kind: "absent" };
+ },
+ startRead: () => {
+ reads++;
+ throw new Error("Keychain forbidden");
+ },
+ });
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps({
+ ...fakeCoreDeps(),
+ dir: () => home,
+ readStore: (kind) =>
+ kind === "borrowed-copy" ? { access_token: "dca:TESTTOKEN0001" } : null,
+ mint: async () => {
+ mints++;
+ return { apiKey: "LLM|TESTKEY0001" };
+ },
+ keychainLogin: async () => {
+ reads++;
+ throw new Error("Keychain forbidden");
+ },
+ });
+ credentials.register(new MuseCodeCredentialProvider());
+ d.registerModelDiscoveryFetcher("muse-code-models", async () => ({
+ kind: "models",
+ models: [{ id: "muse-spark-1.3", reported: "chat", contextWindow: 262144 }],
+ }));
+ d.invalidateModelDiscovery("meta-muse-code");
+ _clearProbeDiscoveryCache();
+ // The public factory permits a handler without a transport: exercise the
+ // provider-level discovery fallback without reaching into private members.
+ if (!transportAvailable)
+ definition.createHandler = async () => {
+ factoryCalls++;
+ return {
+ handle: async () => new Response("no inference in fallback fixture", { status: 418 }),
+ shutdown: async () => {},
+ };
+ };
+ let proxy: Awaited<ReturnType<typeof createProxyServer>> | undefined;
+ try {
+ expect(catalogRouteForProvider("meta-muse-code")).toBeUndefined();
+ proxy = await createProxyServer(0, "", "[email protected]", false, undefined, undefined, {
+ quiet: true,
+ });
+ const origin = new URL(proxy.url).origin;
+ globalThis.fetch = Object.assign(
+ (input: string | URL | Request, init?: RequestInit) => {
+ const url = input instanceof Request ? input.url : String(input);
+ if (new URL(url).origin === origin) return savedFetch(input, init);
+ if (url === "https://api.meta.ai/v1/responses") {
+ upstream++;
+ return Promise.resolve(
+ Response.json(
+ { error: { type: "invalid_api_key", message: "Unauthorized" } },
+ { status: 401 }
+ )
+ );
+ }
+ throw new Error(`Unexpected URL ${url}`);
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+ const result = await discoverProbeModelFromEndpoint(proxy.url, "meta-muse-code");
+ expect(result.model).toBe("muse-spark-1.3");
+ if (transportAvailable) {
+ const request = () =>
+ fetch(`${origin}/v1/messages`, {
+ method: "POST",
+ headers: { "content-type": "application/json" },
+ body: JSON.stringify({
+ model: "[email protected]",
+ max_tokens: 16,
+ stream: true,
+ messages: [{ role: "user", content: "PONG" }],
+ }),
+ });
+ const responses = await Promise.all([request(), request()]);
+ for (const response of responses) {
+ statuses.push(response.status);
+ expect(response.status).toBe(400);
+ expect(response.headers.get("x-claudish-auth-verdict")).toBe("terminal");
+ expect(await response.text()).toContain("claudish login muse");
+ }
+ expect(upstream).toBeGreaterThanOrEqual(2);
+ expect(mints).toBeGreaterThan(0);
+ } else expect(factoryCalls).toBeGreaterThan(0);
+ expect(reads).toBe(0);
+ return { model: result.model, reads, mints, factoryCalls, upstream, statuses };
+ } finally {
+ await proxy?.shutdown();
+ definition.createHandler = factory;
+ credentials.register(prior);
+ credentials.invalidate("meta-muse-code");
+ clearSignedArm();
+ d.registerModelDiscoveryFetcher("muse-code-models", fetcher);
+ d.invalidateModelDiscovery("meta-muse-code");
+ _clearProbeDiscoveryCache();
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(null);
+ keychain.resetMuseKeychainState();
+ keychain.setMuseKeychainTestDeps(null);
+ setCredentialPromptRole(role);
+ setConfigFileOverride(config);
+ }
+ };
+ const result = await runHomeScenario(scenario, transportAvailable);
+ expect(result.model).toBe("muse-spark-1.3");
+ expect(result.reads).toBe(0);
+ if (transportAvailable) {
+ expect(result.statuses).toEqual([400, 400]);
+ expect(result.upstream).toBeGreaterThanOrEqual(2);
+ expect(result.mints).toBeGreaterThan(0);
+ } else expect(result.factoryCalls).toBeGreaterThan(0);
+ }, 25000);
+}
diff --git a/packages/cli/src/tui/providers.muse-code.test.ts b/packages/cli/src/tui/providers.muse-code.test.ts
new file mode 100644
index 00000000..85733383
--- /dev/null
+++ b/packages/cli/src/tui/providers.muse-code.test.ts
@@ -0,0 +1,546 @@
+import { afterEach, beforeEach, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+
+const children: ReturnType<typeof Bun.spawn>[] = [];
+
+afterEach(async () => {
+ for (const child of children.splice(0)) {
+ if (child.exitCode === null) child.kill();
+ await child.exited;
+ }
+});
+async function waitForChild(child: ReturnType<typeof Bun.spawn>) {
+ let timer: ReturnType<typeof setTimeout> | undefined;
+ try {
+ return await Promise.race([
+ child.exited,
+ new Promise<number>((resolve) => {
+ timer = setTimeout(() => {
+ child.kill();
+ resolve(124);
+ }, 4000);
+ }),
+ ]);
+ } finally {
+ clearTimeout(timer);
+ }
+}
+
+let home: string;
+let savedEnv: Record<string, string | undefined>;
+let savedFetch: typeof fetch;
+let savedExit: typeof process.exit;
+// Any unexpected CLI exit must fail the case instead of terminating Bun's runner.
+class UnexpectedProcessExit extends Error {
+ constructor(code?: string | number | null) {
+ super(`RUN5_PROCESS_EXIT:${code ?? 0}`);
+ this.name = "UnexpectedProcessExit";
+ }
+}
+beforeEach(() => {
+ savedEnv = { CLAUDISH_DISABLE_KEYCHAIN: process.env.CLAUDISH_DISABLE_KEYCHAIN };
+ home = mkdtempSync(join(tmpdir(), "muse-run5-"));
+ process.env.CLAUDISH_DISABLE_KEYCHAIN = "1";
+ savedExit = process.exit;
+ process.exit = (code?: string | number | null): never => {
+ throw new UnexpectedProcessExit(code);
+ };
+ savedFetch = globalThis.fetch;
+ globalThis.fetch = Object.assign(
+ async () => {
+ throw new Error("Unexpected network in Run 5 test");
+ },
+ { preconnect: () => {} }
+ ) as typeof fetch;
+});
+function restoreHarness() {
+ process.exit = savedExit;
+ globalThis.fetch = savedFetch;
+ for (const [key, value] of Object.entries(savedEnv)) {
+ if (value === undefined) delete process.env[key];
+ else process.env[key] = value;
+ }
+ rmSync(home, { recursive: true, force: true });
+}
+
+// HOME is not an isolation seam in Bun. Every filesystem-capable dependency
+// below is explicit and test-owned; omitted production defaults are forbidden.
+function fakeCoreDeps(
+ overrides: Partial<import("../providers/meta-muse/muse-credentials.js").MuseCoreDeps> = {}
+): import("../providers/meta-muse/muse-credentials.js").MuseCoreDeps {
+ return {
+ dir: () => home,
+ now: () => 1792088000000,
+ readStore: () => null,
+ writeBorrowedCopy: () => {
+ throw new Error("Unexpected borrowed-copy write");
+ },
+ mint: async () => {
+ throw new Error("Unexpected mint");
+ },
+ keychainLogin: async () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+function fakeMuseKeychainDeps(
+ overrides: Partial<import("../providers/meta-muse/muse-keychain.js").MuseKeychainDeps> = {}
+): import("../providers/meta-muse/muse-keychain.js").MuseKeychainDeps {
+ return {
+ dir: () => home,
+ env: () => ({}),
+ now: () => 1792088000000,
+ sleep: async () => {
+ throw new Error("Unexpected Keychain wait");
+ },
+ pid: () => 424242,
+ isAlive: () => false,
+ presence: async () => ({ kind: "absent" }),
+ startRead: () => {
+ throw new Error("Keychain forbidden");
+ },
+ ...overrides,
+ };
+}
+let previousConfigPath: string | null;
+const restoreRegistrations: (() => void)[] = [];
+beforeEach(async () => {
+ const keychain = await import("../providers/keychain.js");
+ const forbidden = () => {
+ throw new Error("Real Keychain process forbidden");
+ };
+ keychain.setKeychainTestDeps({
+ platform: () => "darwin",
+ run: forbidden,
+ runAsync: async () => forbidden(),
+ spawnAsync: forbidden,
+ });
+ const core = await import("../providers/meta-muse/muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(fakeCoreDeps());
+ const museKeychain = await import("../providers/meta-muse/muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(fakeMuseKeychainDeps());
+ (await import("../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ const config = await import("../config-override.js");
+ previousConfigPath = config.getConfigFileOverride();
+ config.setConfigFileOverride(join(home, "config.json"));
+});
+afterEach(async () => {
+ for (const restore of restoreRegistrations.splice(0).reverse()) restore();
+ const core = await import("../providers/meta-muse/muse-credentials.js");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(null);
+ const museKeychain = await import("../providers/meta-muse/muse-keychain.js");
+ museKeychain.resetMuseKeychainState();
+ museKeychain.setMuseKeychainTestDeps(null);
+ const keychain = await import("../providers/keychain.js");
+ keychain.invalidateKeychainCache();
+ keychain.setKeychainTestDeps(null);
+ (await import("../auth/credentials/prompt-role.js"))._resetCredentialPromptRoleForTest();
+ (await import("../auth/credentials/billing-probe.js")).clearSignedArm();
+ (await import("../providers/model-discovery.js")).invalidateModelDiscovery("meta-muse-code");
+ (await import("../providers/all-models-cache.js"))._clearAllModelsCacheMemo();
+ (await import("../providers/catalog-client.js"))._resetCatalogClient();
+ (await import("../config-override.js")).setConfigFileOverride(previousConfigPath);
+ restoreHarness();
+});
+
+// HOME must be present at process start: keep default-path consumers in Bun children.
+// The callback and fake builders are serialized after Bun has stripped TypeScript.
+async function runHomeScenario(scenario: () => Promise<Record<string, unknown>>) {
+ const absoluteImports = (source: string) =>
+ source.replace(
+ /import\((["'])(\.[^"']+)\1\)/g,
+ (_match, _quote, path) => `import(${JSON.stringify(resolve(import.meta.dir, path))})`
+ );
+ const scriptPath = join(home, "scenario.ts");
+ const setup = `
+ import { expect } from "bun:test";
+ import fs from "node:fs";
+ import fsp from "node:fs/promises";
+ import { syncBuiltinESMExports } from "node:module";
+ import { join, resolve, relative, isAbsolute } from "node:path";
+ import { fileURLToPath } from "node:url";
+ import { homedir } from "node:os";
+ const realExit = process.exit.bind(process);
+ try {
+ const home = process.env.HOME;
+ expect(homedir()).toBe(home);
+ process.exit = code => { throw new Error("RUN5_CHILD_EXIT:" + (code ?? 0)); };
+ const savedFetch = globalThis.fetch;
+ const networkUrls = [];
+ globalThis.fetch = Object.assign(async (input, init) => {
+ const url = new URL(input instanceof Request ? input.url : String(input));
+ if (url.protocol !== "http:" && url.protocol !== "https:") return savedFetch(input, init);
+ networkUrls.push(url.href);
+ throw new Error("Unexpected child network: " + url.href);
+ }, { preconnect() {} });
+ // Audit and reject filesystem mutations outside the child's owned HOME.
+ // Apply before implementation imports, including their singleton setup.
+ const outsideWrites = [];
+ const writes = [];
+ function checkWrite(path) {
+ if (typeof path === "number") return; // fd was checked when opened
+ const target = resolve(path instanceof URL ? fileURLToPath(path) : String(path));
+ const rel = relative(home, target);
+ if (rel === ".." || rel.startsWith("../") || isAbsolute(rel)) {
+ outsideWrites.push(target);
+ throw new Error("Outside-HOME mutation forbidden: " + target);
+ }
+ writes.push(rel);
+ }
+ for (const api of [fs, fsp]) {
+ for (const name of ["writeFile", "writeFileSync", "appendFile", "appendFileSync", "mkdir", "mkdirSync",
+ "rm", "rmSync", "rmdir", "rmdirSync", "unlink", "unlinkSync", "chmod", "chmodSync",
+ "truncate", "truncateSync", "utimes", "utimesSync", "createWriteStream", "mkdtemp", "mkdtempSync"]) {
+ const original = api[name];
+ if (original) api[name] = function(path, ...args) { checkWrite(path); return original.call(this, path, ...args); };
+ }
+ for (const name of ["rename", "renameSync", "copyFile", "copyFileSync", "cp", "cpSync", "link", "linkSync", "symlink", "symlinkSync"]) {
+ const original = api[name];
+ if (original) api[name] = function(from, to, ...args) {
+ if (name.startsWith("rename")) checkWrite(from);
+ checkWrite(to); return original.call(this, from, to, ...args);
+ };
+ }
+ for (const name of ["open", "openSync"]) {
+ const original = api[name];
+ if (original) api[name] = function(path, flags, ...args) {
+ if (typeof flags === "number" ? (flags & 3) !== 0 || (flags & (fs.constants.O_CREAT | fs.constants.O_TRUNC)) !== 0 : /[wa+]/.test(flags)) checkWrite(path);
+ return original.call(this, path, flags, ...args);
+ };
+ }
+ }
+ const bunWrite = Bun.write;
+ Bun.write = (path, ...args) => { checkWrite(path); return bunWrite(path, ...args); };
+ syncBuiltinESMExports();
+ `;
+ const initialization = `
+ let keychainOperations = 0;
+ const forbidden = () => { keychainOperations++; throw new Error("Real Keychain process forbidden"); };
+ const generic = await import(${JSON.stringify(resolve(import.meta.dir, "../providers/keychain.js"))});
+ generic.setKeychainTestDeps({ platform: () => "darwin", run: forbidden, runAsync: async () => forbidden(), spawnAsync: forbidden });
+ const coreSetup = await import(${JSON.stringify(resolve(import.meta.dir, "../providers/meta-muse/muse-credentials.js"))});
+ coreSetup.resetMuseCredentialState(); coreSetup.setMuseCoreTestDeps(fakeCoreDeps());
+ const keychainSetup = await import(${JSON.stringify(resolve(import.meta.dir, "../providers/meta-muse/muse-keychain.js"))});
+ keychainSetup.resetMuseKeychainState(); keychainSetup.setMuseKeychainTestDeps(fakeMuseKeychainDeps());
+ (await import(${JSON.stringify(resolve(import.meta.dir, "../auth/credentials/prompt-role.js"))}))._resetCredentialPromptRoleForTest();
+ (await import(${JSON.stringify(resolve(import.meta.dir, "../config-override.js"))})).setConfigFileOverride(join(home, "config.json"));
+ `;
+ writeFileSync(
+ scriptPath,
+ setup +
+ absoluteImports(fakeCoreDeps.toString()) +
+ "\n" +
+ absoluteImports(fakeMuseKeychainDeps.toString()) +
+ initialization +
+ `\nconst result = await (${absoluteImports(scenario.toString())})();\n` +
+ "expect(outsideWrites).toEqual([]);\nexpect(keychainOperations).toBe(0);\nexpect(networkUrls).toEqual([]);\nconsole.log(JSON.stringify({ ...result, outsideWrites, writes, keychainOperations, networkUrls }));\nrealExit(0);\n} catch (error) { console.error(error); realExit(1); }\n"
+ );
+ const child = Bun.spawn([process.execPath, scriptPath], {
+ cwd: home,
+ env: {
+ ...process.env,
+ HOME: home,
+ TMPDIR: home,
+ CLAUDISH_DISABLE_KEYCHAIN: "1",
+ CLAUDISH_DISABLE_CATALOG_WARM: "1",
+ },
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ children.push(child);
+ const [stdout, stderr, exitCode] = await Promise.all([
+ new Response(child.stdout).text(),
+ new Response(child.stderr).text(),
+ waitForChild(child),
+ ]);
+ expect(exitCode, stderr).toBe(0);
+ const lines = stdout.trim().split("\n");
+ expect(lines, stderr).toHaveLength(1);
+ const result = JSON.parse(lines[0]);
+ expect(result.outsideWrites).toEqual([]);
+ expect(result.keychainOperations).toBe(0);
+ expect(result.networkUrls).toEqual([]);
+ return result;
+}
+
+test("U1: both providers appear before first login", async () => {
+ const { getProviderDefs } = await import("./providers.js");
+ const defs = getProviderDefs();
+ expect(defs.some((p) => p.catalogName === "meta-muse-code" && p.apiKeyEnvVar === "")).toBe(true);
+ expect(defs.some((p) => p.catalogName === "meta" && p.apiKeyEnvVar === "META_API_KEY")).toBe(
+ true
+ );
+});
+
+test("U1: only own login, borrowed copy and present Keychain count as configured", async () => {
+ const { isMuseCredentialConfigured } = await import("../providers/meta-muse/muse-credentials.js");
+ for (const status of ["own-login", "borrowed-copy", "keychain"] as const)
+ expect(isMuseCredentialConfigured(status)).toBe(true);
+ for (const status of ["absent", "failed", "unknown"] as const)
+ expect(isMuseCredentialConfigured(status)).toBe(false);
+});
+
+test("U1: synchronous file-status projection performs zero Keychain operations", async () => {
+ const { museCredentialStatus, setMuseCoreTestDeps, resetMuseCredentialState } = await import(
+ "../providers/meta-muse/muse-credentials.js"
+ );
+ const { setMuseKeychainTestDeps, resetMuseKeychainState } = await import(
+ "../providers/meta-muse/muse-keychain.js"
+ );
+ let starts = 0;
+ let presenceChecks = 0;
+ resetMuseKeychainState();
+ setMuseKeychainTestDeps({
+ ...fakeMuseKeychainDeps(),
+ dir: () => home,
+ presence: async () => {
+ presenceChecks++;
+ throw new Error("unexpected presence process");
+ },
+ startRead: () => {
+ starts++;
+ throw new Error("unexpected Keychain read");
+ },
+ });
+ setMuseCoreTestDeps({ ...fakeCoreDeps(), dir: () => home, readStore: () => null });
+ try {
+ expect(museCredentialStatus(home)).toBe("unknown");
+ setMuseCoreTestDeps({
+ ...fakeCoreDeps(),
+ dir: () => home,
+ readStore: (kind) => (kind === "own-login" ? { access_token: "dca:TESTTOKEN0001" } : null),
+ });
+ expect(museCredentialStatus(home)).toBe("own-login");
+ setMuseCoreTestDeps({
+ ...fakeCoreDeps(),
+ dir: () => home,
+ readStore: (kind) =>
+ kind === "borrowed-copy" ? { access_token: "dca:TESTTOKEN0001" } : null,
+ });
+ expect(museCredentialStatus(home)).toBe("borrowed-copy");
+ expect(starts).toBe(0);
+ expect(presenceChecks).toBe(0);
+ } finally {
+ resetMuseCredentialState();
+ setMuseCoreTestDeps(null);
+ resetMuseKeychainState();
+ setMuseKeychainTestDeps(null);
+ }
+});
+
+test("U1: render notes name source; credential state retains minted tier without Keychain", async () => {
+ const ui = await import("./providers.js");
+ const core = await import("../providers/meta-muse/muse-credentials.js");
+ const keychain = await import("../providers/meta-muse/muse-keychain.js");
+ const { setCredentialPromptRole } = await import("../auth/credentials/prompt-role.js");
+ const role = setCredentialPromptRole("never");
+ const p = ui.getProviderDefs().find((p) => p.catalogName === "meta-muse-code");
+ if (!p) throw new Error("Muse provider missing");
+ let operations = 0;
+ keychain.resetMuseKeychainState();
+ core.resetMuseCredentialState();
+ keychain.setMuseKeychainTestDeps({
+ ...fakeMuseKeychainDeps(),
+ dir: () => home,
+ env: () => ({}),
+ presence: async () => {
+ operations++;
+ return { kind: "absent" };
+ },
+ startRead: () => {
+ operations++;
+ throw new Error("Keychain forbidden");
+ },
+ });
+ core.setMuseCoreTestDeps({ ...fakeCoreDeps(), dir: () => home, readStore: () => null });
+ try {
+ // B18: capability support is independent of the default-path OAuth login.
+ // Default-path set/readiness/source assertions run in an isolated child below.
+ expect(p.oauthSlug).toBe("muse");
+ expect(operations).toBe(0);
+ const absentNote = ui.providerCredentialNote(p);
+ const notes: string[] = [];
+ for (const kind of ["own-login", "borrowed-copy"] as const) {
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps({
+ ...fakeCoreDeps(),
+ dir: () => home,
+ readStore: (k) =>
+ k === kind
+ ? { access_token: "dca:TESTTOKEN0001", subs_tier_name: "Muse Code Power Usage" }
+ : null,
+ mint: async () => ({ apiKey: "LLM|TESTKEY0001", subsTierName: "Muse Code Power Usage" }),
+ });
+ await core.ensureMuseCredentialReady({ prompt: false });
+ expect(core.currentMuseState()?.source).toBe(
+ kind === "own-login" ? "claudish-login" : "borrowed-copy"
+ );
+ const note = ui.providerCredentialNote(p);
+ expect(note).toBeDefined();
+ expect(note?.trim().length).toBeGreaterThan(0);
+ expect(note).not.toBe(absentNote);
+ if (typeof note !== "string") throw new Error("credential note missing");
+ notes.push(note);
+ expect(core.currentMuseState()?.subsTierName).toBe("Muse Code Power Usage");
+ expect(operations).toBe(0);
+ }
+ expect(notes[0]).not.toBe(notes[1]);
+ } finally {
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(null);
+ keychain.resetMuseKeychainState();
+ keychain.setMuseKeychainTestDeps(null);
+ setCredentialPromptRole(role);
+ }
+});
+
+test("U1: async Keychain presence projects present, absent and failed distinctly", async () => {
+ const core = await import("../providers/meta-muse/muse-credentials.js");
+ const keychain = await import("../providers/meta-muse/muse-keychain.js");
+ let starts = 0;
+ try {
+ for (const [result, expected] of [
+ [{ kind: "found" }, "keychain"],
+ [{ kind: "absent" }, "absent"],
+ [{ kind: "failed", code: 1, error: "test presence failure" }, "failed"],
+ ] as const) {
+ core.resetMuseCredentialState();
+ keychain.resetMuseKeychainState();
+ core.setMuseCoreTestDeps({ ...fakeCoreDeps(), dir: () => home, readStore: () => null });
+ keychain.setMuseKeychainTestDeps({
+ ...fakeMuseKeychainDeps(),
+ dir: () => home,
+ env: () => ({}),
+ presence: async () => result,
+ startRead: () => {
+ starts++;
+ throw new Error("value read forbidden");
+ },
+ });
+ expect(await core.refreshMuseCredentialStatus()).toBe(expected);
+ expect(core.museCredentialStatus(home)).toBe(expected);
+ expect(core.isMuseCredentialConfigured(expected)).toBe(expected === "keychain");
+ }
+ expect(starts).toBe(0);
+ } finally {
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(null);
+ keychain.resetMuseKeychainState();
+ keychain.setMuseKeychainTestDeps(null);
+ }
+});
+
+test("U1: malformed or empty-token files never configure Muse; valid own login is identified", async () => {
+ const { writeFileSync } = await import("node:fs");
+ const { museStorePath } = await import("../providers/meta-muse/muse-store.js");
+ const {
+ museCredentialStatusFromFiles,
+ isMuseCredentialConfigured,
+ setMuseCoreTestDeps,
+ resetMuseCredentialState,
+ } = await import("../providers/meta-muse/muse-credentials.js");
+ const { readMuseStore } = await import("../providers/meta-muse/muse-store.js");
+ setMuseCoreTestDeps({
+ ...fakeCoreDeps(),
+ dir: () => home,
+ readStore: (kind) => readMuseStore(kind, home),
+ });
+ try {
+ for (const content of [
+ "{broken",
+ JSON.stringify({ access_token: "" }),
+ JSON.stringify({ api_key: "LLM|TESTKEY0001" }),
+ ]) {
+ writeFileSync(museStorePath("own-login", home), content, { mode: 0o600 });
+ expect(isMuseCredentialConfigured(museCredentialStatusFromFiles(home))).toBe(false);
+ }
+ writeFileSync(
+ museStorePath("own-login", home),
+ JSON.stringify({ access_token: "dca:TESTTOKEN0001" }),
+ { mode: 0o600 }
+ );
+ expect(museCredentialStatusFromFiles(home)).toBe("own-login");
+ } finally {
+ resetMuseCredentialState();
+ setMuseCoreTestDeps(null);
+ }
+});
+
+test("U1: OAuth set, readiness and source before/after login in an isolated child", async () => {
+ const result = await runHomeScenario(async () => {
+ const ui = await import("./providers.js");
+ const core = await import("../providers/meta-muse/muse-credentials.js");
+ const store = await import("../providers/meta-muse/muse-store.js");
+ const { existsSync } = await import("node:fs");
+ const p = ui.getProviderDefs().find((p) => p.catalogName === "meta-muse-code")!;
+ core.setMuseCoreTestDeps({
+ ...fakeCoreDeps(),
+ dir: store.defaultMuseStoreDir,
+ readStore: (kind) => store.readMuseStore(kind),
+ mint: async () => ({ apiKey: "LLM|TESTKEY0001" }),
+ });
+ const project = () => ({
+ oauth: ui.providerAuthCapabilities(p, {}).oauth,
+ ready: ui.providerIsReady(p, {}),
+ source: ui.providerAuthSource(p, {}),
+ });
+ const absent = project();
+ expect(absent).toMatchObject({
+ oauth: { supported: true, set: false },
+ ready: false,
+ source: null,
+ });
+ const present = [];
+ for (const kind of ["own-login", "borrowed-copy"] as const) {
+ store.deleteMuseStores();
+ core.resetMuseCredentialState();
+ if (kind === "own-login") store.writeMuseStore(kind, { access_token: "dca:TESTTOKEN0001" });
+ else store.writeBorrowedCopy("dca:TESTTOKEN0001", "Muse Code Power Usage");
+ await core.ensureMuseCredentialReady({ prompt: false });
+ const projection = project();
+ expect(projection).toMatchObject({
+ oauth: { supported: true, set: true },
+ ready: true,
+ source: "oauth",
+ });
+ present.push({ kind, ...projection, fileExists: existsSync(store.museStorePath(kind)) });
+ }
+ return { absent, present };
+ });
+ expect(result.absent).toMatchObject({
+ oauth: { supported: true, set: false },
+ ready: false,
+ source: null,
+ });
+ expect(result.present).toHaveLength(2);
+ for (const projection of result.present) {
+ expect(projection).toMatchObject({
+ oauth: { supported: true, set: true },
+ ready: true,
+ source: "oauth",
+ fileExists: true,
+ });
+ }
+}, 15000);
+
+test("U1: describeSourceSync follows the Muse core own-login seam", async () => {
+ const { describeSourceSync } = await import("../auth/credentials/source.js");
+ const core = await import("../providers/meta-muse/muse-credentials.js");
+ const provider = { catalogName: "meta-muse-code", apiKeyEnvVar: "", oauthSlug: "muse" };
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(
+ fakeCoreDeps({
+ readStore: (kind) => (kind === "own-login" ? { access_token: "dca:TESTTOKEN0001" } : null),
+ })
+ );
+ expect(describeSourceSync(provider, {})).toBe("oauth");
+ core.resetMuseCredentialState();
+ core.setMuseCoreTestDeps(fakeCoreDeps({ readStore: () => null }));
+ expect(describeSourceSync(provider, {})).toBeNull();
+});