opencode-anthropic-fix 0.0.14

package/lib/rotation.test.mjs

@@ -0,0 +1,346 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { HealthScoreTracker, TokenBucketTracker, selectAccount } from "./rotation.mjs";
+
+// ---------------------------------------------------------------------------
+// HealthScoreTracker
+// ---------------------------------------------------------------------------
+
+describe("HealthScoreTracker", () => {
+  /** @type {HealthScoreTracker} */
+  let tracker;
+
+  beforeEach(() => {
+    tracker = new HealthScoreTracker();
+  });
+
+  it("returns initial score for unknown account", () => {
+    expect(tracker.getScore(0)).toBe(70);
+  });
+
+  it("increases score on success", () => {
+    tracker.recordSuccess(0);
+    expect(tracker.getScore(0)).toBe(71);
+  });
+
+  it("decreases score on rate limit", () => {
+    tracker.recordRateLimit(0);
+    expect(tracker.getScore(0)).toBe(60);
+  });
+
+  it("decreases score on failure", () => {
+    tracker.recordFailure(0);
+    expect(tracker.getScore(0)).toBe(50);
+  });
+
+  it("does not go below 0", () => {
+    for (let i = 0; i < 10; i++) {
+      tracker.recordFailure(0);
+    }
+    expect(tracker.getScore(0)).toBe(0);
+  });
+
+  it("caps at max_score", () => {
+    for (let i = 0; i < 50; i++) {
+      tracker.recordSuccess(0);
+    }
+    expect(tracker.getScore(0)).toBe(100);
+  });
+
+  it("isUsable returns true when score >= min_usable", () => {
+    expect(tracker.isUsable(0)).toBe(true); // 70 >= 50
+  });
+
+  it("isUsable returns false when score < min_usable", () => {
+    // 70 - 20 = 50 (still usable), need one more
+    tracker.recordFailure(0); // 50
+    expect(tracker.isUsable(0)).toBe(true);
+    tracker.recordRateLimit(0); // 40
+    expect(tracker.isUsable(0)).toBe(false);
+  });
+
+  it("reset removes tracking for an account", () => {
+    tracker.recordFailure(0);
+    tracker.reset(0);
+    expect(tracker.getScore(0)).toBe(70); // Back to initial
+  });
+
+  it("tracks accounts independently", () => {
+    tracker.recordFailure(0);
+    tracker.recordSuccess(1);
+    expect(tracker.getScore(0)).toBe(50);
+    expect(tracker.getScore(1)).toBe(71);
+  });
+
+  it("applies passive recovery over time", () => {
+    tracker.recordFailure(0); // Score = 50
+    // Simulate 1 hour passing
+    const state = tracker.getScore(0);
+    expect(state).toBe(50);
+
+    // We can't easily test time-based recovery without mocking Date.now
+    // but we can verify the formula works by checking the code path
+  });
+
+  it("uses custom config", () => {
+    const custom = new HealthScoreTracker({
+      initial: 100,
+      success_reward: 5,
+      rate_limit_penalty: -5,
+      failure_penalty: -10,
+      min_usable: 80,
+      max_score: 100,
+    });
+    expect(custom.getScore(0)).toBe(100);
+    custom.recordRateLimit(0);
+    expect(custom.getScore(0)).toBe(95);
+    expect(custom.isUsable(0)).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// TokenBucketTracker
+// ---------------------------------------------------------------------------
+
+describe("TokenBucketTracker", () => {
+  /** @type {TokenBucketTracker} */
+  let tracker;
+
+  beforeEach(() => {
+    tracker = new TokenBucketTracker();
+  });
+
+  it("returns initial tokens for unknown account", () => {
+    expect(tracker.getTokens(0)).toBe(50);
+  });
+
+  it("hasTokens returns true when tokens available", () => {
+    expect(tracker.hasTokens(0)).toBe(true);
+  });
+
+  it("consume reduces tokens", () => {
+    tracker.consume(0);
+    expect(tracker.getTokens(0)).toBe(49);
+  });
+
+  it("consume returns false when insufficient tokens", () => {
+    // Drain all tokens
+    for (let i = 0; i < 50; i++) {
+      tracker.consume(0);
+    }
+    expect(tracker.consume(0)).toBe(false);
+    expect(tracker.hasTokens(0)).toBe(false);
+  });
+
+  it("refund adds tokens back", () => {
+    tracker.consume(0);
+    tracker.consume(0);
+    tracker.refund(0);
+    expect(tracker.getTokens(0)).toBe(49);
+  });
+
+  it("refund does not exceed max", () => {
+    tracker.refund(0, 100);
+    expect(tracker.getTokens(0)).toBe(50);
+  });
+
+  it("getMaxTokens returns configured max", () => {
+    expect(tracker.getMaxTokens()).toBe(50);
+  });
+
+  it("uses custom config", () => {
+    const custom = new TokenBucketTracker({
+      max_tokens: 10,
+      initial_tokens: 5,
+      regeneration_rate_per_minute: 1,
+    });
+    expect(custom.getTokens(0)).toBe(5);
+    expect(custom.getMaxTokens()).toBe(10);
+  });
+
+  it("tracks accounts independently", () => {
+    tracker.consume(0);
+    expect(tracker.getTokens(0)).toBe(49);
+    expect(tracker.getTokens(1)).toBe(50);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// selectAccount
+// ---------------------------------------------------------------------------
+
+describe("selectAccount", () => {
+  /** @type {HealthScoreTracker} */
+  let healthTracker;
+  /** @type {TokenBucketTracker} */
+  let tokenTracker;
+
+  beforeEach(() => {
+    healthTracker = new HealthScoreTracker();
+    tokenTracker = new TokenBucketTracker();
+  });
+
+  /**
+   * @param {Partial<import('./rotation.mjs').AccountCandidate>} overrides
+   * @returns {import('./rotation.mjs').AccountCandidate}
+   */
+  function makeCandidate(overrides = {}) {
+    return {
+      index: 0,
+      lastUsed: 0,
+      healthScore: 70,
+      isRateLimited: false,
+      enabled: true,
+      ...overrides,
+    };
+  }
+
+  it("returns null when no candidates", () => {
+    expect(selectAccount([], "sticky", null, healthTracker, tokenTracker, 0)).toBeNull();
+  });
+
+  it("returns null when all candidates are rate-limited", () => {
+    const candidates = [
+      makeCandidate({ index: 0, isRateLimited: true }),
+      makeCandidate({ index: 1, isRateLimited: true }),
+    ];
+    expect(selectAccount(candidates, "sticky", null, healthTracker, tokenTracker, 0)).toBeNull();
+  });
+
+  it("returns null when all candidates are disabled", () => {
+    const candidates = [makeCandidate({ index: 0, enabled: false })];
+    expect(selectAccount(candidates, "sticky", null, healthTracker, tokenTracker, 0)).toBeNull();
+  });
+
+  // Sticky strategy
+  describe("sticky strategy", () => {
+    it("returns current account if available", () => {
+      const candidates = [makeCandidate({ index: 0 }), makeCandidate({ index: 1 })];
+      const result = selectAccount(candidates, "sticky", 0, healthTracker, tokenTracker, 0);
+      expect(result?.index).toBe(0);
+    });
+
+    it("switches when current is rate-limited", () => {
+      const candidates = [makeCandidate({ index: 0, isRateLimited: true }), makeCandidate({ index: 1 })];
+      const result = selectAccount(candidates, "sticky", 0, healthTracker, tokenTracker, 0);
+      expect(result?.index).toBe(1);
+    });
+
+    it("does not switch when current is unhealthy", () => {
+      // Make account 0 unhealthy
+      for (let i = 0; i < 5; i++) {
+        healthTracker.recordFailure(0);
+      }
+      const candidates = [makeCandidate({ index: 0 }), makeCandidate({ index: 1 })];
+      const result = selectAccount(candidates, "sticky", 0, healthTracker, tokenTracker, 0);
+      expect(result?.index).toBe(0);
+      expect(result?.cursor).toBe(0);
+    });
+
+    it("keeps current even when cursor points elsewhere", () => {
+      // Make account 0 unhealthy
+      for (let i = 0; i < 5; i++) {
+        healthTracker.recordFailure(0);
+      }
+      const candidates = [makeCandidate({ index: 0 }), makeCandidate({ index: 1 })];
+      // Even with cursor=1, sticky should keep the current account
+      const result = selectAccount(candidates, "sticky", 0, healthTracker, tokenTracker, 1);
+      expect(result?.index).toBe(0);
+      expect(result?.cursor).toBe(1);
+    });
+
+    it("selects first available when no current", () => {
+      const candidates = [makeCandidate({ index: 0 }), makeCandidate({ index: 1 })];
+      const result = selectAccount(candidates, "sticky", null, healthTracker, tokenTracker, 0);
+      expect(result?.index).toBe(0);
+    });
+  });
+
+  // Round-robin strategy
+  describe("round-robin strategy", () => {
+    it("rotates through accounts", () => {
+      const candidates = [makeCandidate({ index: 0 }), makeCandidate({ index: 1 }), makeCandidate({ index: 2 })];
+
+      const r1 = selectAccount(candidates, "round-robin", null, healthTracker, tokenTracker, 0);
+      expect(r1?.index).toBe(0);
+
+      const r2 = selectAccount(candidates, "round-robin", 0, healthTracker, tokenTracker, r1.cursor);
+      expect(r2?.index).toBe(1);
+
+      const r3 = selectAccount(candidates, "round-robin", 1, healthTracker, tokenTracker, r2.cursor);
+      expect(r3?.index).toBe(2);
+
+      // Wraps around
+      const r4 = selectAccount(candidates, "round-robin", 2, healthTracker, tokenTracker, r3.cursor);
+      expect(r4?.index).toBe(0);
+    });
+
+    it("skips rate-limited accounts", () => {
+      const candidates = [
+        makeCandidate({ index: 0, isRateLimited: true }),
+        makeCandidate({ index: 1 }),
+        makeCandidate({ index: 2 }),
+      ];
+      const result = selectAccount(candidates, "round-robin", null, healthTracker, tokenTracker, 0);
+      expect(result?.index).toBe(1);
+    });
+  });
+
+  // Hybrid strategy
+  describe("hybrid strategy", () => {
+    it("selects the account with highest composite score", () => {
+      const candidates = [
+        makeCandidate({ index: 0, lastUsed: Date.now() }),
+        makeCandidate({ index: 1, lastUsed: 0 }), // Older = more fresh
+      ];
+      // Account 1 should have higher freshness score
+      const result = selectAccount(candidates, "hybrid", null, healthTracker, tokenTracker, 0);
+      // Both have same health and tokens, but account 1 has more freshness
+      expect(result?.index).toBe(1);
+    });
+
+    it("applies stickiness bonus to current account", () => {
+      const candidates = [
+        makeCandidate({ index: 0, lastUsed: Date.now() }),
+        makeCandidate({ index: 1, lastUsed: Date.now() - 1000 }),
+      ];
+      // Account 0 is current — stickiness bonus should keep it
+      const result = selectAccount(candidates, "hybrid", 0, healthTracker, tokenTracker, 0);
+      expect(result?.index).toBe(0);
+    });
+
+    it("falls back to any available when all are unhealthy", () => {
+      // Make all accounts unhealthy
+      for (let i = 0; i < 10; i++) {
+        healthTracker.recordFailure(0);
+        healthTracker.recordFailure(1);
+      }
+      const candidates = [makeCandidate({ index: 0 }), makeCandidate({ index: 1 })];
+      const result = selectAccount(candidates, "hybrid", null, healthTracker, tokenTracker, 0);
+      // Should fall back to first available
+      expect(result).not.toBeNull();
+    });
+
+    it("switches when advantage exceeds threshold", () => {
+      // Make account 0 very unhealthy
+      for (let i = 0; i < 4; i++) {
+        healthTracker.recordFailure(0);
+      }
+      // Drain account 0's tokens
+      for (let i = 0; i < 50; i++) {
+        tokenTracker.consume(0);
+      }
+
+      const candidates = [makeCandidate({ index: 0, lastUsed: Date.now() }), makeCandidate({ index: 1, lastUsed: 0 })];
+      const result = selectAccount(candidates, "hybrid", 0, healthTracker, tokenTracker, 0);
+      // Account 1 should win despite stickiness bonus because account 0 is very degraded
+      expect(result?.index).toBe(1);
+    });
+  });
+
+  // Default/unknown strategy
+  it("falls back to first available for unknown strategy", () => {
+    const candidates = [makeCandidate({ index: 0 }), makeCandidate({ index: 1 })];
+    const result = selectAccount(candidates, "unknown", null, healthTracker, tokenTracker, 0);
+    expect(result?.index).toBe(0);
+  });
+});

package/lib/storage.mjs

@@ -0,0 +1,265 @@
+import { promises as fs } from "node:fs";
+import { existsSync, readFileSync, appendFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { getConfigDir } from "./config.mjs";
+
+/**
+ * @typedef {object} AccountStats
+ * @property {number} requests
+ * @property {number} inputTokens
+ * @property {number} outputTokens
+ * @property {number} cacheReadTokens
+ * @property {number} cacheWriteTokens
+ * @property {number} lastReset
+ */
+
+/**
+ * @typedef {object} AccountMetadata
+ * @property {string} id
+ * @property {string} [email]
+ * @property {string} refreshToken
+ * @property {string} [access]
+ * @property {number} [expires]
+ * @property {number} addedAt
+ * @property {number} lastUsed
+ * @property {boolean} enabled
+ * @property {Record<string, number>} rateLimitResetTimes
+ * @property {number} consecutiveFailures
+ * @property {number | null} lastFailureTime
+ * @property {string} [lastSwitchReason]
+ * @property {AccountStats} stats
+ */
+
+/**
+ * @typedef {object} AccountStorage
+ * @property {number} version
+ * @property {AccountMetadata[]} accounts
+ * @property {number} activeIndex
+ */
+
+const CURRENT_VERSION = 1;
+
+/**
+ * Create a fresh stats object.
+ * @param {number} [now]
+ * @returns {AccountStats}
+ */
+export function createDefaultStats(now) {
+  return {
+    requests: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    lastReset: now ?? Date.now(),
+  };
+}
+
+/**
+ * Validate and normalise a stats object, filling in missing fields.
+ * @param {unknown} raw
+ * @param {number} now
+ * @returns {AccountStats}
+ */
+function validateStats(raw, now) {
+  if (!raw || typeof raw !== "object") return createDefaultStats(now);
+  const s = /** @type {Record<string, unknown>} */ (raw);
+  const safeNum = (/** @type {unknown} */ v) =>
+    typeof v === "number" && Number.isFinite(v) && v >= 0 ? Math.floor(v) : 0;
+  return {
+    requests: safeNum(s.requests),
+    inputTokens: safeNum(s.inputTokens),
+    outputTokens: safeNum(s.outputTokens),
+    cacheReadTokens: safeNum(s.cacheReadTokens),
+    cacheWriteTokens: safeNum(s.cacheWriteTokens),
+    lastReset: typeof s.lastReset === "number" && Number.isFinite(s.lastReset) ? s.lastReset : now,
+  };
+}
+
+const GITIGNORE_ENTRIES = [".gitignore", "anthropic-accounts.json", "anthropic-accounts.json.*.tmp"];
+
+/**
+ * Get the path to the accounts storage file.
+ * @returns {string}
+ */
+export function getStoragePath() {
+  return join(getConfigDir(), "anthropic-accounts.json");
+}
+
+/**
+ * Ensure .gitignore in the config directory includes our files.
+ * @param {string} configDir
+ */
+export function ensureGitignore(configDir) {
+  const gitignorePath = join(configDir, ".gitignore");
+  try {
+    let content = "";
+    /** @type {string[]} */
+    let existingLines = [];
+
+    if (existsSync(gitignorePath)) {
+      content = readFileSync(gitignorePath, "utf-8");
+      existingLines = content.split("\n").map((line) => line.trim());
+    }
+
+    const missingEntries = GITIGNORE_ENTRIES.filter((entry) => !existingLines.includes(entry));
+
+    if (missingEntries.length === 0) return;
+
+    if (content === "") {
+      writeFileSync(gitignorePath, missingEntries.join("\n") + "\n", "utf-8");
+    } else {
+      const suffix = content.endsWith("\n") ? "" : "\n";
+      appendFileSync(gitignorePath, suffix + missingEntries.join("\n") + "\n", "utf-8");
+    }
+  } catch {
+    // Ignore gitignore errors
+  }
+}
+
+/**
+ * Deduplicate accounts by refresh token, keeping the most recently used.
+ * @param {AccountMetadata[]} accounts
+ * @returns {AccountMetadata[]}
+ */
+export function deduplicateByRefreshToken(accounts) {
+  /** @type {Map<string, AccountMetadata>} */
+  const tokenMap = new Map();
+
+  for (const acc of accounts) {
+    if (!acc.refreshToken) continue;
+    const existing = tokenMap.get(acc.refreshToken);
+    if (!existing || (acc.lastUsed || 0) > (existing.lastUsed || 0)) {
+      tokenMap.set(acc.refreshToken, acc);
+    }
+  }
+
+  return Array.from(tokenMap.values());
+}
+
+/**
+ * Validate a single account entry.
+ * @param {unknown} raw
+ * @param {number} now
+ * @returns {AccountMetadata | null}
+ */
+function validateAccount(raw, now) {
+  if (!raw || typeof raw !== "object") return null;
+  const acc = /** @type {Record<string, unknown>} */ (raw);
+
+  if (typeof acc.refreshToken !== "string" || !acc.refreshToken) return null;
+
+  const addedAt = typeof acc.addedAt === "number" && Number.isFinite(acc.addedAt) ? acc.addedAt : now;
+
+  const id = typeof acc.id === "string" && acc.id ? acc.id : `${addedAt}:${acc.refreshToken.slice(0, 12)}`;
+
+  return {
+    id,
+    email: typeof acc.email === "string" ? acc.email : undefined,
+    refreshToken: acc.refreshToken,
+    access: typeof acc.access === "string" ? acc.access : undefined,
+    expires: typeof acc.expires === "number" && Number.isFinite(acc.expires) ? acc.expires : undefined,
+    addedAt,
+    lastUsed: typeof acc.lastUsed === "number" && Number.isFinite(acc.lastUsed) ? acc.lastUsed : 0,
+    enabled: acc.enabled !== false,
+    rateLimitResetTimes:
+      acc.rateLimitResetTimes && typeof acc.rateLimitResetTimes === "object" && !Array.isArray(acc.rateLimitResetTimes)
+        ? /** @type {Record<string, number>} */ (acc.rateLimitResetTimes)
+        : {},
+    consecutiveFailures:
+      typeof acc.consecutiveFailures === "number" ? Math.max(0, Math.floor(acc.consecutiveFailures)) : 0,
+    lastFailureTime: typeof acc.lastFailureTime === "number" ? acc.lastFailureTime : null,
+    lastSwitchReason: typeof acc.lastSwitchReason === "string" ? acc.lastSwitchReason : undefined,
+    stats: validateStats(acc.stats, now),
+  };
+}
+
+/**
+ * Load accounts from disk.
+ * @returns {Promise<AccountStorage | null>}
+ */
+export async function loadAccounts() {
+  const storagePath = getStoragePath();
+
+  try {
+    const content = await fs.readFile(storagePath, "utf-8");
+    const data = JSON.parse(content);
+
+    if (!data || typeof data !== "object" || !Array.isArray(data.accounts)) {
+      return null;
+    }
+
+    if (data.version !== CURRENT_VERSION) {
+      // Future: handle migrations here
+      return null;
+    }
+
+    const now = Date.now();
+    const accounts = data.accounts
+      .map((raw) => validateAccount(raw, now))
+      .filter(/** @returns {acc is AccountMetadata} */ (acc) => acc !== null);
+
+    const deduped = deduplicateByRefreshToken(accounts);
+
+    let activeIndex = typeof data.activeIndex === "number" && Number.isFinite(data.activeIndex) ? data.activeIndex : 0;
+
+    if (deduped.length > 0) {
+      activeIndex = Math.max(0, Math.min(activeIndex, deduped.length - 1));
+    } else {
+      activeIndex = 0;
+    }
+
+    return {
+      version: CURRENT_VERSION,
+      accounts: deduped,
+      activeIndex,
+    };
+  } catch (error) {
+    const code = /** @type {NodeJS.ErrnoException} */ (error).code;
+    if (code === "ENOENT") return null;
+    return null;
+  }
+}
+
+/**
+ * Save accounts to disk atomically.
+ * @param {AccountStorage} storage
+ * @returns {Promise<void>}
+ */
+export async function saveAccounts(storage) {
+  const storagePath = getStoragePath();
+  const configDir = dirname(storagePath);
+
+  await fs.mkdir(configDir, { recursive: true });
+  ensureGitignore(configDir);
+
+  const tempPath = `${storagePath}.${randomBytes(6).toString("hex")}.tmp`;
+  const content = JSON.stringify(storage, null, 2);
+
+  try {
+    await fs.writeFile(tempPath, content, { encoding: "utf-8", mode: 0o600 });
+    await fs.rename(tempPath, storagePath);
+  } catch (error) {
+    try {
+      await fs.unlink(tempPath);
+    } catch {
+      // Ignore cleanup errors
+    }
+    throw error;
+  }
+}
+
+/**
+ * Clear all accounts from disk.
+ * @returns {Promise<void>}
+ */
+export async function clearAccounts() {
+  const storagePath = getStoragePath();
+  try {
+    await fs.unlink(storagePath);
+  } catch (error) {
+    const code = /** @type {NodeJS.ErrnoException} */ (error).code;
+    if (code !== "ENOENT") throw error;
+  }
+}