@vacbo/opencode-anthropic-fix 0.1.7 → 0.1.9

package/src/__tests__/cch-drift-checker.test.ts

@@ -1,61 +1,61 @@
 import { describe, expect, it } from "vitest";
 
 import {
-  EXPECTED_CCH_PLACEHOLDER,
-  EXPECTED_CCH_SALT,
-  EXPECTED_CCH_SEED,
-  EXPECTED_XXHASH64_PRIMES,
-  bigintToLittleEndianBytes,
-  findAllOccurrences,
-  scanCchConstants,
+    EXPECTED_CCH_PLACEHOLDER,
+    EXPECTED_CCH_SALT,
+    EXPECTED_CCH_SEED,
+    EXPECTED_XXHASH64_PRIMES,
+    bigintToLittleEndianBytes,
+    findAllOccurrences,
+    scanCchConstants,
 } from "../drift/cch-constants.js";
 
 describe("cch drift checker helpers", () => {
-  it("encodes bigint constants as little-endian bytes", () => {
-    expect(Array.from(bigintToLittleEndianBytes(EXPECTED_CCH_SEED))).toEqual([
-      0x1e, 0x83, 0x06, 0xc8, 0x6a, 0x73, 0x52, 0x6e,
-    ]);
-  });
-
-  it("finds all occurrences of a byte pattern", () => {
-    const haystack = new Uint8Array([1, 2, 3, 1, 2, 3, 4]);
-    const needle = new Uint8Array([1, 2, 3]);
-    expect(findAllOccurrences(haystack, needle)).toEqual([0, 3]);
-  });
+    it("encodes bigint constants as little-endian bytes", () => {
+        expect(Array.from(bigintToLittleEndianBytes(EXPECTED_CCH_SEED))).toEqual([
+            0x1e, 0x83, 0x06, 0xc8, 0x6a, 0x73, 0x52, 0x6e,
+        ]);
+    });
+
+    it("finds all occurrences of a byte pattern", () => {
+        const haystack = new Uint8Array([1, 2, 3, 1, 2, 3, 4]);
+        const needle = new Uint8Array([1, 2, 3]);
+        expect(findAllOccurrences(haystack, needle)).toEqual([0, 3]);
+    });
 });
 
 describe("scanCchConstants", () => {
-  it("passes when all standalone constants are present", () => {
-    const bytes = new Uint8Array([
-      ...new TextEncoder().encode(`xx cch=${EXPECTED_CCH_PLACEHOLDER} yy ${EXPECTED_CCH_SALT} zz`),
-      ...bigintToLittleEndianBytes(EXPECTED_CCH_SEED),
-      ...EXPECTED_XXHASH64_PRIMES.flatMap((prime) => Array.from(bigintToLittleEndianBytes(prime))),
-    ]);
-
-    const report = scanCchConstants(bytes, "synthetic-standalone", "standalone");
-    expect(report.passed).toBe(true);
-    expect(report.findings).toEqual([]);
-    expect(report.checked.placeholder).toBeGreaterThan(0);
-    expect(report.checked.salt).toBeGreaterThan(0);
-    expect(report.checked.seed).toBeGreaterThan(0);
-    expect(report.checked.primes.every((count) => count > 0)).toBe(true);
-  });
-
-  it("fails critically when placeholder and seed are missing", () => {
-    const bytes = new TextEncoder().encode(`missing ${EXPECTED_CCH_SALT}`);
-    const report = scanCchConstants(bytes, "broken-standalone", "standalone");
-
-    expect(report.passed).toBe(false);
-    expect(report.findings.map((finding) => finding.name)).toContain("cch placeholder");
-    expect(report.findings.map((finding) => finding.name)).toContain("native cch seed");
-  });
-
-  it("only requires placeholder and salt for npm cli bundles", () => {
-    const bytes = new TextEncoder().encode(`prefix cch=${EXPECTED_CCH_PLACEHOLDER}; ${EXPECTED_CCH_SALT} suffix`);
-    const report = scanCchConstants(bytes, "synthetic-bundle", "bundle");
-
-    expect(report.passed).toBe(true);
-    expect(report.checked.seed).toBe(0);
-    expect(report.findings).toEqual([]);
-  });
+    it("passes when all standalone constants are present", () => {
+        const bytes = new Uint8Array([
+            ...new TextEncoder().encode(`xx cch=${EXPECTED_CCH_PLACEHOLDER} yy ${EXPECTED_CCH_SALT} zz`),
+            ...bigintToLittleEndianBytes(EXPECTED_CCH_SEED),
+            ...EXPECTED_XXHASH64_PRIMES.flatMap((prime) => Array.from(bigintToLittleEndianBytes(prime))),
+        ]);
+
+        const report = scanCchConstants(bytes, "synthetic-standalone", "standalone");
+        expect(report.passed).toBe(true);
+        expect(report.findings).toEqual([]);
+        expect(report.checked.placeholder).toBeGreaterThan(0);
+        expect(report.checked.salt).toBeGreaterThan(0);
+        expect(report.checked.seed).toBeGreaterThan(0);
+        expect(report.checked.primes.every((count) => count > 0)).toBe(true);
+    });
+
+    it("fails critically when placeholder and seed are missing", () => {
+        const bytes = new TextEncoder().encode(`missing ${EXPECTED_CCH_SALT}`);
+        const report = scanCchConstants(bytes, "broken-standalone", "standalone");
+
+        expect(report.passed).toBe(false);
+        expect(report.findings.map((finding) => finding.name)).toContain("cch placeholder");
+        expect(report.findings.map((finding) => finding.name)).toContain("native cch seed");
+    });
+
+    it("only requires placeholder and salt for npm cli bundles", () => {
+        const bytes = new TextEncoder().encode(`prefix cch=${EXPECTED_CCH_PLACEHOLDER}; ${EXPECTED_CCH_SALT} suffix`);
+        const report = scanCchConstants(bytes, "synthetic-bundle", "bundle");
+
+        expect(report.passed).toBe(true);
+        expect(report.checked.seed).toBe(0);
+        expect(report.findings).toEqual([]);
+    });
 });

package/src/__tests__/cch-native-style.test.ts

@@ -5,72 +5,72 @@ import { CCH_PLACEHOLDER, computeNativeStyleCch, replaceNativeStyleCch, xxHash64
 import { transformRequestBody } from "../request/body.js";
 
 describe("native-style cch", () => {
-  it("matches independently verified xxHash64 reference values", () => {
-    expect(xxHash64(new TextEncoder().encode(""))).toBe(0x6e798575d82647edn);
-    expect(xxHash64(new TextEncoder().encode("a"))).toBe(0x8404a7f0a8a6bcaen);
-    expect(xxHash64(new TextEncoder().encode("hello"))).toBe(0x95ab2f66e009922an);
-  });
+    it("matches independently verified xxHash64 reference values", () => {
+        expect(xxHash64(new TextEncoder().encode(""))).toBe(0x6e798575d82647edn);
+        expect(xxHash64(new TextEncoder().encode("a"))).toBe(0x8404a7f0a8a6bcaen);
+        expect(xxHash64(new TextEncoder().encode("hello"))).toBe(0x95ab2f66e009922an);
+    });
 
-  it("derives the expected 5-char cch from independently verified vectors", () => {
-    expect(computeNativeStyleCch("")).toBe("647ed");
-    expect(computeNativeStyleCch("cch=00000")).toBe("1d7f8");
-    expect(
-      computeNativeStyleCch("x-anthropic-billing-header: cc_version=2.1.101.0e7; cc_entrypoint=cli; cch=00000;"),
-    ).toBe("101fb");
-  });
+    it("derives the expected 5-char cch from independently verified vectors", () => {
+        expect(computeNativeStyleCch("")).toBe("647ed");
+        expect(computeNativeStyleCch("cch=00000")).toBe("1d7f8");
+        expect(
+            computeNativeStyleCch("x-anthropic-billing-header: cc_version=2.1.101.0e7; cc_entrypoint=cli; cch=00000;"),
+        ).toBe("101fb");
+    });
 
-  it("replaces the placeholder in a serialized body", () => {
-    const serialized =
-      '{"system":[{"type":"text","text":"x-anthropic-billing-header: cc_version=2.1.101.0e7; cc_entrypoint=cli; cch=00000;"}],"messages":[{"role":"user","content":"Reply with the single word: OK"}]}';
+    it("replaces the placeholder in a serialized body", () => {
+        const serialized =
+            '{"system":[{"type":"text","text":"x-anthropic-billing-header: cc_version=2.1.101.0e7; cc_entrypoint=cli; cch=00000;"}],"messages":[{"role":"user","content":"Reply with the single word: OK"}]}';
 
-    expect(replaceNativeStyleCch(serialized)).toContain("cch=0ca30");
-    expect(replaceNativeStyleCch(serialized)).not.toContain(`cch=${CCH_PLACEHOLDER}`);
-  });
+        expect(replaceNativeStyleCch(serialized)).toContain("cch=0ca30");
+        expect(replaceNativeStyleCch(serialized)).not.toContain(`cch=${CCH_PLACEHOLDER}`);
+    });
 
-  it("leaves strings without the placeholder unchanged", () => {
-    const serialized = '{"system":[{"type":"text","text":"no billing block here"}]}';
-    expect(replaceNativeStyleCch(serialized)).toBe(serialized);
-  });
+    it("leaves strings without the placeholder unchanged", () => {
+        const serialized = '{"system":[{"type":"text","text":"no billing block here"}]}';
+        expect(replaceNativeStyleCch(serialized)).toBe(serialized);
+    });
 });
 
 describe("billing header placeholder + transformRequestBody replacement", () => {
-  const signature = {
-    enabled: true,
-    claudeCliVersion: "2.1.101",
-    promptCompactionMode: "minimal" as const,
-    sanitizeSystemPrompt: false,
-  };
-  const runtime = {
-    persistentUserId: "0".repeat(64),
-    accountId: "acct-1",
-    sessionId: "session-1",
-  };
+    const signature = {
+        enabled: true,
+        claudeCliVersion: "2.1.101",
+        promptCompactionMode: "minimal" as const,
+        sanitizeSystemPrompt: false,
+    };
+    const runtime = {
+        persistentUserId: "0".repeat(64),
+        accountId: "acct-1",
+        sessionId: "session-1",
+    };
 
-  it("buildAnthropicBillingHeader emits the native placeholder", () => {
-    process.env.CLAUDE_CODE_ATTRIBUTION_HEADER = "true";
-    const header = buildAnthropicBillingHeader("2.1.101", [{ role: "user", content: "Hello world from a test" }]);
-    expect(header).toContain(`cch=${CCH_PLACEHOLDER};`);
-  });
-
-  it("transformRequestBody replaces the placeholder after serialization", () => {
-    const body = JSON.stringify({
-      model: "claude-sonnet-4-5",
-      max_tokens: 1024,
-      stream: false,
-      messages: [{ role: "user", content: "Reply with the single word: OK" }],
-      system: "You are a helpful assistant.",
+    it("buildAnthropicBillingHeader emits the native placeholder", () => {
+        process.env.CLAUDE_CODE_ATTRIBUTION_HEADER = "true";
+        const header = buildAnthropicBillingHeader("2.1.101", [{ role: "user", content: "Hello world from a test" }]);
+        expect(header).toContain(`cch=${CCH_PLACEHOLDER};`);
     });
 
-    const transformed = transformRequestBody(body, signature, runtime);
-    expect(transformed).toBeDefined();
-    expect(transformed).not.toContain(`cch=${CCH_PLACEHOLDER}`);
+    it("transformRequestBody replaces the placeholder after serialization", () => {
+        const body = JSON.stringify({
+            model: "claude-sonnet-4-5",
+            max_tokens: 1024,
+            stream: false,
+            messages: [{ role: "user", content: "Reply with the single word: OK" }],
+            system: "You are a helpful assistant.",
+        });
+
+        const transformed = transformRequestBody(body, signature, runtime);
+        expect(transformed).toBeDefined();
+        expect(transformed).not.toContain(`cch=${CCH_PLACEHOLDER}`);
 
-    const actualCch = transformed?.match(/cch=([0-9a-f]{5})/)?.[1];
-    const placeholderBody = transformed?.replace(/cch=[0-9a-f]{5}/, `cch=${CCH_PLACEHOLDER}`);
+        const actualCch = transformed?.match(/cch=([0-9a-f]{5})/)?.[1];
+        const placeholderBody = transformed?.replace(/cch=[0-9a-f]{5}/, `cch=${CCH_PLACEHOLDER}`);
 
-    expect(actualCch).toBeDefined();
-    expect(placeholderBody).toBeDefined();
-    expect(actualCch).toBe(computeNativeStyleCch(placeholderBody!));
-    expect(transformed).toBe(replaceNativeStyleCch(placeholderBody!));
-  });
+        expect(actualCch).toBeDefined();
+        expect(placeholderBody).toBeDefined();
+        expect(actualCch).toBe(computeNativeStyleCch(placeholderBody!));
+        expect(transformed).toBe(replaceNativeStyleCch(placeholderBody!));
+    });
 });

package/src/__tests__/debug-gating.test.ts

@@ -17,60 +17,60 @@ const bunFetchSource = readFileSync(join(SRC_ROOT, "bun-fetch.ts"), "utf8");
 const bunProxySource = readFileSync(join(SRC_ROOT, "bun-proxy.ts"), "utf8");
 
 describe("debug gating in bun-fetch.ts (Task 2/4)", () => {
-  it("threads OPENCODE_ANTHROPIC_DEBUG env var", () => {
-    expect(bunFetchSource).toContain("OPENCODE_ANTHROPIC_DEBUG");
-  });
+    it("threads OPENCODE_ANTHROPIC_DEBUG env var", () => {
+        expect(bunFetchSource).toContain("OPENCODE_ANTHROPIC_DEBUG");
+    });
 
-  it("gates /tmp debug dump behind debug flag if any /tmp writes exist", () => {
-    const hasTmpWrite = /writeFileSync\s*\(\s*["']\/tmp\/opencode/.test(bunFetchSource);
-    if (hasTmpWrite) {
-      expect(bunFetchSource).toMatch(/if\s*\(\s*(debug|resolveDebug)[^)]*\)|(debug|resolveDebug)\s*&&/);
-    } else {
-      expect(hasTmpWrite).toBe(false);
-    }
-  });
+    it("gates /tmp debug dump behind debug flag if any /tmp writes exist", () => {
+        const hasTmpWrite = /writeFileSync\s*\(\s*["']\/tmp\/opencode/.test(bunFetchSource);
+        if (hasTmpWrite) {
+            expect(bunFetchSource).toMatch(/if\s*\(\s*(debug|resolveDebug)[^)]*\)|(debug|resolveDebug)\s*&&/);
+        } else {
+            expect(hasTmpWrite).toBe(false);
+        }
+    });
 
-  it("does not register an uncaughtException handler (Task 12)", () => {
-    expect(bunFetchSource).not.toContain("uncaughtException");
-  });
+    it("does not register an uncaughtException handler (Task 12)", () => {
+        expect(bunFetchSource).not.toContain("uncaughtException");
+    });
 
-  it("does not register an unhandledRejection handler (Task 12)", () => {
-    expect(bunFetchSource).not.toContain("unhandledRejection");
-  });
+    it("does not register an unhandledRejection handler (Task 12)", () => {
+        expect(bunFetchSource).not.toContain("unhandledRejection");
+    });
 });
 
 describe("debug gating in bun-proxy.ts (Task 3)", () => {
-  it("references OPENCODE_ANTHROPIC_DEBUG for request logging", () => {
-    expect(bunProxySource).toContain("OPENCODE_ANTHROPIC_DEBUG");
-  });
+    it("references OPENCODE_ANTHROPIC_DEBUG for request logging", () => {
+        expect(bunProxySource).toContain("OPENCODE_ANTHROPIC_DEBUG");
+    });
 
-  it("uses AbortSignal-based timeout handling on upstream fetch (Task 11)", () => {
-    expect(bunProxySource).toMatch(/AbortSignal\.(timeout|any)/);
-  });
+    it("uses AbortSignal-based timeout handling on upstream fetch (Task 11)", () => {
+        expect(bunProxySource).toMatch(/AbortSignal\.(timeout|any)/);
+    });
 
-  it("emits BUN_PROXY_PORT IPC ungated (parent must always detect port)", () => {
-    expect(bunProxySource).toContain("BUN_PROXY_PORT");
-  });
+    it("emits BUN_PROXY_PORT IPC ungated (parent must always detect port)", () => {
+        expect(bunProxySource).toContain("BUN_PROXY_PORT");
+    });
 });
 
 describe("silent error swallowing fixes (Task 5)", () => {
-  it("accounts.ts saveToDisk catch logs the error", () => {
-    const source = readFileSync(join(SRC_ROOT, "accounts.ts"), "utf8");
-    expect(source).not.toMatch(/saveToDisk\(\)\s*\.catch\(\s*\(\)\s*=>\s*\{\s*\}\s*\)/);
-  });
+    it("accounts.ts saveToDisk catch logs the error", () => {
+        const source = readFileSync(join(SRC_ROOT, "accounts.ts"), "utf8");
+        expect(source).not.toMatch(/saveToDisk\(\)\s*\.catch\(\s*\(\)\s*=>\s*\{\s*\}\s*\)/);
+    });
 
-  it("token-refresh.ts has no '.catch(() => undefined)' patterns", () => {
-    const source = readFileSync(join(SRC_ROOT, "token-refresh.ts"), "utf8");
-    expect(source).not.toMatch(/\.catch\(\s*\(\)\s*=>\s*undefined\s*\)/);
-  });
+    it("token-refresh.ts has no '.catch(() => undefined)' patterns", () => {
+        const source = readFileSync(join(SRC_ROOT, "token-refresh.ts"), "utf8");
+        expect(source).not.toMatch(/\.catch\(\s*\(\)\s*=>\s*undefined\s*\)/);
+    });
 
-  it("request/body.ts JSON parse catch binds the error parameter", () => {
-    const source = readFileSync(join(SRC_ROOT, "request", "body.ts"), "utf8");
-    expect(source).not.toMatch(/catch\s*\{\s*return\s+body\s*;?\s*\}/);
-  });
+    it("request/body.ts JSON parse catch binds the error parameter", () => {
+        const source = readFileSync(join(SRC_ROOT, "request", "body.ts"), "utf8");
+        expect(source).not.toMatch(/catch\s*\{\s*return\s+body\s*;?\s*\}/);
+    });
 
-  it("request/metadata.ts extractFileIds catch binds the error parameter", () => {
-    const source = readFileSync(join(SRC_ROOT, "request", "metadata.ts"), "utf8");
-    expect(source).not.toMatch(/catch\s*\{\s*return\s+\[\]\s*;?\s*\}/);
-  });
+    it("request/metadata.ts extractFileIds catch binds the error parameter", () => {
+        const source = readFileSync(join(SRC_ROOT, "request", "metadata.ts"), "utf8");
+        expect(source).not.toMatch(/catch\s*\{\s*return\s+\[\]\s*;?\s*\}/);
+    });
 });

package/src/__tests__/decomposition-smoke.test.ts

@@ -12,81 +12,81 @@ import { createRefreshHelpers } from "../refresh-helpers.js";
 import { createPluginHelpers } from "../plugin-helpers.js";
 
 describe("refresh-helpers module", () => {
-  it("exports createRefreshHelpers as a function", () => {
-    expect(typeof createRefreshHelpers).toBe("function");
-  });
-
-  it("factory returns an object when called with valid deps", () => {
-    const stubClient = {
-      tui: { showToast: vi.fn() },
-      command: { prompt: vi.fn() },
-      session: { prompt: vi.fn() },
-    };
-    const helpers = createRefreshHelpers({
-      client: stubClient as any,
-      config: { ...DEFAULT_CONFIG } as any,
-      getAccountManager: () => null,
-      debugLog: vi.fn(),
+    it("exports createRefreshHelpers as a function", () => {
+        expect(typeof createRefreshHelpers).toBe("function");
     });
 
-    expect(helpers).toBeDefined();
-    expect(typeof helpers).toBe("object");
-    expect(helpers).not.toBeNull();
-  });
+    it("factory returns an object when called with valid deps", () => {
+        const stubClient = {
+            tui: { showToast: vi.fn() },
+            command: { prompt: vi.fn() },
+            session: { prompt: vi.fn() },
+        };
+        const helpers = createRefreshHelpers({
+            client: stubClient as any,
+            config: { ...DEFAULT_CONFIG } as any,
+            getAccountManager: () => null,
+            debugLog: vi.fn(),
+        });
+
+        expect(helpers).toBeDefined();
+        expect(typeof helpers).toBe("object");
+        expect(helpers).not.toBeNull();
+    });
 
-  it("factory reads idle_refresh config fields at construction", () => {
-    const config = {
-      ...DEFAULT_CONFIG,
-      idle_refresh: { enabled: false, window_minutes: 10, min_interval_minutes: 5 },
-    };
-    expect(() =>
-      createRefreshHelpers({
-        client: {} as any,
-        config: config as any,
-        getAccountManager: () => null,
-        debugLog: vi.fn(),
-      }),
-    ).not.toThrow();
-  });
+    it("factory reads idle_refresh config fields at construction", () => {
+        const config = {
+            ...DEFAULT_CONFIG,
+            idle_refresh: { enabled: false, window_minutes: 10, min_interval_minutes: 5 },
+        };
+        expect(() =>
+            createRefreshHelpers({
+                client: {} as any,
+                config: config as any,
+                getAccountManager: () => null,
+                debugLog: vi.fn(),
+            }),
+        ).not.toThrow();
+    });
 });
 
 describe("plugin-helpers module", () => {
-  it("exports createPluginHelpers as a function", () => {
-    expect(typeof createPluginHelpers).toBe("function");
-  });
-
-  it("factory returns an object when called with valid deps", () => {
-    const stubClient = {
-      tui: { showToast: vi.fn() },
-      command: { prompt: vi.fn() },
-      session: { prompt: vi.fn() },
-    };
-    const helpers = createPluginHelpers({
-      client: stubClient as any,
-      config: { ...DEFAULT_CONFIG } as any,
-      debugLog: vi.fn(),
-      getAccountManager: () => null,
-      setAccountManager: vi.fn(),
+    it("exports createPluginHelpers as a function", () => {
+        expect(typeof createPluginHelpers).toBe("function");
     });
 
-    expect(helpers).toBeDefined();
-    expect(typeof helpers).toBe("object");
-    expect(helpers).not.toBeNull();
-  });
+    it("factory returns an object when called with valid deps", () => {
+        const stubClient = {
+            tui: { showToast: vi.fn() },
+            command: { prompt: vi.fn() },
+            session: { prompt: vi.fn() },
+        };
+        const helpers = createPluginHelpers({
+            client: stubClient as any,
+            config: { ...DEFAULT_CONFIG } as any,
+            debugLog: vi.fn(),
+            getAccountManager: () => null,
+            setAccountManager: vi.fn(),
+        });
+
+        expect(helpers).toBeDefined();
+        expect(typeof helpers).toBe("object");
+        expect(helpers).not.toBeNull();
+    });
 
-  it("factory accepts quiet toast config without throwing", () => {
-    const config = {
-      ...DEFAULT_CONFIG,
-      toasts: { quiet: true, debounce_seconds: 60 },
-    };
-    expect(() =>
-      createPluginHelpers({
-        client: {} as any,
-        config: config as any,
-        debugLog: vi.fn(),
-        getAccountManager: () => null,
-        setAccountManager: vi.fn(),
-      }),
-    ).not.toThrow();
-  });
+    it("factory accepts quiet toast config without throwing", () => {
+        const config = {
+            ...DEFAULT_CONFIG,
+            toasts: { quiet: true, debounce_seconds: 60 },
+        };
+        expect(() =>
+            createPluginHelpers({
+                client: {} as any,
+                config: config as any,
+                debugLog: vi.fn(),
+                getAccountManager: () => null,
+                setAccountManager: vi.fn(),
+            }),
+        ).not.toThrow();
+    });
 });