@vacbo/opencode-anthropic-fix 0.1.7 → 0.1.9

package/src/account-state.test.ts

@@ -2,108 +2,108 @@ import { describe, expect, it } from "vitest";
 import { adjustActiveIndexAfterRemoval, applyOAuthCredentials, resetAccountTracking } from "./account-state.js";
 
 describe("resetAccountTracking", () => {
-  it("resets rate-limit and failure fields", () => {
-    const account = {
-      rateLimitResetTimes: { anthropic: Date.now() + 60_000 },
-      consecutiveFailures: 7,
-      lastFailureTime: Date.now(),
-    };
+    it("resets rate-limit and failure fields", () => {
+        const account = {
+            rateLimitResetTimes: { anthropic: Date.now() + 60_000 },
+            consecutiveFailures: 7,
+            lastFailureTime: Date.now(),
+        };
 
-    resetAccountTracking(account);
+        resetAccountTracking(account);
 
-    expect(account.rateLimitResetTimes).toEqual({});
-    expect(account.consecutiveFailures).toBe(0);
-    expect(account.lastFailureTime).toBeNull();
-  });
+        expect(account.rateLimitResetTimes).toEqual({});
+        expect(account.consecutiveFailures).toBe(0);
+        expect(account.lastFailureTime).toBeNull();
+    });
 });
 
 describe("applyOAuthCredentials", () => {
-  it("applies refresh/access/expiry and optional email", () => {
-    const account = {
-      refreshToken: "old-refresh",
-      access: "old-access",
-      expires: 1,
-      email: "old@example.com",
-    };
+    it("applies refresh/access/expiry and optional email", () => {
+        const account = {
+            refreshToken: "old-refresh",
+            access: "old-access",
+            expires: 1,
+            email: "old@example.com",
+        };
 
-    applyOAuthCredentials(account, {
-      refresh: "new-refresh",
-      access: "new-access",
-      expires: 123,
-      email: "new@example.com",
-    });
+        applyOAuthCredentials(account, {
+            refresh: "new-refresh",
+            access: "new-access",
+            expires: 123,
+            email: "new@example.com",
+        });
 
-    expect(account).toEqual({
-      refreshToken: "new-refresh",
-      access: "new-access",
-      expires: 123,
-      token_updated_at: expect.any(Number),
-      email: "new@example.com",
+        expect(account).toEqual({
+            refreshToken: "new-refresh",
+            access: "new-access",
+            expires: 123,
+            token_updated_at: expect.any(Number),
+            email: "new@example.com",
+        });
     });
-  });
 
-  it("preserves existing email when credentials omit email", () => {
-    const account = {
-      refreshToken: "old-refresh",
-      access: "old-access",
-      expires: 1,
-      email: "old@example.com",
-    };
+    it("preserves existing email when credentials omit email", () => {
+        const account = {
+            refreshToken: "old-refresh",
+            access: "old-access",
+            expires: 1,
+            email: "old@example.com",
+        };
 
-    applyOAuthCredentials(account, {
-      refresh: "new-refresh",
-      access: "new-access",
-      expires: 456,
-    });
+        applyOAuthCredentials(account, {
+            refresh: "new-refresh",
+            access: "new-access",
+            expires: 456,
+        });
 
-    expect(account.email).toBe("old@example.com");
-    expect(account.refreshToken).toBe("new-refresh");
-    expect(account.access).toBe("new-access");
-    expect(account.expires).toBe(456);
-    expect(account.token_updated_at).toEqual(expect.any(Number));
-  });
+        expect(account.email).toBe("old@example.com");
+        expect(account.refreshToken).toBe("new-refresh");
+        expect(account.access).toBe("new-access");
+        expect(account.expires).toBe(456);
+        expect(account.token_updated_at).toEqual(expect.any(Number));
+    });
 });
 
 describe("adjustActiveIndexAfterRemoval", () => {
-  it("resets activeIndex to 0 when no accounts remain", () => {
-    const storage = { accounts: [], activeIndex: 3 };
-    adjustActiveIndexAfterRemoval(storage, 0);
-    expect(storage.activeIndex).toBe(0);
-  });
+    it("resets activeIndex to 0 when no accounts remain", () => {
+        const storage = { accounts: [], activeIndex: 3 };
+        adjustActiveIndexAfterRemoval(storage, 0);
+        expect(storage.activeIndex).toBe(0);
+    });
 
-  it("clamps activeIndex when it falls out of range", () => {
-    const storage = {
-      accounts: [{ id: "a" }, { id: "b" }],
-      activeIndex: 2,
-    };
-    adjustActiveIndexAfterRemoval(storage, 0);
-    expect(storage.activeIndex).toBe(1);
-  });
+    it("clamps activeIndex when it falls out of range", () => {
+        const storage = {
+            accounts: [{ id: "a" }, { id: "b" }],
+            activeIndex: 2,
+        };
+        adjustActiveIndexAfterRemoval(storage, 0);
+        expect(storage.activeIndex).toBe(1);
+    });
 
-  it("decrements activeIndex when removed index is before active", () => {
-    const storage = {
-      accounts: [{ id: "a" }, { id: "b" }, { id: "c" }],
-      activeIndex: 2,
-    };
-    adjustActiveIndexAfterRemoval(storage, 0);
-    expect(storage.activeIndex).toBe(1);
-  });
+    it("decrements activeIndex when removed index is before active", () => {
+        const storage = {
+            accounts: [{ id: "a" }, { id: "b" }, { id: "c" }],
+            activeIndex: 2,
+        };
+        adjustActiveIndexAfterRemoval(storage, 0);
+        expect(storage.activeIndex).toBe(1);
+    });
 
-  it("keeps activeIndex when removed index is after active", () => {
-    const storage = {
-      accounts: [{ id: "a" }, { id: "b" }, { id: "c" }],
-      activeIndex: 0,
-    };
-    adjustActiveIndexAfterRemoval(storage, 2);
-    expect(storage.activeIndex).toBe(0);
-  });
+    it("keeps activeIndex when removed index is after active", () => {
+        const storage = {
+            accounts: [{ id: "a" }, { id: "b" }, { id: "c" }],
+            activeIndex: 0,
+        };
+        adjustActiveIndexAfterRemoval(storage, 2);
+        expect(storage.activeIndex).toBe(0);
+    });
 
-  it("keeps activeIndex when removed index was the active slot", () => {
-    const storage = {
-      accounts: [{ id: "a" }, { id: "b" }, { id: "c" }],
-      activeIndex: 1,
-    };
-    adjustActiveIndexAfterRemoval(storage, 1);
-    expect(storage.activeIndex).toBe(1);
-  });
+    it("keeps activeIndex when removed index was the active slot", () => {
+        const storage = {
+            accounts: [{ id: "a" }, { id: "b" }, { id: "c" }],
+            activeIndex: 1,
+        };
+        adjustActiveIndexAfterRemoval(storage, 1);
+        expect(storage.activeIndex).toBe(1);
+    });
 });

package/src/account-state.ts

@@ -4,46 +4,46 @@ import type { AccountMetadata, AccountStorage } from "./storage.js";
  * Reset transient account tracking fields.
  */
 export function resetAccountTracking(account: AccountMetadata): void {
-  account.rateLimitResetTimes = {};
-  account.consecutiveFailures = 0;
-  account.lastFailureTime = null;
+    account.rateLimitResetTimes = {};
+    account.consecutiveFailures = 0;
+    account.lastFailureTime = null;
 }
 
 /**
  * Normalize active index after removing one account.
  */
 export function adjustActiveIndexAfterRemoval(storage: AccountStorage, removedIndex: number): void {
-  if (storage.accounts.length === 0) {
-    storage.activeIndex = 0;
-    return;
-  }
+    if (storage.accounts.length === 0) {
+        storage.activeIndex = 0;
+        return;
+    }
 
-  if (storage.activeIndex >= storage.accounts.length) {
-    storage.activeIndex = storage.accounts.length - 1;
-    return;
-  }
+    if (storage.activeIndex >= storage.accounts.length) {
+        storage.activeIndex = storage.accounts.length - 1;
+        return;
+    }
 
-  if (storage.activeIndex > removedIndex) {
-    storage.activeIndex -= 1;
-  }
+    if (storage.activeIndex > removedIndex) {
+        storage.activeIndex -= 1;
+    }
 }
 
 export interface OAuthCredentials {
-  refresh: string;
-  access: string;
-  expires: number;
-  email?: string;
+    refresh: string;
+    access: string;
+    expires: number;
+    email?: string;
 }
 
 /**
  * Apply OAuth credentials to an existing account record.
  */
 export function applyOAuthCredentials(account: AccountMetadata, credentials: OAuthCredentials): void {
-  account.refreshToken = credentials.refresh;
-  account.access = credentials.access;
-  account.expires = credentials.expires;
-  account.token_updated_at = Date.now();
-  if (credentials.email) {
-    account.email = credentials.email;
-  }
+    account.refreshToken = credentials.refresh;
+    account.access = credentials.access;
+    account.expires = credentials.expires;
+    account.token_updated_at = Date.now();
+    if (credentials.email) {
+        account.email = credentials.email;
+    }
 }

package/src/accounts/matching.test.ts

@@ -0,0 +1,335 @@
+/**
+ * Direct unit tests for accounts/matching.ts
+ *
+ * Tests identity resolution, managed account creation, matching,
+ * reindexing, and storage-to-memory account updating.
+ */
+
+import { describe, expect, it } from "vitest";
+
+import type { AccountIdentity } from "../account-identity.js";
+import type { ManagedAccount } from "../accounts.js";
+import type { AccountMetadata } from "../storage.js";
+import {
+    createManagedAccount,
+    findMatchingManagedAccount,
+    reindexManagedAccounts,
+    resolveManagedAccountIdentity,
+    updateManagedAccountFromStorage,
+} from "./matching.js";
+
+// ---------------------------------------------------------------------------
+// resolveManagedAccountIdentity
+// ---------------------------------------------------------------------------
+
+describe("resolveManagedAccountIdentity", () => {
+    it("returns provided identity when present", () => {
+        const identity: AccountIdentity = { kind: "oauth", email: "a@b.com" };
+        const result = resolveManagedAccountIdentity({
+            refreshToken: "tok",
+            identity,
+        });
+        expect(result).toEqual(identity);
+    });
+
+    it("returns cc identity for cc-keychain source with label", () => {
+        const result = resolveManagedAccountIdentity({
+            refreshToken: "tok",
+            source: "cc-keychain",
+            label: "my-label",
+        });
+        expect(result).toEqual({
+            kind: "cc",
+            source: "cc-keychain",
+            label: "my-label",
+        });
+    });
+
+    it("returns cc identity for cc-file source with label", () => {
+        const result = resolveManagedAccountIdentity({
+            refreshToken: "tok",
+            source: "cc-file",
+            label: "file-label",
+        });
+        expect(result).toEqual({
+            kind: "cc",
+            source: "cc-file",
+            label: "file-label",
+        });
+    });
+
+    it("returns oauth identity when email is provided", () => {
+        const result = resolveManagedAccountIdentity({
+            refreshToken: "tok",
+            email: "user@test.com",
+        });
+        expect(result).toEqual({
+            kind: "oauth",
+            email: "user@test.com",
+        });
+    });
+
+    it("returns legacy identity as fallback", () => {
+        const result = resolveManagedAccountIdentity({
+            refreshToken: "my-refresh-token",
+        });
+        expect(result).toEqual({
+            kind: "legacy",
+            refreshToken: "my-refresh-token",
+        });
+    });
+
+    it("prefers explicit identity over email", () => {
+        const identity: AccountIdentity = { kind: "legacy", refreshToken: "x" };
+        const result = resolveManagedAccountIdentity({
+            refreshToken: "tok",
+            email: "user@test.com",
+            identity,
+        });
+        expect(result).not.toBeUndefined();
+        expect(result!.kind).toBe("legacy");
+    });
+
+    it("prefers cc source over email when source is cc-keychain", () => {
+        const result = resolveManagedAccountIdentity({
+            refreshToken: "tok",
+            email: "user@test.com",
+            source: "cc-keychain",
+            label: "cc-label",
+        });
+        expect(result).not.toBeUndefined();
+        expect(result!.kind).toBe("cc");
+    });
+});
+
+// ---------------------------------------------------------------------------
+// createManagedAccount
+// ---------------------------------------------------------------------------
+
+describe("createManagedAccount", () => {
+    it("creates account with minimal fields", () => {
+        const account = createManagedAccount({
+            index: 0,
+            refreshToken: "refresh-abc123xyz",
+        });
+
+        expect(account.index).toBe(0);
+        expect(account.refreshToken).toBe("refresh-abc123xyz");
+        expect(account.enabled).toBe(true);
+        expect(account.consecutiveFailures).toBe(0);
+        expect(account.lastFailureTime).toBeNull();
+        expect(account.source).toBe("oauth");
+        expect(account.id).toContain("refresh-abc1");
+    });
+
+    it("creates account with full override fields", () => {
+        const now = 1000;
+        const account = createManagedAccount({
+            id: "custom-id",
+            index: 2,
+            email: "test@example.com",
+            refreshToken: "tok",
+            access: "access-tok",
+            expires: 9999,
+            enabled: false,
+            consecutiveFailures: 3,
+            lastFailureTime: 500,
+            source: "oauth",
+            now,
+        });
+
+        expect(account.id).toBe("custom-id");
+        expect(account.index).toBe(2);
+        expect(account.email).toBe("test@example.com");
+        expect(account.access).toBe("access-tok");
+        expect(account.expires).toBe(9999);
+        expect(account.enabled).toBe(false);
+        expect(account.consecutiveFailures).toBe(3);
+        expect(account.lastFailureTime).toBe(500);
+    });
+
+    it("copies rateLimitResetTimes instead of sharing reference", () => {
+        const times = { "429": 5000 };
+        const account = createManagedAccount({
+            index: 0,
+            refreshToken: "tok",
+            rateLimitResetTimes: times,
+        });
+
+        times["429"] = 9999;
+        expect(account.rateLimitResetTimes["429"]).toBe(5000);
+    });
+
+    it("assigns cc source when identity is cc", () => {
+        const account = createManagedAccount({
+            index: 0,
+            refreshToken: "tok",
+            source: "cc-keychain",
+            label: "my-cc-label",
+        });
+
+        expect(account.source).toBe("cc-keychain");
+        expect(account.label).toBe("my-cc-label");
+        expect(account.identity?.kind).toBe("cc");
+    });
+});
+
+// ---------------------------------------------------------------------------
+// findMatchingManagedAccount
+// ---------------------------------------------------------------------------
+
+describe("findMatchingManagedAccount", () => {
+    function makeAccount(overrides: Partial<ManagedAccount> = {}): ManagedAccount {
+        return createManagedAccount({
+            index: 0,
+            refreshToken: "default-token",
+            now: 1000,
+            ...overrides,
+        });
+    }
+
+    it("finds by id", () => {
+        const a = makeAccount({ id: "match-id" });
+        const b = makeAccount({ id: "other-id", refreshToken: "tok2" });
+        const result = findMatchingManagedAccount([a, b], { id: "match-id" });
+        expect(result).toBe(a);
+    });
+
+    it("finds by identity", () => {
+        const identity: AccountIdentity = { kind: "oauth", email: "user@x.com" };
+        const a = makeAccount({ email: "user@x.com", identity });
+        const result = findMatchingManagedAccount([a], { identity });
+        expect(result).toBe(a);
+    });
+
+    it("finds by refreshToken as fallback", () => {
+        const a = makeAccount({ refreshToken: "my-token-abcdef" });
+        const result = findMatchingManagedAccount([a], { refreshToken: "my-token-abcdef" });
+        expect(result).toBe(a);
+    });
+
+    it("returns null when no match", () => {
+        const a = makeAccount({ id: "no-match" });
+        const result = findMatchingManagedAccount([a], { id: "different" });
+        expect(result).toBeNull();
+    });
+
+    it("returns null for empty accounts array", () => {
+        const result = findMatchingManagedAccount([], { id: "x" });
+        expect(result).toBeNull();
+    });
+
+    it("prefers id match over identity match", () => {
+        const identity: AccountIdentity = { kind: "oauth", email: "user@x.com" };
+        const a = makeAccount({ id: "id-match", email: "other@x.com" });
+        const b = makeAccount({ id: "other", email: "user@x.com", identity, refreshToken: "tok2" });
+        const result = findMatchingManagedAccount([a, b], { id: "id-match", identity });
+        expect(result).toBe(a);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// reindexManagedAccounts
+// ---------------------------------------------------------------------------
+
+describe("reindexManagedAccounts", () => {
+    it("reassigns sequential indices starting from 0", () => {
+        const accounts = [
+            createManagedAccount({ index: 5, refreshToken: "a" }),
+            createManagedAccount({ index: 10, refreshToken: "b" }),
+            createManagedAccount({ index: 0, refreshToken: "c" }),
+        ];
+
+        reindexManagedAccounts(accounts);
+
+        expect(accounts[0].index).toBe(0);
+        expect(accounts[1].index).toBe(1);
+        expect(accounts[2].index).toBe(2);
+    });
+
+    it("handles empty array", () => {
+        const accounts: ManagedAccount[] = [];
+        reindexManagedAccounts(accounts);
+        expect(accounts).toHaveLength(0);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// updateManagedAccountFromStorage
+// ---------------------------------------------------------------------------
+
+describe("updateManagedAccountFromStorage", () => {
+    function makeExisting(): ManagedAccount {
+        return createManagedAccount({
+            id: "existing-id",
+            index: 0,
+            email: "old@test.com",
+            refreshToken: "old-token",
+            access: "old-access",
+            expires: 1000,
+            source: "oauth",
+        });
+    }
+
+    function makeStorageAccount(overrides: Partial<AccountMetadata> = {}): AccountMetadata {
+        return {
+            id: "storage-id",
+            refreshToken: "new-token",
+            token_updated_at: 2000,
+            addedAt: 2000,
+            lastUsed: 3000,
+            enabled: true,
+            rateLimitResetTimes: {},
+            consecutiveFailures: 0,
+            lastFailureTime: null,
+            stats: {
+                requests: 10,
+                inputTokens: 100,
+                outputTokens: 50,
+                cacheReadTokens: 0,
+                cacheWriteTokens: 0,
+                lastReset: 1000,
+            },
+            ...overrides,
+        };
+    }
+
+    it("updates index from parameter", () => {
+        const existing = makeExisting();
+        updateManagedAccountFromStorage(existing, makeStorageAccount(), 5);
+        expect(existing.index).toBe(5);
+    });
+
+    it("updates refreshToken from storage", () => {
+        const existing = makeExisting();
+        updateManagedAccountFromStorage(existing, makeStorageAccount({ refreshToken: "updated-tok" }), 0);
+        expect(existing.refreshToken).toBe("updated-tok");
+    });
+
+    it("preserves email from existing when storage has none", () => {
+        const existing = makeExisting();
+        updateManagedAccountFromStorage(existing, makeStorageAccount(), 0);
+        expect(existing.email).toBe("old@test.com");
+    });
+
+    it("updates email from storage when provided", () => {
+        const existing = makeExisting();
+        updateManagedAccountFromStorage(existing, makeStorageAccount({ email: "new@test.com" }), 0);
+        expect(existing.email).toBe("new@test.com");
+    });
+
+    it("copies rateLimitResetTimes (not reference)", () => {
+        const existing = makeExisting();
+        const times = { "429": 9999 };
+        updateManagedAccountFromStorage(existing, makeStorageAccount({ rateLimitResetTimes: times }), 0);
+
+        times["429"] = 0;
+        expect(existing.rateLimitResetTimes["429"]).toBe(9999);
+    });
+
+    it("updates enabled status", () => {
+        const existing = makeExisting();
+        updateManagedAccountFromStorage(existing, makeStorageAccount({ enabled: false }), 0);
+        expect(existing.enabled).toBe(false);
+    });
+});