opencode-anthropic-fix 0.0.25 → 0.0.27

package/lib/accounts.mjs

@@ -1,7 +1,13 @@
+import { createHash } from "node:crypto";
 import { loadAccounts, saveAccounts, createDefaultStats } from "./storage.mjs";
 import { HealthScoreTracker, TokenBucketTracker, selectAccount } from "./rotation.mjs";
 import { calculateBackoffMs } from "./backoff.mjs";
 
+/** QA fix M12: hash token fragment instead of leaking raw prefix */
+function hashTokenFragment(token) {
+  return createHash("sha256").update(token).digest("hex").slice(0, 12);
+}
+
 /**
  * @typedef {import('./config.mjs').AnthropicAuthConfig} AnthropicAuthConfig
  * @typedef {import('./config.mjs').AccountSelectionStrategy} AccountSelectionStrategy
@@ -92,7 +98,7 @@ export class AccountManager {
     // re-bootstrapping from OpenCode auth fallback credentials.
     if (stored) {
       manager.#accounts = stored.accounts.map((acc, index) => ({
-        id: acc.id || `${acc.addedAt}:${acc.refreshToken.slice(0, 12)}`,
+        id: acc.id || `${acc.addedAt}:${hashTokenFragment(acc.refreshToken)}`,
         index,
         email: acc.email,
         refreshToken: acc.refreshToken,
@@ -193,6 +199,15 @@ export class AccountManager {
     return this.#currentIndex;
   }
 
+  /**
+   * Get the health score for a specific account.
+   * @param {number} accountIndex
+   * @returns {number}
+   */
+  getHealthScore(accountIndex) {
+    return this.#healthTracker.getScore(accountIndex);
+  }
+
   /**
    * Force the active account to a specific index.
    * Used by OPENCODE_ANTHROPIC_INITIAL_ACCOUNT to pin a session to one account.
@@ -334,6 +349,36 @@ export class AccountManager {
     this.#tokenTracker.refund(account.index);
   }
 
+  /**
+   * Apply a utilization-based health penalty (proactive, before actual rate limit).
+   * @param {ManagedAccount} account
+   * @param {number} penalty - Points to deduct (0-10 typical)
+   */
+  applyUtilizationPenalty(account, penalty) {
+    if (penalty > 0) {
+      this.#healthTracker.applyPenalty(account.index, penalty);
+    }
+  }
+
+  /**
+   * Handle surpassed rate limit threshold — aggressive penalty and soft cooldown.
+   * @param {ManagedAccount} account
+   * @param {string | null} resetAt - ISO timestamp or null
+   */
+  applySurpassedThreshold(account, resetAt) {
+    // Apply a significant health penalty
+    this.#healthTracker.applyPenalty(account.index, 15);
+
+    // If reset time provided, set a soft cooldown
+    if (resetAt) {
+      const resetTime = new Date(resetAt).getTime();
+      if (!isNaN(resetTime) && resetTime > Date.now()) {
+        const SOFT_COOLDOWN_KEY = "soft_cooldown";
+        account.rateLimitResetTimes[SOFT_COOLDOWN_KEY] = resetTime;
+      }
+    }
+  }
+
   /**
    * Add a new account to the pool.
    * @param {string} refreshToken
@@ -359,7 +404,7 @@ export class AccountManager {
     const now = Date.now();
     /** @type {ManagedAccount} */
     const account = {
-      id: `${now}:${refreshToken.slice(0, 12)}`,
+      id: `${now}:${hashTokenFragment(refreshToken)}`,
       index: this.#accounts.length,
       email,
       refreshToken,
@@ -415,11 +460,10 @@ export class AccountManager {
       }
     }
 
-    // Reset health scores for all accounts since indices shifted after splice.
-    // This is simpler and safer than trying to remap individual scores.
-    for (let i = 0; i < this.#accounts.length; i++) {
-      this.#healthTracker.reset(i);
-    }
+    // Reset both health and token trackers since indices shifted after splice (QA fix H10).
+    // Rebuilding is simpler and safer than trying to remap individual entries.
+    this.#healthTracker = new HealthScoreTracker(this.#config.health_score);
+    this.#tokenTracker = new TokenBucketTracker(this.#config.token_bucket);
     this.requestSaveToDisk();
     return true;
   }
@@ -445,6 +489,10 @@ export class AccountManager {
     this.#accounts = [];
     this.#currentIndex = -1;
     this.#cursor = 0;
+    // QA fix: reset trackers to avoid stale state leaking to new accounts
+    this.#healthTracker = new HealthScoreTracker(this.#config.health_score);
+    this.#tokenTracker = new TokenBucketTracker(this.#config.token_bucket);
+    this.#statsDeltas.clear();
   }
 
   /**
@@ -587,10 +635,20 @@ export class AccountManager {
       activeIndex: Math.max(0, this.#currentIndex),
     };
 
-    await saveAccounts(storage);
+    // QA fix H8: snapshot delta keys before the async write to avoid losing
+    // deltas added during the await. Only delete keys we captured, not new ones.
+    const capturedDeltaKeys = new Set(this.#statsDeltas.keys());
 
-    // Clear deltas after successful write
-    this.#statsDeltas.clear();
+    // QA fix M15: pass pre-loaded disk data to saveAccounts to avoid TOCTOU double-read
+    const preloadedDiskData = diskAccountsById
+      ? { version: 1, accounts: [...diskAccountsById.values()], activeIndex: Math.max(0, this.#currentIndex) }
+      : null;
+    await saveAccounts(storage, preloadedDiskData);
+
+    // Clear only the captured deltas; new ones added during await are preserved
+    for (const key of capturedDeltaKeys) {
+      this.#statsDeltas.delete(key);
+    }
 
     // Update in-memory stats to match what we wrote (so subsequent reads
     // reflect the merged values, not stale pre-merge values)
@@ -630,7 +688,7 @@ export class AccountManager {
         const existing =
           (acc.id && existingById.get(acc.id)) || (!acc.id ? existingByToken.get(acc.refreshToken) : null);
         return {
-          id: acc.id || existing?.id || `${acc.addedAt}:${acc.refreshToken.slice(0, 12)}`,
+          id: acc.id || existing?.id || `${acc.addedAt}:${hashTokenFragment(acc.refreshToken)}`,
           index,
           email: acc.email ?? existing?.email,
           refreshToken: acc.refreshToken,

package/lib/accounts.test.mjs

@@ -356,18 +356,18 @@ describe("AccountManager persistence", () => {
 
   it("saveToDisk calls saveAccounts with correct format", async () => {
     await manager.saveToDisk();
-    expect(saveAccounts).toHaveBeenCalledWith(
-      expect.objectContaining({
-        version: 1,
-        accounts: expect.arrayContaining([
-          expect.objectContaining({
-            refreshToken: "token1",
-            enabled: true,
-          }),
-        ]),
-        activeIndex: expect.any(Number),
-      }),
+    // M15: saveToDisk now passes optional 2nd arg (preloaded disk data)
+    const savedArg = saveAccounts.mock.calls[0][0];
+    expect(savedArg.version).toBe(1);
+    expect(savedArg.accounts).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          refreshToken: "token1",
+          enabled: true,
+        }),
+      ]),
     );
+    expect(typeof savedArg.activeIndex).toBe("number");
   });
 
   it("requestSaveToDisk debounces saves", async () => {
@@ -606,18 +606,18 @@ describe("AccountManager usage stats", () => {
 
     await manager.saveToDisk();
 
-    expect(saveAccounts).toHaveBeenCalledWith(
-      expect.objectContaining({
-        accounts: expect.arrayContaining([
-          expect.objectContaining({
-            stats: expect.objectContaining({
-              requests: 1,
-              inputTokens: 100,
-              outputTokens: 50,
-            }),
+    // M15: saveToDisk now passes optional 2nd arg (preloaded disk data)
+    const savedArg = saveAccounts.mock.calls[0][0];
+    expect(savedArg.accounts).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          stats: expect.objectContaining({
+            requests: 1,
+            inputTokens: 100,
+            outputTokens: 50,
           }),
-        ]),
-      }),
+        }),
+      ]),
     );
   });
 });

package/lib/backoff.mjs

@@ -7,6 +7,31 @@ const AUTH_FAILED_BACKOFF = 5_000;
 const RATE_LIMIT_EXCEEDED_BACKOFF = 30_000;
 const MIN_BACKOFF_MS = 2_000;
 
+/**
+ * Parse the retry-after-ms header from a response.
+ * Returns milliseconds directly (no conversion needed).
+ * @param {Response} response
+ * @returns {number | null}
+ */
+export function parseRetryAfterMsHeader(response) {
+  const header = response.headers.get("retry-after-ms");
+  if (!header) return null;
+  const ms = parseFloat(header);
+  return !isNaN(ms) && ms > 0 ? ms : null;
+}
+
+/**
+ * Parse the x-should-retry header from a response.
+ * @param {Response} response
+ * @returns {boolean | null} true = force retry, false = force no retry, null = not present
+ */
+export function parseShouldRetryHeader(response) {
+  const header = response.headers.get("x-should-retry");
+  if (header === "true") return true;
+  if (header === "false") return false;
+  return null;
+}
+
 /**
  * Parse the Retry-After header from a response.
  * Supports both seconds (integer) and HTTP-date formats.

package/lib/config.mjs

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { homedir } from "node:os";
+import { randomBytes } from "node:crypto";
 
 /**
  * @typedef {'sticky' | 'round-robin' | 'hybrid'} AccountSelectionStrategy
@@ -44,6 +45,14 @@ import { homedir } from "node:os";
  * @property {number} min_interval_minutes - Minimum minutes between idle refresh attempts per account
  */
 
+/**
+ * @typedef {object} CachePolicyConfig
+ * @property {string} ttl - "1h" (default), "5m", or "off"
+ * @property {boolean} ttl_supported - Auto-set to false if API rejects TTL
+ * @property {boolean} boundary_marker - Inject static/dynamic boundary marker into system prompt (opt-in)
+ * @property {number} hit_rate_warning_threshold - Warn when avg cache hit rate falls below this (0-1). Default: 0.3
+ */
+
 /**
  * @typedef {object} AnthropicAuthConfig
  * @property {AccountSelectionStrategy} account_selection_strategy
@@ -57,6 +66,10 @@ import { homedir } from "node:os";
  * @property {ToastConfig} toasts
  * @property {HeaderConfig} headers
  * @property {IdleRefreshConfig} idle_refresh
+ * @property {CachePolicyConfig} cache_policy
+ * @property {boolean} fast_mode
+ * @property {{emulate_minimal: boolean}} telemetry
+ * @property {boolean} usage_toast
  */
 
 /** @type {AnthropicAuthConfig} */
@@ -98,6 +111,23 @@ export const DEFAULT_CONFIG = {
     window_minutes: 60,
     min_interval_minutes: 30,
   },
+  cache_policy: {
+    ttl: "1h",
+    ttl_supported: true,
+    boundary_marker: false,
+    hit_rate_warning_threshold: 0.3,
+  },
+  fast_mode: false,
+  telemetry: {
+    emulate_minimal: false,
+  },
+  usage_toast: false,
+  headers: {
+    emulation_profile: "",
+    overrides: {},
+    disable: [],
+    billing_header: true,
+  },
 };
 
 export const VALID_STRATEGIES = ["sticky", "round-robin", "hybrid"];
@@ -119,6 +149,10 @@ function createDefaultConfig() {
     token_bucket: { ...DEFAULT_CONFIG.token_bucket },
     toasts: { ...DEFAULT_CONFIG.toasts },
     idle_refresh: { ...DEFAULT_CONFIG.idle_refresh },
+    cache_policy: { ...DEFAULT_CONFIG.cache_policy },
+    fast_mode: DEFAULT_CONFIG.fast_mode,
+    telemetry: { ...DEFAULT_CONFIG.telemetry },
+    headers: { ...DEFAULT_CONFIG.headers, overrides: {}, disable: [] },
   };
 }
 
@@ -293,6 +327,36 @@ function validateConfig(raw) {
     };
   }
 
+  // Cache policy sub-config
+  if (raw.cache_policy && typeof raw.cache_policy === "object") {
+    const cp = /** @type {Record<string, unknown>} */ (raw.cache_policy);
+    const validTtls = ["1h", "5m", "off"];
+    config.cache_policy = {
+      ttl: typeof cp.ttl === "string" && validTtls.includes(cp.ttl) ? cp.ttl : DEFAULT_CONFIG.cache_policy.ttl,
+      ttl_supported:
+        typeof cp.ttl_supported === "boolean" ? cp.ttl_supported : DEFAULT_CONFIG.cache_policy.ttl_supported,
+      boundary_marker:
+        typeof cp.boundary_marker === "boolean" ? cp.boundary_marker : DEFAULT_CONFIG.cache_policy.boundary_marker,
+      hit_rate_warning_threshold:
+        typeof cp.hit_rate_warning_threshold === "number" && Number.isFinite(cp.hit_rate_warning_threshold)
+          ? Math.max(0, Math.min(1, cp.hit_rate_warning_threshold))
+          : DEFAULT_CONFIG.cache_policy.hit_rate_warning_threshold,
+    };
+  }
+
+  // Fast mode
+  config.fast_mode = typeof raw.fast_mode === "boolean" ? raw.fast_mode : false;
+
+  // Telemetry
+  config.telemetry = config.telemetry || {};
+  config.telemetry.emulate_minimal =
+    typeof raw.telemetry?.emulate_minimal === "boolean"
+      ? raw.telemetry.emulate_minimal
+      : DEFAULT_CONFIG.telemetry.emulate_minimal;
+
+  // Usage toast
+  config.usage_toast = typeof raw.usage_toast === "boolean" ? raw.usage_toast : DEFAULT_CONFIG.usage_toast;
+
   return config;
 }
 
@@ -456,7 +520,8 @@ export function saveConfig(updates) {
   const merged = deepMergeConfig(existing, updates);
 
   // Atomic write: temp file + rename
-  const tmpPath = configPath + `.tmp.${process.pid}`;
+  // QA fix M16: use random bytes to avoid collision with same-process concurrent calls
+  const tmpPath = configPath + `.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
   writeFileSync(tmpPath, JSON.stringify(merged, null, 2) + "\n", { encoding: "utf-8", mode: 0o600 });
   renameSync(tmpPath, configPath);
 }