@vacbo/opencode-anthropic-fix 0.0.45 → 0.1.2

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

@@ -0,0 +1,166 @@
+import { describe, expect, it } from "vitest";
+import { createInMemoryStorage, makeAccountsData, makeStoredAccount } from "./in-memory-storage.js";
+
+describe("in-memory-storage smoke tests", () => {
+  it("createInMemoryStorage creates storage with initial data", () => {
+    const initial = makeAccountsData([{ refreshToken: "tok1" }]);
+    const storage = createInMemoryStorage(initial);
+
+    expect(storage.snapshot()).toEqual(initial);
+  });
+
+  it("createInMemoryStorage creates storage with null initial state", async () => {
+    const storage = createInMemoryStorage();
+
+    // loadAccountsMock should return null
+    const loaded = await storage.loadAccountsMock();
+    expect(loaded).toBeNull();
+
+    // snapshot should throw when null
+    expect(() => storage.snapshot()).toThrow("Storage snapshot is null");
+  });
+
+  it("setSnapshot updates both disk and memory state", async () => {
+    const storage = createInMemoryStorage();
+    const data = makeAccountsData([{ refreshToken: "tok1" }]);
+
+    storage.setSnapshot(data);
+
+    // Memory should match
+    expect(storage.snapshot()).toEqual(data);
+
+    // Disk should match (via loadAccountsMock)
+    const loaded = await storage.loadAccountsMock();
+    expect(loaded).toEqual(data);
+  });
+
+  it("snapshot returns deep copy - mutations don't affect storage", () => {
+    const initial = makeAccountsData([{ refreshToken: "tok1", enabled: true }]);
+    const storage = createInMemoryStorage(initial);
+
+    const snap = storage.snapshot();
+    snap.accounts[0].enabled = false;
+    snap.accounts[0].refreshToken = "mutated";
+
+    // Storage should be unchanged
+    const snap2 = storage.snapshot();
+    expect(snap2.accounts[0].enabled).toBe(true);
+    expect(snap2.accounts[0].refreshToken).toBe("tok1");
+  });
+
+  it("saveAccountsMock writes to disk state", async () => {
+    const storage = createInMemoryStorage();
+    const data = makeAccountsData([{ refreshToken: "tok1" }]);
+
+    // Save via mock
+    await storage.saveAccountsMock(data);
+
+    // Should be readable via loadAccountsMock
+    const loaded = await storage.loadAccountsMock();
+    expect(loaded).toEqual(data);
+  });
+
+  it("mutateDiskOnly changes disk without affecting caller's snapshot", () => {
+    const initial = makeAccountsData([{ refreshToken: "tok1", enabled: true }]);
+    const storage = createInMemoryStorage(initial);
+
+    // Get current snapshot (what test subject holds)
+    const beforeSnapshot = storage.snapshot();
+    expect(beforeSnapshot.accounts[0].enabled).toBe(true);
+
+    // Simulate another process writing to disk
+    storage.mutateDiskOnly((disk) => ({
+      ...disk,
+      accounts: disk.accounts.map((a) => ({ ...a, enabled: false })),
+    }));
+
+    // Caller's snapshot should be unchanged
+    const afterSnapshot = storage.snapshot();
+    expect(afterSnapshot.accounts[0].enabled).toBe(true);
+
+    // But disk state should be changed
+    expect(afterSnapshot.accounts[0].enabled).toBe(true); // Still true in memory
+  });
+
+  it("mutateDiskOnly affects subsequent loadAccountsMock calls", async () => {
+    const initial = makeAccountsData([{ refreshToken: "tok1", enabled: true }]);
+    const storage = createInMemoryStorage(initial);
+
+    // Mutate disk
+    storage.mutateDiskOnly((disk) => ({
+      ...disk,
+      accounts: disk.accounts.map((a) => ({ ...a, enabled: false })),
+    }));
+
+    // Load should see the mutated state
+    const loaded = await storage.loadAccountsMock();
+    expect(loaded?.accounts[0].enabled).toBe(false);
+  });
+
+  it("mutateDiskOnly throws when disk state is null", () => {
+    const storage = createInMemoryStorage();
+
+    expect(() =>
+      storage.mutateDiskOnly((disk) => ({
+        ...disk,
+        accounts: [],
+      })),
+    ).toThrow("Cannot mutate disk - disk state is null");
+  });
+
+  it("makeStoredAccount creates valid account with defaults", () => {
+    const account = makeStoredAccount({ refreshToken: "my-token" });
+
+    expect(account.refreshToken).toBe("my-token");
+    expect(account.id).toMatch(/^acct-/);
+    expect(account.enabled).toBe(true);
+    expect(account.consecutiveFailures).toBe(0);
+    expect(account.lastFailureTime).toBeNull();
+    expect(account.stats.requests).toBe(0);
+    expect(account.addedAt).toBeGreaterThan(0);
+  });
+
+  it("makeStoredAccount applies overrides", () => {
+    const account = makeStoredAccount({
+      refreshToken: "tok1",
+      enabled: false,
+      consecutiveFailures: 5,
+      email: "test@example.com",
+    });
+
+    expect(account.refreshToken).toBe("tok1");
+    expect(account.enabled).toBe(false);
+    expect(account.consecutiveFailures).toBe(5);
+    expect(account.email).toBe("test@example.com");
+  });
+
+  it("makeAccountsData creates storage with multiple accounts", () => {
+    const data = makeAccountsData([
+      { refreshToken: "tok1", email: "a@test.com" },
+      { refreshToken: "tok2", email: "b@test.com" },
+    ]);
+
+    expect(data.version).toBe(1);
+    expect(data.activeIndex).toBe(0);
+    expect(data.accounts).toHaveLength(2);
+    expect(data.accounts[0].refreshToken).toBe("tok1");
+    expect(data.accounts[1].refreshToken).toBe("tok2");
+    expect(data.accounts[0].addedAt).toBe(1000);
+    expect(data.accounts[1].addedAt).toBe(2000);
+  });
+
+  it("makeAccountsData accepts extra storage fields", () => {
+    const data = makeAccountsData([{ refreshToken: "tok1" }], {
+      activeIndex: 2,
+    });
+
+    expect(data.activeIndex).toBe(2);
+  });
+
+  it("storage mocks are vi.fn() instances", () => {
+    const storage = createInMemoryStorage();
+
+    expect(storage.loadAccountsMock).toBeDefined();
+    expect(storage.saveAccountsMock).toBeDefined();
+  });
+});

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

@@ -0,0 +1,152 @@
+import { vi } from "vitest";
+import type { AccountMetadata, AccountStorage } from "../../storage.js";
+
+/**
+ * In-memory storage harness for testing account deduplication and
+ * concurrent access scenarios without touching the real filesystem.
+ */
+export interface InMemoryStorage {
+  /** 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;
+
+  /**
+   * 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 saveAccounts - writes to disk */
+  saveAccountsMock: (data: AccountStorage) => Promise<void>;
+}
+
+/**
+ * Create an in-memory storage harness for testing.
+ *
+ * @param initial - Optional initial storage state. If not provided, returns null on load.
+ * @returns Storage harness with snapshot management and mock functions
+ *
+ * @example
+ * ```ts
+ * const storage = createInMemoryStorage({
+ *   version: 1,
+ *   accounts: [{ refreshToken: "tok1", addedAt: 1000, lastUsed: 0, enabled: true }],
+ *   activeIndex: 0,
+ * });
+ *
+ * // Wire up mocks
+ * vi.mock("../../storage.js", () => ({
+ *   loadAccounts: storage.loadAccountsMock,
+ *   saveAccounts: storage.saveAccountsMock,
+ *   createDefaultStats: vi.fn((now?: number) => ({
+ *     requests: 0,
+ *     inputTokens: 0,
+ *     outputTokens: 0,
+ *     cacheReadTokens: 0,
+ *     cacheWriteTokens: 0,
+ *     lastReset: now ?? Date.now(),
+ *   })),
+ * }));
+ * ```
+ */
+export function createInMemoryStorage(initial?: AccountStorage): InMemoryStorage {
+  // 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;
+
+  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);
+    },
+
+    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);
+    }),
+
+    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,
+  };
+}
+
+/**
+ * Helper to create a valid storage payload from account overrides.
+ */
+export function makeAccountsData(
+  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,
+  };
+}

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

@@ -0,0 +1,92 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+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"],
+    });
+    const onData = vi.fn();
+
+    child.stdout?.on("data", onData);
+
+    proxy.simulateStdoutBanner();
+
+    expect(onData).not.toHaveBeenCalled();
+
+    await vi.advanceTimersByTimeAsync(25);
+
+    expect(proxy.child.pid).toBe(child.pid);
+    expect(onData).toHaveBeenCalledOnce();
+    expect(onData.mock.calls[0][0].toString()).toContain("BUN_PROXY_PORT=48372");
+  });
+
+  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();
+
+    child.on("exit", onExit);
+
+    proxy.simulateExit(0);
+    child.kill("SIGKILL");
+
+    expect(onExit).toHaveBeenCalledWith(0, null);
+    expect(proxy.child.killSignals).toEqual(["SIGKILL"]);
+  });
+
+  it("rejects async spawn callers when configured to throw", async () => {
+    const proxy = createMockBunProxy({ spawnError: new Error("spawn failed") });
+
+    await expect((async () => proxy.mockSpawn("bun", ["run", "./bun-proxy.ts", "48372"], {}))()).rejects.toThrow(
+      "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"],
+    });
+
+    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" }),
+      }),
+    );
+  });
+});

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

@@ -0,0 +1,229 @@
+import type { ChildProcess, SpawnOptions } from "node:child_process";
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+
+import { vi, type Mock } from "vitest";
+
+type ForwardFetchInput = string | URL | Request;
+type ForwardFetch = (input: ForwardFetchInput, init?: RequestInit) => Promise<Response>;
+
+type MockChildProcess = EventEmitter &
+  Omit<
+    ChildProcess,
+    "pid" | "killed" | "exitCode" | "signalCode" | "stdout" | "stderr" | "spawnfile" | "spawnargs" | "kill"
+  > & {
+    killSignals: NodeJS.Signals[];
+    pid: number;
+    killed: boolean;
+    exitCode: number | null;
+    signalCode: NodeJS.Signals | null;
+    stdout: PassThrough;
+    stderr: PassThrough;
+    spawnfile: string;
+    spawnargs: string[];
+    kill: (signal?: number | NodeJS.Signals | null) => boolean;
+    forwardFetch: ForwardFetch;
+  };
+
+export interface MockProxyOptions {
+  bannerDelay?: number;
+  spawnError?: Error;
+  forwardToMockFetch?: ForwardFetch;
+  parentDeathSimulation?: boolean;
+}
+
+export interface MockBunProxy {
+  mockSpawn: Mock;
+  child: MockChildProcess;
+  simulateExit(code?: number | null, signal?: NodeJS.Signals | null): void;
+  simulateStdoutBanner(port?: number): void;
+  simulateCrash(message?: string): void;
+  getInFlightCount(): number;
+}
+
+let nextPid = 48_372;
+
+function normalizeSignal(signal?: number | NodeJS.Signals | null): NodeJS.Signals {
+  return typeof signal === "string" ? signal : "SIGTERM";
+}
+
+function inferSpawnPort(args: string[]): number {
+  const numericArg = [...args].reverse().find((arg) => /^\d+$/.test(arg));
+  return numericArg ? Number.parseInt(numericArg, 10) : 48_372;
+}
+
+async function normalizeForwardedRequest(
+  input: ForwardFetchInput,
+  init?: RequestInit,
+): Promise<{
+  targetUrl: string;
+  forwardedInit: RequestInit;
+}> {
+  const request =
+    input instanceof Request
+      ? new Request(input, init)
+      : new Request(input instanceof URL ? input.toString() : input, init);
+  const headers = new Headers(request.headers);
+  const targetUrl = headers.get("x-proxy-url") ?? request.url;
+
+  headers.delete("x-proxy-url");
+  headers.delete("host");
+  headers.delete("connection");
+
+  const method = request.method || "GET";
+  let body: RequestInit["body"] | undefined;
+
+  if (method !== "GET" && method !== "HEAD") {
+    if (init?.body !== undefined) {
+      body = init.body;
+    } else {
+      const textBody = await request.clone().text();
+      body = textBody.length > 0 ? textBody : undefined;
+    }
+  }
+
+  return {
+    targetUrl,
+    forwardedInit: {
+      method,
+      headers,
+      body,
+    },
+  };
+}
+
+export function createMockBunProxy(options: MockProxyOptions = {}): MockBunProxy {
+  let inFlightCount = 0;
+  let exited = false;
+  let lastSpawnArgs: string[] = [];
+  const pendingTimers = new Set<NodeJS.Timeout>();
+  const forwardToMockFetch: ForwardFetch =
+    options.forwardToMockFetch ?? (async () => new Response(null, { status: 204 }));
+
+  const stdout = new PassThrough();
+  const stderr = new PassThrough();
+  const child = new EventEmitter() as MockChildProcess;
+
+  child.pid = nextPid++;
+  child.killed = false;
+  child.exitCode = null;
+  child.signalCode = null;
+  child.stdout = stdout;
+  child.stderr = stderr;
+  child.killSignals = [];
+  child.spawnfile = "";
+  child.spawnargs = [];
+  child.kill = (signal?: number | NodeJS.Signals | null) => {
+    const normalizedSignal = normalizeSignal(signal);
+    child.killSignals.push(normalizedSignal);
+    child.killed = true;
+
+    if (options.parentDeathSimulation) {
+      queueMicrotask(() => {
+        emitExit(null, normalizedSignal);
+      });
+    }
+
+    return true;
+  };
+  child.forwardFetch = async (input: ForwardFetchInput, init?: RequestInit): Promise<Response> => {
+    inFlightCount += 1;
+
+    try {
+      const { targetUrl, forwardedInit } = await normalizeForwardedRequest(input, init);
+      return await forwardToMockFetch(targetUrl, forwardedInit);
+    } finally {
+      inFlightCount -= 1;
+    }
+  };
+
+  const clearPendingTimers = (): void => {
+    for (const timer of pendingTimers) {
+      clearTimeout(timer);
+    }
+    pendingTimers.clear();
+  };
+
+  const emitExit = (code: number | null = 0, signal: NodeJS.Signals | null = null): void => {
+    if (exited) {
+      return;
+    }
+
+    exited = true;
+    clearPendingTimers();
+    child.exitCode = code;
+    child.signalCode = signal;
+
+    child.emit("exit", code, signal);
+    child.emit("close", code, signal);
+    stdout.end();
+    stderr.end();
+  };
+
+  const mockSpawn = vi.fn(
+    (
+      command: string,
+      argsOrOptions?: readonly string[] | SpawnOptions,
+      maybeOptions?: SpawnOptions,
+    ): MockChildProcess => {
+      if (options.spawnError) {
+        throw options.spawnError;
+      }
+
+      const args = Array.isArray(argsOrOptions) ? [...argsOrOptions] : [];
+      const spawnOptions = Array.isArray(argsOrOptions) ? maybeOptions : argsOrOptions;
+
+      lastSpawnArgs = args;
+      child.spawnfile = command;
+      child.spawnargs = [command, ...args];
+      void spawnOptions;
+
+      return child;
+    },
+  );
+
+  const simulateStdoutBanner = (port = inferSpawnPort(lastSpawnArgs)): void => {
+    if (exited) {
+      return;
+    }
+
+    const writeBanner = (): void => {
+      if (!exited) {
+        stdout.write(`BUN_PROXY_PORT=${port}\n`);
+      }
+    };
+
+    if (!options.bannerDelay || options.bannerDelay <= 0) {
+      writeBanner();
+      return;
+    }
+
+    const timer = setTimeout(() => {
+      pendingTimers.delete(timer);
+      writeBanner();
+    }, options.bannerDelay);
+
+    timer.unref?.();
+    pendingTimers.add(timer);
+  };
+
+  return {
+    mockSpawn,
+    child,
+    simulateExit(code = 0, signal = null): void {
+      emitExit(code, signal);
+    },
+    simulateStdoutBanner,
+    simulateCrash(message = "mock bun proxy crashed"): void {
+      if (exited) {
+        return;
+      }
+
+      stderr.write(`${message}\n`);
+      emitExit(1, null);
+    },
+    getInFlightCount(): number {
+      return inFlightCount;
+    },
+  };
+}