@juspay/neurolink 9.86.4 → 9.86.5

package/dist/lib/proxy/tokenRefresh.js

@@ -1,16 +1,25 @@
 import { logger } from "../utils/logger.js";
 import { tokenStore } from "../auth/tokenStore.js";
+import { writeJsonSnapshotAtomically } from "./snapshotPersistence.js";
 const REFRESH_URL = "https://api.anthropic.com/v1/oauth/token";
 const REFRESH_URL_FALLBACK = "https://console.anthropic.com/v1/oauth/token";
 const CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
-const BUFFER_MS = 60 * 60 * 1000;
+const BUFFER_MS = 5 * 60 * 1000;
+const SUCCESS_CACHE_MS = 60_000;
 const USER_AGENT = "claude-cli/2.1.80 (external, cli)";
+const refreshesInFlight = new Map();
 export function needsRefresh(account) {
     return !!(account.expiresAt &&
         account.expiresAt <= Date.now() + BUFFER_MS &&
         account.refreshToken);
 }
-export async function refreshToken(account) {
+function isRefreshCredentialRejection(status) {
+    return status === 400 || status === 401 || status === 403 || status === 404;
+}
+export function isPermanentRefreshFailure(result) {
+    return isRefreshCredentialRejection(result.status);
+}
+async function performTokenRefresh(account) {
     if (!account.refreshToken) {
         return { success: false, error: "No refresh token available" };
     }
@@ -24,6 +33,7 @@ export async function refreshToken(account) {
         "User-Agent": USER_AGENT,
     };
     const urls = [REFRESH_URL, REFRESH_URL_FALLBACK];
+    let terminalFailure;
     for (const url of urls) {
         try {
             const resp = await fetch(url, {
@@ -38,21 +48,26 @@ export async function refreshToken(account) {
                     status: resp.status,
                     error: errorBody.slice(0, 500),
                 });
-                // If primary URL returned a non-ok status, try fallback
+                const failure = {
+                    success: false,
+                    error: errorBody,
+                    status: resp.status,
+                };
+                if (isRefreshCredentialRejection(resp.status)) {
+                    terminalFailure = failure;
+                }
+                // If primary URL returned a non-ok status, try fallback.
                 if (url === REFRESH_URL) {
                     continue;
                 }
-                return { success: false, error: errorBody, status: resp.status };
+                return terminalFailure ?? failure;
             }
             const data = (await resp.json());
-            const previousExpiresAt = account.expiresAt;
             account.token = data.access_token;
             account.expiresAt =
                 data.expires_in !== undefined
                     ? Date.now() + data.expires_in * 1000
-                    : previousExpiresAt && previousExpiresAt > Date.now()
-                        ? previousExpiresAt
-                        : Date.now() + 55 * 60 * 1000;
+                    : Date.now() + 55 * 60 * 1000;
             if (data.refresh_token) {
                 account.refreshToken = data.refresh_token;
             }
@@ -67,11 +82,77 @@ export async function refreshToken(account) {
             if (url === REFRESH_URL) {
                 continue;
             }
-            return { success: false, error: String(e) };
+            return terminalFailure ?? { success: false, error: String(e) };
         }
     }
     // Should not reach here, but guard against empty urls array
-    return { success: false, error: "No refresh URLs available" };
+    return (terminalFailure ?? {
+        success: false,
+        error: "No refresh URLs available",
+    });
+}
+/**
+ * Serialize refreshes by refresh-token value. OAuth refresh tokens may rotate,
+ * so concurrent refreshes with the same old token can make all but the first
+ * request fail with invalid_grant. A short success cache covers callers that
+ * loaded either the old token or the newly rotated token around persistence.
+ */
+export async function refreshToken(account) {
+    if (!account.refreshToken) {
+        return { success: false, error: "No refresh token available" };
+    }
+    const lockKey = account.refreshToken;
+    let sharedPromise = refreshesInFlight.get(lockKey);
+    if (!sharedPromise) {
+        const refreshAccount = { ...account };
+        const createdPromise = performTokenRefresh(refreshAccount).then((result) => {
+            const shared = {
+                result,
+                token: refreshAccount.token,
+                refreshToken: refreshAccount.refreshToken,
+                expiresAt: refreshAccount.expiresAt,
+            };
+            if (result.success) {
+                const cachedKeys = new Set([lockKey]);
+                const rotatedKey = refreshAccount.refreshToken;
+                if (rotatedKey &&
+                    rotatedKey !== lockKey &&
+                    !refreshesInFlight.has(rotatedKey)) {
+                    refreshesInFlight.set(rotatedKey, createdPromise);
+                    cachedKeys.add(rotatedKey);
+                }
+                const timer = setTimeout(() => {
+                    for (const key of cachedKeys) {
+                        if (refreshesInFlight.get(key) === createdPromise) {
+                            refreshesInFlight.delete(key);
+                        }
+                    }
+                }, SUCCESS_CACHE_MS);
+                timer.unref?.();
+            }
+            else if (refreshesInFlight.get(lockKey) === createdPromise) {
+                refreshesInFlight.delete(lockKey);
+            }
+            return shared;
+        }, (error) => {
+            if (refreshesInFlight.get(lockKey) === createdPromise) {
+                refreshesInFlight.delete(lockKey);
+            }
+            throw error;
+        });
+        refreshesInFlight.set(lockKey, createdPromise);
+        sharedPromise = createdPromise;
+    }
+    const shared = await sharedPromise;
+    if (shared.result.success) {
+        account.token = shared.token;
+        account.refreshToken = shared.refreshToken;
+        account.expiresAt = shared.expiresAt;
+    }
+    return shared.result;
+}
+export function clearRefreshStateForTests() {
+    refreshesInFlight.clear();
 }
 export async function persistTokens(target, account) {
     if (typeof target !== "string" && "providerKey" in target) {
@@ -92,11 +173,7 @@ async function persistLegacyCredentials(credPath, account) {
             refreshToken: account.refreshToken,
         };
         existing.updatedAt = Date.now();
-        const tmpPath = credPath + ".tmp";
-        await fs.writeFile(tmpPath, JSON.stringify(existing, null, 2), {
-            mode: 0o600,
-        });
-        await fs.rename(tmpPath, credPath);
+        await writeJsonSnapshotAtomically(credPath, existing, 0o600);
     }
     catch (err) {
         logger.warn("[token-refresh] Failed to persist legacy credentials", {

package/dist/lib/proxy/updateState.js

@@ -9,6 +9,7 @@
 import fs from "fs";
 import os from "os";
 import path from "path";
+import { randomUUID } from "node:crypto";
 // ============================================
 // Constants
 // ============================================
@@ -92,10 +93,22 @@ export function loadUpdateState(stateFilePath) {
 export function saveUpdateState(state, stateFilePath) {
     const filePath = resolveStatePath(stateFilePath);
     ensureParentDir(filePath);
-    // Atomic write: write to temp file then rename to prevent corruption on crash
-    const tmpPath = filePath + ".tmp";
-    fs.writeFileSync(tmpPath, JSON.stringify(state, null, 2));
-    fs.renameSync(tmpPath, filePath);
+    // A process-unique temp path prevents concurrent update checks from renaming
+    // each other's file. The guard is single-owner now, but this also keeps
+    // explicit update commands safe when they overlap.
+    const tmpPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        fs.writeFileSync(tmpPath, JSON.stringify(state, null, 2), { mode: 0o600 });
+        fs.renameSync(tmpPath, filePath);
+    }
+    finally {
+        try {
+            fs.rmSync(tmpPath, { force: true });
+        }
+        catch {
+            // Best-effort cleanup after a successful rename or interrupted write.
+        }
+    }
 }
 /**
  * Check whether a version is currently suppressed (i.e., suppressed AND within the 24-hour window).

package/dist/lib/server/routes/claudeProxyRoutes.d.ts

@@ -11,7 +11,8 @@
  */
 import { buildTranslationOptions } from "../../proxy/proxyTranslationEngine.js";
 import type { ModelRouter } from "../../proxy/modelRouter.js";
-import type { AccountCooldownPlan, AccountQuota, ParsedClaudeError, ProxyPassthroughAccount, RouteGroup, RuntimeAccountState } from "../../types/index.js";
+import { isPermanentRefreshFailure } from "../../proxy/tokenRefresh.js";
+import type { AccountAllowlist, AccountCooldownPlan, AccountQuota, ParsedClaudeError, ProxyPassthroughAccount, RouteGroup, RuntimeAccountState, StreamTerminalOutcome } from "../../types/index.js";
 /** Resolve the configured primary's stable key to its current index in the
  *  request's enabledAccounts list. Returns 0 (insertion-order fallback) when
  *  no key is configured or the key cannot be matched (account disabled/
@@ -43,7 +44,7 @@ declare function resetEpochToMs(resetEpoch: number | undefined, now: number): nu
  * burst / acceleration limit) is transient: honor retry-after as a floor,
  * allow a couple of jittered same-account retries, then a short cooldown.
  */
-declare function planCooldownFor429(quota: AccountQuota | null, retryAfterMs: number, now: number): AccountCooldownPlan;
+declare function planCooldownFor429(quota: AccountQuota | null, retryAfterMs: number, now: number, unifiedStatus?: string | undefined): AccountCooldownPlan;
 /**
  * Seed each account's runtime quota from the persisted snapshots in
  * ~/.neurolink/account-quotas.json (keyed by label). Runtime state is
@@ -72,6 +73,15 @@ declare function seedRuntimeQuotasFromDisk(accounts: ProxyPassthroughAccount[]):
  * last resort.
  */
 declare function orderAccountsByQuota(accounts: ProxyPassthroughAccount[], now: number): ProxyPassthroughAccount[];
+declare function trackUpstreamReadableStream(source: ReadableStream<Uint8Array>): {
+    stream: ReadableStream<Uint8Array>;
+    outcome: Promise<StreamTerminalOutcome>;
+};
+declare function getStreamFailureDetails(outcome: StreamTerminalOutcome): {
+    status: number;
+    errorType: string;
+    message: string;
+} | undefined;
 /**
  * Create Claude-compatible proxy routes.
  *
@@ -82,7 +92,7 @@ declare function orderAccountsByQuota(accounts: ProxyPassthroughAccount[], now:
  * @param basePath    - Base path prefix (default: "" since Claude API uses /v1/...).
  * @returns RouteGroup with Claude-compatible endpoints.
  */
-export declare function createClaudeProxyRoutes(modelRouter?: ModelRouter, basePath?: string, accountStrategy?: "round-robin" | "fill-first", passthroughMode?: boolean, primaryAccountKey?: string): RouteGroup;
+export declare function createClaudeProxyRoutes(modelRouter?: ModelRouter, basePath?: string, accountStrategy?: "round-robin" | "fill-first", passthroughMode?: boolean, primaryAccountKey?: string, accountAllowlist?: AccountAllowlist): RouteGroup;
 export declare function getTransientSameAccountRetryDelayMs(retryNumber: number): number;
 /**
  * Parse a Claude error payload when available.
@@ -107,12 +117,17 @@ export declare const __testHooks: {
     resolveHomeIndex: typeof resolveHomeIndex;
     maybeResetPrimaryToHome: typeof maybeResetPrimaryToHome;
     planCooldownFor429: typeof planCooldownFor429;
+    isPermanentRefreshFailure: typeof isPermanentRefreshFailure;
+    getStreamFailureDetails: typeof getStreamFailureDetails;
+    trackUpstreamReadableStream: typeof trackUpstreamReadableStream;
     orderAccountsByQuota: typeof orderAccountsByQuota;
     resetEpochToMs: typeof resetEpochToMs;
     seedRuntimeQuotasFromDisk: typeof seedRuntimeQuotasFromDisk;
     getAccountRuntimeState: (key: string) => RuntimeAccountState | undefined;
     setConfiguredPrimaryAccountKey: (key: string | undefined) => void;
     getConfiguredPrimaryAccountKey: () => string | undefined;
+    setConfiguredAccountAllowlist: (allowlist: AccountAllowlist | undefined) => void;
+    getConfiguredAccountAllowlist: () => string[] | undefined;
     setPrimaryAccountIndex: (index: number) => void;
     getPrimaryAccountIndex: () => number;
     setAccountRuntimeState: (key: string, state: Partial<RuntimeAccountState>) => void;