@vacbo/opencode-anthropic-fix 0.1.7 → 0.1.9

package/src/__tests__/helpers/in-memory-storage.ts

@@ -6,24 +6,24 @@ import type { AccountMetadata, AccountStorage } from "../../storage.js";
  * concurrent access scenarios without touching the real filesystem.
  */
 export interface InMemoryStorage {
-  /** Get the current in-memory snapshot (what the test subject sees) */
-  snapshot(): AccountStorage;
+    /** Get the current in-memory snapshot (what the test subject sees) */
+    snapshot(): AccountStorage;
 
-  /** Replace the in-memory snapshot (simulates loading from disk) */
-  setSnapshot(data: AccountStorage): void;
+    /** Replace the in-memory snapshot (simulates loading from disk) */
+    setSnapshot(data: AccountStorage): void;
 
-  /**
-   * Mutate the "disk" state without affecting the caller's snapshot.
-   * This simulates another process writing to the storage file while
-   * the test subject holds an in-memory copy.
-   */
-  mutateDiskOnly(mutator: (disk: AccountStorage) => AccountStorage): void;
+    /**
+     * Mutate the "disk" state without affecting the caller's snapshot.
+     * This simulates another process writing to the storage file while
+     * the test subject holds an in-memory copy.
+     */
+    mutateDiskOnly(mutator: (disk: AccountStorage) => AccountStorage): void;
 
-  /** Mock implementation of loadAccounts - returns disk state */
-  loadAccountsMock: () => Promise<AccountStorage | null>;
+    /** Mock implementation of loadAccounts - returns disk state */
+    loadAccountsMock: () => Promise<AccountStorage | null>;
 
-  /** Mock implementation of saveAccounts - writes to disk */
-  saveAccountsMock: (data: AccountStorage) => Promise<void>;
+    /** Mock implementation of saveAccounts - writes to disk */
+    saveAccountsMock: (data: AccountStorage) => Promise<void>;
 }
 
 /**
@@ -56,97 +56,97 @@ export interface InMemoryStorage {
  * ```
  */
 export function createInMemoryStorage(initial?: AccountStorage): InMemoryStorage {
-  // Internal "disk" state - what loadAccounts would read from filesystem
-  let diskState: AccountStorage | null = initial ?? null;
+    // Internal "disk" state - what loadAccounts would read from filesystem
+    let diskState: AccountStorage | null = initial ?? null;
 
-  // Internal "memory" state - what the test subject holds after loading
-  let memoryState: AccountStorage | null = diskState;
+    // Internal "memory" state - what the test subject holds after loading
+    let memoryState: AccountStorage | null = diskState;
 
-  return {
-    snapshot(): AccountStorage {
-      if (memoryState === null) {
-        throw new Error("Storage snapshot is null - did you forget to set initial data or call setSnapshot()?");
-      }
-      // Return deep copy to prevent accidental mutations via references
-      return structuredClone(memoryState);
-    },
+    return {
+        snapshot(): AccountStorage {
+            if (memoryState === null) {
+                throw new Error("Storage snapshot is null - did you forget to set initial data or call setSnapshot()?");
+            }
+            // Return deep copy to prevent accidental mutations via references
+            return structuredClone(memoryState);
+        },
 
-    setSnapshot(data: AccountStorage): void {
-      // Update both disk and memory to match
-      diskState = structuredClone(data);
-      memoryState = structuredClone(data);
-    },
+        setSnapshot(data: AccountStorage): void {
+            // Update both disk and memory to match
+            diskState = structuredClone(data);
+            memoryState = structuredClone(data);
+        },
 
-    mutateDiskOnly(mutator: (disk: AccountStorage) => AccountStorage): void {
-      if (diskState === null) {
-        throw new Error("Cannot mutate disk - disk state is null. Set initial data first.");
-      }
-      // Only mutate disk state, leaving memoryState unchanged
-      // This simulates another process writing to the file
-      diskState = mutator(structuredClone(diskState));
-    },
+        mutateDiskOnly(mutator: (disk: AccountStorage) => AccountStorage): void {
+            if (diskState === null) {
+                throw new Error("Cannot mutate disk - disk state is null. Set initial data first.");
+            }
+            // Only mutate disk state, leaving memoryState unchanged
+            // This simulates another process writing to the file
+            diskState = mutator(structuredClone(diskState));
+        },
 
-    loadAccountsMock: vi.fn(async (): Promise<AccountStorage | null> => {
-      // Simulate reading from disk - returns current disk state
-      return diskState === null ? null : structuredClone(diskState);
-    }),
+        loadAccountsMock: vi.fn(async (): Promise<AccountStorage | null> => {
+            // Simulate reading from disk - returns current disk state
+            return diskState === null ? null : structuredClone(diskState);
+        }),
 
-    saveAccountsMock: vi.fn(async (data: AccountStorage): Promise<void> => {
-      // Simulate writing to disk - updates disk state
-      diskState = structuredClone(data);
-    }),
-  };
+        saveAccountsMock: vi.fn(async (data: AccountStorage): Promise<void> => {
+            // Simulate writing to disk - updates disk state
+            diskState = structuredClone(data);
+        }),
+    };
 }
 
 /**
  * Helper to create a minimal valid stored account for testing.
  */
 export function makeStoredAccount(overrides: Partial<AccountMetadata> & { refreshToken: string }): AccountMetadata {
-  const now = Date.now();
-  return {
-    id: overrides.id ?? `acct-${Math.random().toString(36).slice(2, 8)}`,
-    email: overrides.email,
-    identity: overrides.identity,
-    label: overrides.label,
-    refreshToken: overrides.refreshToken,
-    access: overrides.access ?? "access-token",
-    expires: overrides.expires ?? now + 3600_000,
-    addedAt: overrides.addedAt ?? now,
-    lastUsed: overrides.lastUsed ?? 0,
-    enabled: overrides.enabled ?? true,
-    rateLimitResetTimes: overrides.rateLimitResetTimes ?? {},
-    consecutiveFailures: overrides.consecutiveFailures ?? 0,
-    lastFailureTime: overrides.lastFailureTime ?? null,
-    lastSwitchReason: overrides.lastSwitchReason,
-    token_updated_at: overrides.token_updated_at ?? 0,
-    stats: overrides.stats ?? {
-      requests: 0,
-      inputTokens: 0,
-      outputTokens: 0,
-      cacheReadTokens: 0,
-      cacheWriteTokens: 0,
-      lastReset: now,
-    },
-    source: overrides.source,
-  };
+    const now = Date.now();
+    return {
+        id: overrides.id ?? `acct-${Math.random().toString(36).slice(2, 8)}`,
+        email: overrides.email,
+        identity: overrides.identity,
+        label: overrides.label,
+        refreshToken: overrides.refreshToken,
+        access: overrides.access ?? "access-token",
+        expires: overrides.expires ?? now + 3600_000,
+        addedAt: overrides.addedAt ?? now,
+        lastUsed: overrides.lastUsed ?? 0,
+        enabled: overrides.enabled ?? true,
+        rateLimitResetTimes: overrides.rateLimitResetTimes ?? {},
+        consecutiveFailures: overrides.consecutiveFailures ?? 0,
+        lastFailureTime: overrides.lastFailureTime ?? null,
+        lastSwitchReason: overrides.lastSwitchReason,
+        token_updated_at: overrides.token_updated_at ?? 0,
+        stats: overrides.stats ?? {
+            requests: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadTokens: 0,
+            cacheWriteTokens: 0,
+            lastReset: now,
+        },
+        source: overrides.source,
+    };
 }
 
 /**
  * Helper to create a valid storage payload from account overrides.
  */
 export function makeAccountsData(
-  accountOverrides: Array<Partial<AccountMetadata> & { refreshToken: string }>,
-  extra: Partial<AccountStorage> = {},
+    accountOverrides: Array<Partial<AccountMetadata> & { refreshToken: string }>,
+    extra: Partial<AccountStorage> = {},
 ): AccountStorage {
-  return {
-    version: 1,
-    accounts: accountOverrides.map((o, i) =>
-      makeStoredAccount({
-        addedAt: (i + 1) * 1000,
-        ...o,
-      }),
-    ),
-    activeIndex: 0,
-    ...extra,
-  };
+    return {
+        version: 1,
+        accounts: accountOverrides.map((o, i) =>
+            makeStoredAccount({
+                addedAt: (i + 1) * 1000,
+                ...o,
+            }),
+        ),
+        activeIndex: 0,
+        ...extra,
+    };
 }

package/src/__tests__/helpers/mock-bun-proxy.smoke.test.ts

@@ -4,89 +4,89 @@ import { createDeferred } from "./deferred";
 import { createMockBunProxy } from "./mock-bun-proxy";
 
 describe("mock bun proxy helper", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-  });
-
-  it("mocks spawn and emits the startup banner", async () => {
-    const proxy = createMockBunProxy({ bannerDelay: 25 });
-    const child = proxy.mockSpawn("bun", ["run", "./bun-proxy.ts", "48372"], {
-      stdio: ["ignore", "pipe", "pipe"],
+    beforeEach(() => {
+        vi.useFakeTimers();
     });
-    const onData = vi.fn();
 
-    child.stdout?.on("data", onData);
+    afterEach(() => {
+        vi.useRealTimers();
+        vi.restoreAllMocks();
+    });
+
+    it("mocks spawn and emits the startup banner", async () => {
+        const proxy = createMockBunProxy({ bannerDelay: 25 });
+        const child = proxy.mockSpawn("bun", ["run", "./bun-proxy.ts", "48372"], {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const onData = vi.fn();
 
-    proxy.simulateStdoutBanner();
+        child.stdout?.on("data", onData);
 
-    expect(onData).not.toHaveBeenCalled();
+        proxy.simulateStdoutBanner();
 
-    await vi.advanceTimersByTimeAsync(25);
+        expect(onData).not.toHaveBeenCalled();
 
-    expect(proxy.child.pid).toBe(child.pid);
-    expect(onData).toHaveBeenCalledOnce();
-    expect(onData.mock.calls[0][0].toString()).toContain("BUN_PROXY_PORT=48372");
-  });
+        await vi.advanceTimersByTimeAsync(25);
 
-  it("fires exit handlers and records kill signals", () => {
-    const proxy = createMockBunProxy();
-    const child = proxy.mockSpawn("bun", ["run", "./bun-proxy.ts", "48372"], {
-      stdio: ["ignore", "pipe", "pipe"],
+        expect(proxy.child.pid).toBe(child.pid);
+        expect(onData).toHaveBeenCalledOnce();
+        expect(onData.mock.calls[0][0].toString()).toContain("BUN_PROXY_PORT=48372");
     });
-    const onExit = vi.fn();
 
-    child.on("exit", onExit);
+    it("fires exit handlers and records kill signals", () => {
+        const proxy = createMockBunProxy();
+        const child = proxy.mockSpawn("bun", ["run", "./bun-proxy.ts", "48372"], {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const onExit = vi.fn();
 
-    proxy.simulateExit(0);
-    child.kill("SIGKILL");
+        child.on("exit", onExit);
 
-    expect(onExit).toHaveBeenCalledWith(0, null);
-    expect(proxy.child.killSignals).toEqual(["SIGKILL"]);
-  });
+        proxy.simulateExit(0);
+        child.kill("SIGKILL");
 
-  it("rejects async spawn callers when configured to throw", async () => {
-    const proxy = createMockBunProxy({ spawnError: new Error("spawn failed") });
+        expect(onExit).toHaveBeenCalledWith(0, null);
+        expect(proxy.child.killSignals).toEqual(["SIGKILL"]);
+    });
 
-    await expect((async () => proxy.mockSpawn("bun", ["run", "./bun-proxy.ts", "48372"], {}))()).rejects.toThrow(
-      "spawn failed",
-    );
-  });
+    it("rejects async spawn callers when configured to throw", async () => {
+        const proxy = createMockBunProxy({ spawnError: new Error("spawn failed") });
 
-  it("tracks in-flight forwarded fetch requests without touching the network", async () => {
-    const response = createDeferred<Response>();
-    const forwardToMockFetch = vi.fn(() => response.promise);
-    const proxy = createMockBunProxy({ forwardToMockFetch });
-    const child = proxy.mockSpawn("bun", ["run", "./bun-proxy.ts", "48372"], {
-      stdio: ["ignore", "pipe", "pipe"],
+        await expect((async () => proxy.mockSpawn("bun", ["run", "./bun-proxy.ts", "48372"], {}))()).rejects.toThrow(
+            "spawn failed",
+        );
     });
 
-    const fetchPromise = child.forwardFetch("http://127.0.0.1:48372/", {
-      method: "POST",
-      headers: {
-        "x-proxy-url": "https://api.anthropic.com/v1/messages",
-        authorization: "Bearer test-token",
-        connection: "keep-alive",
-      },
-      body: JSON.stringify({ hello: "world" }),
+    it("tracks in-flight forwarded fetch requests without touching the network", async () => {
+        const response = createDeferred<Response>();
+        const forwardToMockFetch = vi.fn(() => response.promise);
+        const proxy = createMockBunProxy({ forwardToMockFetch });
+        const child = proxy.mockSpawn("bun", ["run", "./bun-proxy.ts", "48372"], {
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+
+        const fetchPromise = child.forwardFetch("http://127.0.0.1:48372/", {
+            method: "POST",
+            headers: {
+                "x-proxy-url": "https://api.anthropic.com/v1/messages",
+                authorization: "Bearer test-token",
+                connection: "keep-alive",
+            },
+            body: JSON.stringify({ hello: "world" }),
+        });
+
+        expect(proxy.getInFlightCount()).toBe(1);
+
+        response.resolve(new Response("ok", { status: 200 }));
+
+        await expect(fetchPromise).resolves.toBeInstanceOf(Response);
+        expect(proxy.getInFlightCount()).toBe(0);
+        expect(forwardToMockFetch).toHaveBeenCalledWith(
+            "https://api.anthropic.com/v1/messages",
+            expect.objectContaining({
+                method: "POST",
+                body: JSON.stringify({ hello: "world" }),
+            }),
+        );
     });
-
-    expect(proxy.getInFlightCount()).toBe(1);
-
-    response.resolve(new Response("ok", { status: 200 }));
-
-    await expect(fetchPromise).resolves.toBeInstanceOf(Response);
-    expect(proxy.getInFlightCount()).toBe(0);
-    expect(forwardToMockFetch).toHaveBeenCalledWith(
-      "https://api.anthropic.com/v1/messages",
-      expect.objectContaining({
-        method: "POST",
-        body: JSON.stringify({ hello: "world" }),
-      }),
-    );
-  });
 });