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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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([+ "[email protected]",+ ]);+ 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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;+ },+ },+ "[email protected]",+ "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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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();+});