@vacbo/opencode-anthropic-fix 0.0.44 → 0.1.1

package/src/storage.test.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import { appendFileSync, existsSync, promises as fs, readFileSync, writeFileSync } from "node:fs";
 import { beforeEach, describe, expect, it, vi, type Mock } from "vitest";
 import {
@@ -10,6 +9,7 @@ import {
   loadAccounts,
   saveAccounts,
 } from "./storage.js";
+import type { AccountMetadata, AccountStorage } from "./storage.js";
 
 // Mock fs modules
 vi.mock("node:fs", () => ({
@@ -35,6 +35,41 @@ vi.mock("node:crypto", () => ({
 
 const mockExistsSync = existsSync as Mock;
 const mockReadFileSync = readFileSync as Mock;
+const mockFsReadFile = fs.readFile as Mock;
+const mockFsWriteFile = fs.writeFile as Mock;
+const mockFsRename = fs.rename as Mock;
+const mockFsMkdir = fs.mkdir as Mock;
+const mockFsChmod = fs.chmod as Mock;
+const mockFsUnlink = fs.unlink as Mock;
+
+function makeAccount(overrides: Partial<AccountMetadata> & Pick<AccountMetadata, "refreshToken">): AccountMetadata {
+  const addedAt = overrides.addedAt ?? 1000;
+
+  return {
+    id: overrides.id ?? `${addedAt}:${overrides.refreshToken.slice(0, 12)}`,
+    refreshToken: overrides.refreshToken,
+    token_updated_at: overrides.token_updated_at ?? addedAt,
+    addedAt,
+    lastUsed: overrides.lastUsed ?? 0,
+    enabled: overrides.enabled ?? true,
+    rateLimitResetTimes: overrides.rateLimitResetTimes ?? {},
+    consecutiveFailures: overrides.consecutiveFailures ?? 0,
+    lastFailureTime: overrides.lastFailureTime ?? null,
+    stats: overrides.stats ?? createDefaultStats(addedAt),
+    email: overrides.email,
+    identity: overrides.identity,
+    label: overrides.label,
+    access: overrides.access,
+    expires: overrides.expires,
+    lastSwitchReason: overrides.lastSwitchReason,
+    source: overrides.source,
+  };
+}
+
+function expectLoaded(result: AccountStorage | null): AccountStorage {
+  expect(result).not.toBeNull();
+  return result as AccountStorage;
+}
 
 // ---------------------------------------------------------------------------
 // deduplicateByRefreshToken
@@ -46,17 +81,7 @@ describe("deduplicateByRefreshToken", () => {
   });
 
   it("returns single account unchanged", () => {
-    const accounts = [
-      {
-        refreshToken: "token1",
-        addedAt: 1000,
-        lastUsed: 2000,
-        enabled: true,
-        rateLimitResetTimes: {},
-        consecutiveFailures: 0,
-        lastFailureTime: null,
-      },
-    ];
+    const accounts = [makeAccount({ refreshToken: "token1", addedAt: 1000, lastUsed: 2000 })];
     const result = deduplicateByRefreshToken(accounts);
     expect(result).toHaveLength(1);
     expect(result[0].refreshToken).toBe("token1");
@@ -64,24 +89,8 @@ describe("deduplicateByRefreshToken", () => {
 
   it("keeps most recently used when duplicates exist", () => {
     const accounts = [
-      {
-        refreshToken: "token1",
-        addedAt: 1000,
-        lastUsed: 1000,
-        enabled: true,
-        rateLimitResetTimes: {},
-        consecutiveFailures: 0,
-        lastFailureTime: null,
-      },
-      {
-        refreshToken: "token1",
-        addedAt: 2000,
-        lastUsed: 5000,
-        enabled: true,
-        rateLimitResetTimes: {},
-        consecutiveFailures: 0,
-        lastFailureTime: null,
-      },
+      makeAccount({ refreshToken: "token1", addedAt: 1000, lastUsed: 1000 }),
+      makeAccount({ refreshToken: "token1", addedAt: 2000, lastUsed: 5000 }),
     ];
     const result = deduplicateByRefreshToken(accounts);
     expect(result).toHaveLength(1);
@@ -90,41 +99,15 @@ describe("deduplicateByRefreshToken", () => {
 
   it("keeps different tokens as separate accounts", () => {
     const accounts = [
-      {
-        refreshToken: "token1",
-        addedAt: 1000,
-        lastUsed: 1000,
-        enabled: true,
-        rateLimitResetTimes: {},
-        consecutiveFailures: 0,
-        lastFailureTime: null,
-      },
-      {
-        refreshToken: "token2",
-        addedAt: 2000,
-        lastUsed: 2000,
-        enabled: true,
-        rateLimitResetTimes: {},
-        consecutiveFailures: 0,
-        lastFailureTime: null,
-      },
+      makeAccount({ refreshToken: "token1", addedAt: 1000, lastUsed: 1000 }),
+      makeAccount({ refreshToken: "token2", addedAt: 2000, lastUsed: 2000 }),
     ];
     const result = deduplicateByRefreshToken(accounts);
     expect(result).toHaveLength(2);
   });
 
   it("skips accounts without refreshToken", () => {
-    const accounts = [
-      {
-        refreshToken: "",
-        addedAt: 1000,
-        lastUsed: 1000,
-        enabled: true,
-        rateLimitResetTimes: {},
-        consecutiveFailures: 0,
-        lastFailureTime: null,
-      },
-    ];
+    const accounts = [makeAccount({ refreshToken: "", addedAt: 1000, lastUsed: 1000 })];
     const result = deduplicateByRefreshToken(accounts);
     expect(result).toHaveLength(0);
   });
@@ -198,31 +181,47 @@ describe("loadAccounts", () => {
   });
 
   it("returns null when file does not exist", async () => {
-    fs.readFile.mockRejectedValue(Object.assign(new Error("ENOENT"), { code: "ENOENT" }));
+    mockFsReadFile.mockRejectedValue(Object.assign(new Error("ENOENT"), { code: "ENOENT" }));
     const result = await loadAccounts();
     expect(result).toBeNull();
   });
 
   it("returns null for invalid JSON", async () => {
-    fs.readFile.mockResolvedValue("not json");
+    mockFsReadFile.mockResolvedValue("not json");
     const result = await loadAccounts();
     expect(result).toBeNull();
   });
 
-  it("returns null for wrong version", async () => {
-    fs.readFile.mockResolvedValue(JSON.stringify({ version: 99, accounts: [] }));
+  it("warns and returns best-effort data for unknown version", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    mockFsReadFile.mockResolvedValue(
+      JSON.stringify({
+        version: 99,
+        accounts: [{ refreshToken: "token1", enabled: false }],
+        activeIndex: 0,
+      }),
+    );
+
     const result = await loadAccounts();
-    expect(result).toBeNull();
+
+    expect(warn).toHaveBeenCalledWith("Storage version mismatch: 99 vs 1. Attempting best-effort migration.");
+    expect(result).not.toBeNull();
+    expect(result?.version).toBe(1);
+    expect(result?.accounts).toHaveLength(1);
+    expect(result?.accounts[0]?.refreshToken).toBe("token1");
+    expect(result?.accounts[0]?.enabled).toBe(false);
+
+    warn.mockRestore();
   });
 
   it("returns null when accounts is not an array", async () => {
-    fs.readFile.mockResolvedValue(JSON.stringify({ version: 1, accounts: "not-array" }));
+    mockFsReadFile.mockResolvedValue(JSON.stringify({ version: 1, accounts: "not-array" }));
     const result = await loadAccounts();
     expect(result).toBeNull();
   });
 
   it("loads valid accounts", async () => {
-    fs.readFile.mockResolvedValue(
+    mockFsReadFile.mockResolvedValue(
       JSON.stringify({
         version: 1,
         accounts: [
@@ -241,8 +240,7 @@ describe("loadAccounts", () => {
         activeIndex: 0,
       }),
     );
-    const result = await loadAccounts();
-    expect(result).not.toBeNull();
+    const result = expectLoaded(await loadAccounts());
     expect(result.accounts).toHaveLength(1);
     expect(result.accounts[0].refreshToken).toBe("token1");
     expect(result.accounts[0].access).toBe("access1");
@@ -250,33 +248,58 @@ describe("loadAccounts", () => {
     expect(result.activeIndex).toBe(0);
   });
 
+  it("preserves stored source values and leaves missing source undefined", async () => {
+    mockFsReadFile.mockResolvedValue(
+      JSON.stringify({
+        version: 1,
+        accounts: [
+          {
+            refreshToken: "token1",
+            source: "cc-file",
+            label: "Imported Claude Code",
+          },
+          {
+            refreshToken: "token2",
+          },
+        ],
+        activeIndex: 0,
+      }),
+    );
+
+    const result = expectLoaded(await loadAccounts());
+
+    expect(result.accounts[0]?.source).toBe("cc-file");
+    expect(result.accounts[0]?.label).toBe("Imported Claude Code");
+    expect(result.accounts[1]?.source).toBeUndefined();
+  });
+
   it("filters out invalid accounts (missing refreshToken)", async () => {
-    fs.readFile.mockResolvedValue(
+    mockFsReadFile.mockResolvedValue(
       JSON.stringify({
         version: 1,
         accounts: [{ refreshToken: "valid", addedAt: 1000 }, { email: "no-token" }, null],
         activeIndex: 0,
       }),
     );
-    const result = await loadAccounts();
+    const result = expectLoaded(await loadAccounts());
     expect(result.accounts).toHaveLength(1);
     expect(result.accounts[0].refreshToken).toBe("valid");
   });
 
   it("clamps activeIndex to valid range", async () => {
-    fs.readFile.mockResolvedValue(
+    mockFsReadFile.mockResolvedValue(
       JSON.stringify({
         version: 1,
         accounts: [{ refreshToken: "token1" }],
         activeIndex: 99,
       }),
     );
-    const result = await loadAccounts();
+    const result = expectLoaded(await loadAccounts());
     expect(result.activeIndex).toBe(0);
   });
 
   it("deduplicates accounts by refresh token", async () => {
-    fs.readFile.mockResolvedValue(
+    mockFsReadFile.mockResolvedValue(
       JSON.stringify({
         version: 1,
         accounts: [
@@ -286,21 +309,21 @@ describe("loadAccounts", () => {
         activeIndex: 0,
       }),
     );
-    const result = await loadAccounts();
+    const result = expectLoaded(await loadAccounts());
     expect(result.accounts).toHaveLength(1);
     expect(result.accounts[0].lastUsed).toBe(5000);
   });
 
   it("applies defaults for missing fields", async () => {
-    fs.readFile.mockResolvedValue(
+    mockFsReadFile.mockResolvedValue(
       JSON.stringify({
         version: 1,
         accounts: [{ refreshToken: "token1" }],
         activeIndex: 0,
       }),
     );
-    const result = await loadAccounts();
-    const acc = result.accounts[0];
+    const result = expectLoaded(await loadAccounts());
+    const acc = result.accounts[0]!;
     expect(acc.enabled).toBe(true);
     expect(acc.consecutiveFailures).toBe(0);
     expect(acc.lastFailureTime).toBeNull();
@@ -318,46 +341,46 @@ describe("saveAccounts", () => {
     vi.resetAllMocks();
     mockExistsSync.mockReturnValue(true);
     mockReadFileSync.mockReturnValue(".gitignore\nanthropic-accounts.json\nanthropic-accounts.json.*.tmp\n");
-    fs.mkdir.mockResolvedValue(undefined);
-    fs.writeFile.mockResolvedValue(undefined);
-    fs.rename.mockResolvedValue(undefined);
-    fs.chmod.mockResolvedValue(undefined);
+    mockFsMkdir.mockResolvedValue(undefined);
+    mockFsWriteFile.mockResolvedValue(undefined);
+    mockFsRename.mockResolvedValue(undefined);
+    mockFsChmod.mockResolvedValue(undefined);
   });
 
   it("writes atomically via temp file + rename", async () => {
     const storage = {
       version: 1,
-      accounts: [{ refreshToken: "token1" }],
+      accounts: [makeAccount({ refreshToken: "token1" })],
       activeIndex: 0,
     };
     await saveAccounts(storage);
 
-    expect(fs.writeFile).toHaveBeenCalledWith(expect.stringContaining(".tmp"), expect.any(String), {
+    expect(mockFsWriteFile).toHaveBeenCalledWith(expect.stringContaining(".tmp"), expect.any(String), {
       encoding: "utf-8",
       mode: 0o600,
     });
-    expect(fs.rename).toHaveBeenCalled();
+    expect(mockFsRename).toHaveBeenCalled();
   });
 
   it("creates config directory if needed", async () => {
     const storage = { version: 1, accounts: [], activeIndex: 0 };
     await saveAccounts(storage);
-    expect(fs.mkdir).toHaveBeenCalledWith(expect.any(String), {
+    expect(mockFsMkdir).toHaveBeenCalledWith(expect.any(String), {
       recursive: true,
     });
   });
 
   it("cleans up temp file on write error", async () => {
-    fs.writeFile.mockRejectedValue(new Error("disk full"));
-    fs.unlink.mockResolvedValue(undefined);
+    mockFsWriteFile.mockRejectedValue(new Error("disk full"));
+    mockFsUnlink.mockResolvedValue(undefined);
 
     const storage = { version: 1, accounts: [], activeIndex: 0 };
     await expect(saveAccounts(storage)).rejects.toThrow("disk full");
-    expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining(".tmp"));
+    expect(mockFsUnlink).toHaveBeenCalledWith(expect.stringContaining(".tmp"));
   });
 
   it("merges auth fields from fresher disk state", async () => {
-    fs.readFile.mockResolvedValue(
+    mockFsReadFile.mockResolvedValue(
       JSON.stringify({
         version: 1,
         accounts: [
@@ -403,7 +426,7 @@ describe("saveAccounts", () => {
 
     await saveAccounts(storage);
 
-    const written = JSON.parse(fs.writeFile.mock.calls[0][1]);
+    const written = JSON.parse(mockFsWriteFile.mock.calls[0][1]);
     expect(written.accounts[0].refreshToken).toBe("disk-refresh");
     expect(written.accounts[0].access).toBe("disk-access");
     expect(written.accounts[0].expires).toBe(999999);
@@ -411,7 +434,7 @@ describe("saveAccounts", () => {
   });
 
   it("matches id-less disk accounts by addedAt during freshness merge", async () => {
-    fs.readFile.mockResolvedValue(
+    mockFsReadFile.mockResolvedValue(
       JSON.stringify({
         version: 1,
         accounts: [
@@ -456,13 +479,13 @@ describe("saveAccounts", () => {
 
     await saveAccounts(storage);
 
-    const written = JSON.parse(fs.writeFile.mock.calls[0][1]);
+    const written = JSON.parse(mockFsWriteFile.mock.calls[0][1]);
     expect(written.accounts[0].refreshToken).toBe("disk-refresh-rotated");
     expect(written.accounts[0].token_updated_at).toBe(3000);
   });
 
   it("does not resurrect accounts removed by caller", async () => {
-    fs.readFile.mockResolvedValue(
+    mockFsReadFile.mockResolvedValue(
       JSON.stringify({
         version: 1,
         accounts: [
@@ -485,7 +508,7 @@ describe("saveAccounts", () => {
 
     await saveAccounts({ version: 1, accounts: [], activeIndex: 0 });
 
-    const written = JSON.parse(fs.writeFile.mock.calls[0][1]);
+    const written = JSON.parse(mockFsWriteFile.mock.calls[0][1]);
     expect(written.accounts).toEqual([]);
   });
 });
@@ -500,18 +523,18 @@ describe("clearAccounts", () => {
   });
 
   it("deletes the storage file", async () => {
-    fs.unlink.mockResolvedValue(undefined);
+    mockFsUnlink.mockResolvedValue(undefined);
     await clearAccounts();
-    expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining("anthropic-accounts.json"));
+    expect(mockFsUnlink).toHaveBeenCalledWith(expect.stringContaining("anthropic-accounts.json"));
   });
 
   it("ignores ENOENT errors", async () => {
-    fs.unlink.mockRejectedValue(Object.assign(new Error("ENOENT"), { code: "ENOENT" }));
+    mockFsUnlink.mockRejectedValue(Object.assign(new Error("ENOENT"), { code: "ENOENT" }));
     await expect(clearAccounts()).resolves.toBeUndefined();
   });
 
   it("rethrows non-ENOENT errors", async () => {
-    fs.unlink.mockRejectedValue(Object.assign(new Error("permission denied"), { code: "EACCES" }));
+    mockFsUnlink.mockRejectedValue(Object.assign(new Error("permission denied"), { code: "EACCES" }));
     await expect(clearAccounts()).rejects.toThrow("permission denied");
   });
 });
@@ -560,9 +583,9 @@ describe("loadAccounts with stats", () => {
       ],
       activeIndex: 0,
     };
-    fs.readFile.mockResolvedValue(JSON.stringify(stored));
+    mockFsReadFile.mockResolvedValue(JSON.stringify(stored));
 
-    const result = await loadAccounts();
+    const result = expectLoaded(await loadAccounts());
     expect(result.accounts[0].stats.requests).toBe(42);
     expect(result.accounts[0].stats.inputTokens).toBe(10000);
     expect(result.accounts[0].stats.outputTokens).toBe(5000);
@@ -577,9 +600,9 @@ describe("loadAccounts with stats", () => {
       accounts: [{ refreshToken: "tok1" }],
       activeIndex: 0,
     };
-    fs.readFile.mockResolvedValue(JSON.stringify(stored));
+    mockFsReadFile.mockResolvedValue(JSON.stringify(stored));
 
-    const result = await loadAccounts();
+    const result = expectLoaded(await loadAccounts());
     expect(result.accounts[0].stats.requests).toBe(0);
     expect(result.accounts[0].stats.inputTokens).toBe(0);
     expect(result.accounts[0].stats.outputTokens).toBe(0);
@@ -596,9 +619,9 @@ describe("loadAccounts with stats", () => {
       ],
       activeIndex: 0,
     };
-    fs.readFile.mockResolvedValue(JSON.stringify(stored));
+    mockFsReadFile.mockResolvedValue(JSON.stringify(stored));
 
-    const result = await loadAccounts();
+    const result = expectLoaded(await loadAccounts());
     expect(result.accounts[0].stats.requests).toBe(0);
     expect(result.accounts[0].stats.inputTokens).toBe(0);
     expect(result.accounts[0].stats.outputTokens).toBe(0);