Skip to content

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

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

let home: string;
let 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);
  });
});