dsh-cliproxyapi-pro 1.7.0 → 1.9.0

package/lib/quota.js

@@ -16,8 +16,39 @@ export const DEFAULT_QUOTA_TIMEOUT_MS = 15_000;
 export const DEFAULT_QUOTA_CONCURRENCY = 4;
 export const MAX_QUOTA_RESPONSE_BYTES = 4 * 1024 * 1024;
 
+// Consecutive management 401/403 answers after which automatic refresh stops
+// (CPA bans the client address for 30 minutes after 5 failed attempts).
+export const AUTH_FAILURE_LIMIT = 3;
+export const QUOTA_AUTH_STATE_VERSION = 1;
+
 const MANAGEMENT_KEY_REF = "CLI_PROXY_MANAGEMENT_KEY";
 const STATUS_MESSAGE_MAX = 160;
+const AUTH_ERROR_CODES = ["unauthorized", "forbidden"];
+const AUTH_ACCOUNT_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
+
+/**
+ * The persisted management-key failure counts (`quota-state.json`):
+ * `{ version: 1, accounts: { [id]: { authFailures, errorCode, errorStatus?, failedAt } } }`.
+ * Never holds a key. Invalid entries are dropped; accounts without failures are not kept.
+ */
+export function normalizeQuotaAuthState(raw) {
+  const accounts = {};
+  const input = raw !== null && typeof raw === "object" && !Array.isArray(raw) ? raw.accounts : undefined;
+  if (input !== null && typeof input === "object" && !Array.isArray(input)) {
+    for (const [id, entry] of Object.entries(input)) {
+      if (!AUTH_ACCOUNT_ID.test(id) || entry === null || typeof entry !== "object") continue;
+      const failures = Number.isInteger(entry.authFailures) && entry.authFailures > 0 ? Math.min(entry.authFailures, 1000) : 0;
+      if (failures === 0) continue;
+      accounts[id] = {
+        authFailures: failures,
+        errorCode: AUTH_ERROR_CODES.includes(entry.errorCode) ? entry.errorCode : "unauthorized",
+        ...(Number.isInteger(entry.errorStatus) ? { errorStatus: entry.errorStatus } : {}),
+        ...(typeof entry.failedAt === "string" && entry.failedAt.length <= 40 ? { failedAt: entry.failedAt } : {}),
+      };
+    }
+  }
+  return { version: QUOTA_AUTH_STATE_VERSION, accounts };
+}
 
 const UPSTREAM = {
   codexUsage: "https://chatgpt.com/backend-api/wham/usage",
@@ -1053,14 +1084,53 @@ export function createQuotaController(deps) {
   const agPreferred = new Map();
   let disposed = false;
 
+  // Consecutive management 401/403 counts survive reloads through
+  // `deps.authStore` ({ read(), write(state) }); without one they live in memory.
+  const readAuth = () => {
+    try {
+      return normalizeQuotaAuthState(deps.authStore?.read?.());
+    } catch {
+      return normalizeQuotaAuthState(undefined);
+    }
+  };
+  const writeAuthEntry = (id, entry) => {
+    if (deps.authStore?.write === undefined) return;
+    try {
+      const next = readAuth();
+      if (entry === undefined) {
+        if (next.accounts[id] === undefined) return;
+        delete next.accounts[id];
+      } else {
+        next.accounts[id] = entry;
+      }
+      deps.authStore.write(normalizeQuotaAuthState(next));
+    } catch (error) {
+      log("warn", `dsh-cliproxyapi: could not save the quota key failure count: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  };
+
   const stateFor = (id) => {
     let st = states.get(id);
     if (st === undefined) {
-      st = { gen: 0, inflight: null, result: null, data: null, lockedOut: false, lastAttemptAt: undefined };
+      const saved = readAuth().accounts[id];
+      st = {
+        gen: 0,
+        inflight: null,
+        result: saved === undefined ? null : { state: "error", errorCode: saved.errorCode, ...(saved.errorStatus === undefined ? {} : { errorStatus: saved.errorStatus }) },
+        data: null,
+        authFailures: saved?.authFailures ?? 0,
+        lastAttemptAt: undefined,
+      };
       states.set(id, st);
     }
     return st;
   };
+  const authPaused = (st) => st.authFailures >= AUTH_FAILURE_LIMIT;
+  /** Forget an account's failure count (a new key, a cleared key, a removed account). */
+  const resetAuth = (id, st = states.get(id)) => {
+    if (st !== undefined) st.authFailures = 0;
+    writeAuthEntry(id, undefined);
+  };
 
   const log = (level, message) => {
     try {
@@ -1479,15 +1549,30 @@ export function createQuotaController(deps) {
           const fetchedAt = new Date(now()).toISOString();
           st.data = { credentials: result.credentials, fetchedAt };
           st.result = { state: "ok" };
-          st.lockedOut = false;
+          if (st.authFailures > 0) resetAuth(account.id, st);
         }
       } catch (error) {
         if (!current()) return;
         const code = error instanceof QuotaError && error.code !== "aborted" ? error.code : error?.code === "aborted" ? null : "network";
         if (code === null) return;
         st.result = { state: "error", errorCode: code, ...(error?.status === undefined ? {} : { errorStatus: error.status }) };
-        if (code === "unauthorized" || code === "forbidden") st.lockedOut = true;
-        log("warn", `dsh-cliproxyapi: quota refresh failed for account ${account.id}: ${code}${error?.status === undefined ? "" : ` (${error.status})`}`);
+        // Only a rejected key counts; network errors neither count nor reset.
+        if (AUTH_ERROR_CODES.includes(code)) {
+          st.authFailures += 1;
+          writeAuthEntry(account.id, {
+            authFailures: st.authFailures,
+            errorCode: code,
+            ...(error?.status === undefined ? {} : { errorStatus: error.status }),
+            failedAt: new Date(now()).toISOString(),
+          });
+        }
+        log(
+          "warn",
+          `dsh-cliproxyapi: quota refresh failed for account ${account.id}: ${code}${error?.status === undefined ? "" : ` (${error.status})`}` +
+            (AUTH_ERROR_CODES.includes(code)
+              ? ` — management key rejected ${st.authFailures}/${AUTH_FAILURE_LIMIT}${authPaused(st) ? "; automatic refresh stopped" : ""}`
+              : "")
+        );
       } finally {
         root.signal.removeEventListener("abort", onRootAbort);
         if (st.gen === gen) {
@@ -1532,6 +1617,9 @@ export function createQuotaController(deps) {
         ...(state === "error" ? { errorCode: st.result.errorCode, ...(st.result.errorStatus === undefined ? {} : { errorStatus: st.result.errorStatus }) } : {}),
         ...(configured && st.data !== null ? { fetchedAt: st.data.fetchedAt } : {}),
         refreshing,
+        ...(configured && st.authFailures > 0
+          ? { authFailures: st.authFailures, authFailureLimit: AUTH_FAILURE_LIMIT, authPaused: authPaused(st) }
+          : {}),
         credentials: configured && st.data !== null ? structuredClone(st.data.credentials) : [],
         pickerModels,
       };
@@ -1552,6 +1640,8 @@ export function createQuotaController(deps) {
       if (!known.has(id)) {
         cancelInflight(st);
         states.delete(id);
+        // An empty list may be a failed read; keep the stored count then.
+        if (accounts.length > 0) resetAuth(id);
       }
     }
     return Promise.all(accounts.map(async (account) => {
@@ -1568,7 +1658,8 @@ export function createQuotaController(deps) {
         for (const { account, keyConfigured: configured } of prepared) {
           if (account.enabled !== true || !configured) continue;
           const st = stateFor(account.id);
-          if (st.inflight !== null || st.lockedOut) continue;
+          // A key rejected AUTH_FAILURE_LIMIT times in a row is not tried in the background again.
+          if (st.inflight !== null || authPaused(st)) continue;
           if (st.lastAttemptAt !== undefined && at - st.lastAttemptAt < ttlMs) continue;
           startRefresh(account);
         }
@@ -1582,8 +1673,8 @@ export function createQuotaController(deps) {
       if (accountId !== undefined && accountId !== null && accountId !== "") {
         const account = findAccount(accountId);
         if (!disposed) {
-          const st = stateFor(account.id);
-          st.lockedOut = false;
+          // A manual refresh tries once even when paused; the count is kept,
+          // so another rejection pauses again at once (a success resets it).
           if (await keyConfigured(managementKeyRef(account.id))) {
             const running = startRefresh(account);
             if (wait) await running;
@@ -1593,9 +1684,9 @@ export function createQuotaController(deps) {
       }
       const prepared = await prepare();
       if (!disposed) {
-        // Refresh-all never retries a locked-out account; only refresh(id) or saveKey clears a lockout.
+        // Refresh-all never retries a paused account; only refresh(id) tries it once, and a new key resets it.
         await Promise.all(prepared
-          .filter(({ account, keyConfigured: configured }) => account.enabled === true && configured && !stateFor(account.id).lockedOut)
+          .filter(({ account, keyConfigured: configured }) => account.enabled === true && configured && !authPaused(stateFor(account.id)))
           .map(({ account }) => (wait ? startRefresh(account) : (startRefresh(account), undefined))));
       }
       return buildSnapshot(prepared);
@@ -1611,7 +1702,7 @@ export function createQuotaController(deps) {
         await deps.unsetKey(ref);
         st.data = null;
         st.result = null;
-        st.lockedOut = false;
+        resetAuth(account.id, st);
         st.lastAttemptAt = undefined;
         return buildSnapshot();
       }
@@ -1621,16 +1712,27 @@ export function createQuotaController(deps) {
         cancelInflight(st);
         await deps.setKey(ref, value);
         st.result = null;
-        st.lockedOut = false;
+        resetAuth(account.id, st);
       }
       if (!disposed && (await keyConfigured(ref))) {
-        st.lockedOut = false;
         const running = startRefresh(account);
         if (wait) await running;
       }
       return buildSnapshot();
     },
 
+    /**
+     * A credential reference changed outside saveKey (e.g. the DSH credentials
+     * page): when it is an account's management key, forget its failure count.
+     * @returns the account id, or undefined for any other reference.
+     */
+    keyChanged(ref) {
+      const account = listAccounts().find((a) => managementKeyRef(a.id) === ref);
+      if (account === undefined) return undefined;
+      resetAuth(account.id);
+      return account.id;
+    },
+
     dispose() {
       if (disposed) return;
       disposed = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-cliproxyapi-pro",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "description": "Auto-discovery CLIProxyAPI (CPA) provider and management UI for DeepSeek Harness — multiple accounts, dynamic model sync, capability detection, and visual settings.",
   "keywords": [
     "dsh",
@@ -41,6 +41,7 @@
     "lib/client.js",
     "lib/updater.js",
     "lib/quota.js",
+    "lib/media.js",
     "locale/*.json",
     "cordis.patch.yml",
     "icon.svg",
@@ -70,7 +71,7 @@
   },
   "scripts": {
     "test": "node --test tests/*.test.mjs",
-    "check": "node --check lib/index.js && node --check lib/client.js && node --check lib/updater.js && node --check lib/quota.js && node --test tests/*.test.mjs",
+    "check": "node --check lib/index.js && node --check lib/client.js && node --check lib/updater.js && node --check lib/quota.js && node --check lib/media.js && node --test tests/*.test.mjs",
     "pack:check": "npm pack --dry-run"
   }
 }