@vacbo/opencode-anthropic-fix 0.1.7 → 0.1.9

package/src/__tests__/helpers/deferred.ts

@@ -13,14 +13,14 @@
  */
 
 export interface Deferred<T> {
-  /** The promise that will resolve/reject when called */
-  promise: Promise<T>;
-  /** Resolve the promise with a value */
-  resolve: (value: T | PromiseLike<T>) => void;
-  /** Reject the promise with a reason */
-  reject: (reason?: unknown) => void;
-  /** Whether the promise has settled (resolved or rejected) */
-  settled: boolean;
+    /** The promise that will resolve/reject when called */
+    promise: Promise<T>;
+    /** Resolve the promise with a value */
+    resolve: (value: T | PromiseLike<T>) => void;
+    /** Reject the promise with a reason */
+    reject: (reason?: unknown) => void;
+    /** Whether the promise has settled (resolved or rejected) */
+    settled: boolean;
 }
 
 /**
@@ -31,44 +31,44 @@ export interface Deferred<T> {
  * @returns Deferred object with promise, resolve, reject, and settled state
  */
 export function createDeferred<T>(): Deferred<T> {
-  let resolve: (value: T | PromiseLike<T>) => void;
-  let reject: (reason?: unknown) => void;
-  let settled = false;
+    let resolve: (value: T | PromiseLike<T>) => void;
+    let reject: (reason?: unknown) => void;
+    let settled = false;
 
-  const promise = new Promise<T>((res, rej) => {
-    resolve = (value) => {
-      if (!settled) {
-        settled = true;
-        res(value);
-      }
-    };
-    reject = (reason) => {
-      if (!settled) {
-        settled = true;
-        rej(reason);
-      }
-    };
-  });
+    const promise = new Promise<T>((res, rej) => {
+        resolve = (value) => {
+            if (!settled) {
+                settled = true;
+                res(value);
+            }
+        };
+        reject = (reason) => {
+            if (!settled) {
+                settled = true;
+                rej(reason);
+            }
+        };
+    });
 
-  return {
-    promise,
-    resolve: resolve!,
-    reject: reject!,
-    get settled() {
-      return settled;
-    },
-  };
+    return {
+        promise,
+        resolve: resolve!,
+        reject: reject!,
+        get settled() {
+            return settled;
+        },
+    };
 }
 
 export interface DeferredQueue<T> {
-  /** Add a new deferred to the queue */
-  enqueue: () => Deferred<T>;
-  /** Resolve the next deferred in FIFO order */
-  resolveNext: (value: T | PromiseLike<T>) => boolean;
-  /** Reject the next deferred in FIFO order */
-  rejectNext: (reason?: unknown) => boolean;
-  /** Number of pending deferreds in the queue */
-  pending: number;
+    /** Add a new deferred to the queue */
+    enqueue: () => Deferred<T>;
+    /** Resolve the next deferred in FIFO order */
+    resolveNext: (value: T | PromiseLike<T>) => boolean;
+    /** Reject the next deferred in FIFO order */
+    rejectNext: (reason?: unknown) => boolean;
+    /** Number of pending deferreds in the queue */
+    pending: number;
 }
 
 /**
@@ -80,34 +80,34 @@ export interface DeferredQueue<T> {
  * @returns Queue with enqueue, resolveNext, rejectNext, and pending count
  */
 export function createDeferredQueue<T>(): DeferredQueue<T> {
-  const queue: Deferred<T>[] = [];
+    const queue: Deferred<T>[] = [];
 
-  return {
-    enqueue: () => {
-      const deferred = createDeferred<T>();
-      queue.push(deferred);
-      return deferred;
-    },
-    resolveNext: (value) => {
-      const next = queue.shift();
-      if (next) {
-        next.resolve(value);
-        return true;
-      }
-      return false;
-    },
-    rejectNext: (reason) => {
-      const next = queue.shift();
-      if (next) {
-        next.reject(reason);
-        return true;
-      }
-      return false;
-    },
-    get pending() {
-      return queue.length;
-    },
-  };
+    return {
+        enqueue: () => {
+            const deferred = createDeferred<T>();
+            queue.push(deferred);
+            return deferred;
+        },
+        resolveNext: (value) => {
+            const next = queue.shift();
+            if (next) {
+                next.resolve(value);
+                return true;
+            }
+            return false;
+        },
+        rejectNext: (reason) => {
+            const next = queue.shift();
+            if (next) {
+                next.reject(reason);
+                return true;
+            }
+            return false;
+        },
+        get pending() {
+            return queue.length;
+        },
+    };
 }
 
 /**
@@ -118,5 +118,5 @@ export function createDeferredQueue<T>(): DeferredQueue<T> {
  * @returns Promise that resolves after one microtask
  */
 export function nextTick(): Promise<void> {
-  return Promise.resolve();
+    return Promise.resolve();
 }

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

@@ -2,165 +2,165 @@ 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",
+    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);
     });
 
-    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,
+    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);
     });
 
-    expect(data.activeIndex).toBe(2);
-  });
+    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 })),
+        }));
 
-  it("storage mocks are vi.fn() instances", () => {
-    const storage = createInMemoryStorage();
+        // 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
+    });
 
-    expect(storage.loadAccountsMock).toBeDefined();
-    expect(storage.saveAccountsMock).toBeDefined();
-  });
+    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();
+    });
 });