@juspay/neurolink 10.4.2 → 10.4.4

package/dist/proxy/socketWorkerRuntime.js

@@ -8,6 +8,7 @@ function isTransferableProxySocket(handle) {
         typeof candidate.resume === "function" &&
         typeof candidate.destroy === "function" &&
         typeof candidate.end === "function" &&
+        typeof candidate.off === "function" &&
         typeof candidate.once === "function");
 }
 function destroyTransferredHandle(handle) {
@@ -153,6 +154,16 @@ export function attachSocketWorkerProcess(server, input) {
         // synchronously here would truncate that in-flight request.
         setImmediate(() => runtime.drain());
     };
+    const takePendingSocket = (socketId) => {
+        const pending = pendingSockets.get(socketId);
+        if (!pending) {
+            return undefined;
+        }
+        pendingSockets.delete(socketId);
+        pending.socket.off("error", pending.onError);
+        pending.socket.off("close", pending.onClose);
+        return pending.socket;
+    };
     const onMessage = (message, handle) => {
         if (message &&
             typeof message === "object" &&
@@ -176,7 +187,27 @@ export function attachSocketWorkerProcess(server, input) {
                     socket.destroy();
                     return;
                 }
-                pendingSockets.set(socketId, socket);
+                // A client can reset while the transferred handle is paused between
+                // acceptance and commit. The HTTP server has not seen the socket yet,
+                // so it cannot install its normal transport-error handler for us.
+                const onError = () => {
+                    if (pendingSockets.get(socketId)?.socket !== socket) {
+                        return;
+                    }
+                    takePendingSocket(socketId);
+                    socket.destroy();
+                    drainWhenPendingSettled();
+                };
+                const onClose = () => {
+                    if (pendingSockets.get(socketId)?.socket !== socket) {
+                        return;
+                    }
+                    takePendingSocket(socketId);
+                    drainWhenPendingSettled();
+                };
+                pendingSockets.set(socketId, { socket, onError, onClose });
+                socket.once("error", onError);
+                socket.once("close", onClose);
                 try {
                     process.send({
                         type: "proxy-worker:socket-accepted",
@@ -185,14 +216,14 @@ export function attachSocketWorkerProcess(server, input) {
                         socketId,
                     }, (error) => {
                         if (error) {
-                            pendingSockets.delete(socketId);
-                            socket.destroy();
+                            takePendingSocket(socketId)?.destroy();
+                            drainWhenPendingSettled();
                         }
                     });
                 }
                 catch {
-                    pendingSockets.delete(socketId);
-                    socket.destroy();
+                    takePendingSocket(socketId)?.destroy();
+                    drainWhenPendingSettled();
                 }
             }
             else {
@@ -229,11 +260,10 @@ export function attachSocketWorkerProcess(server, input) {
             }
             else if (message.type === "proxy-worker:socket-commit" ||
                 message.type === "proxy-worker:socket-cancel") {
-                const socket = pendingSockets.get(message.socketId);
+                const socket = takePendingSocket(message.socketId);
                 if (!socket) {
                     return;
                 }
-                pendingSockets.delete(message.socketId);
                 if (message.type === "proxy-worker:socket-commit") {
                     runtime.acceptSocket(socket);
                 }
@@ -259,10 +289,9 @@ export function attachSocketWorkerProcess(server, input) {
     // is exiting. The zero-downtime guarantee applies to the rolling handoff
     // (control-message) path, not to process termination.
     const drain = () => {
-        for (const socket of pendingSockets.values()) {
-            socket.destroy();
+        for (const socketId of [...pendingSockets.keys()]) {
+            takePendingSocket(socketId)?.destroy();
         }
-        pendingSockets.clear();
         runtime.drain();
     };
     const onTerminationSignal = () => drain();
@@ -283,10 +312,9 @@ export function attachSocketWorkerProcess(server, input) {
             process.off("disconnect", drain);
             process.off("SIGTERM", onTerminationSignal);
             process.off("SIGINT", onTerminationSignal);
-            for (const socket of pendingSockets.values()) {
-                socket.destroy();
+            for (const socketId of [...pendingSockets.keys()]) {
+                takePendingSocket(socketId)?.destroy();
             }
-            pendingSockets.clear();
             runtime.close();
         },
     };

package/dist/proxy/sseInterceptor.js

@@ -429,7 +429,11 @@ export function createSSEInterceptor(options = {}) {
     // Wrap the writable side so we can intercept abort() — which does NOT
     // trigger the TransformStream's flush() or cancel() callbacks.
     const innerWriter = transform.writable.getWriter();
+    let writableController;
     const writable = new WritableStream({
+        start(controller) {
+            writableController = controller;
+        },
         write(chunk) {
             return innerWriter.write(chunk);
         },
@@ -441,8 +445,50 @@ export function createSSEInterceptor(options = {}) {
             return innerWriter.abort(reason);
         },
     });
+    // Preserve downstream cancellation across the wrapped writable. Without
+    // this bridge, client disconnects leave the upstream source and telemetry
+    // promise open indefinitely after the readable side is cancelled.
+    void innerWriter.closed.catch((reason) => {
+        settle();
+        try {
+            writableController.error(reason);
+        }
+        catch {
+            // The wrapper may already be closing or aborted.
+        }
+    });
+    const innerReader = transform.readable.getReader();
+    const readable = new ReadableStream({
+        async pull(controller) {
+            try {
+                const { done, value } = await innerReader.read();
+                if (done) {
+                    controller.close();
+                }
+                else {
+                    controller.enqueue(value);
+                }
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+        async cancel(reason) {
+            settle();
+            try {
+                writableController.error(reason);
+            }
+            catch {
+                // The wrapper may already be closing or aborted.
+            }
+            await Promise.allSettled([
+                innerReader.cancel(reason),
+                innerWriter.abort(reason),
+            ]);
+        },
+    });
     const stream = {
-        readable: transform.readable,
+        readable,
         writable,
     };
     return { stream, telemetry: telemetryPromise };

package/dist/proxy/tokenRefresh.d.ts

@@ -8,5 +8,11 @@ export declare function isPermanentRefreshFailure(result: RefreshResult): boolea
  * loaded either the old token or the newly rotated token around persistence.
  */
 export declare function refreshToken(account: RefreshableAccount): Promise<RefreshResult>;
+/**
+ * Refreshes against the latest persisted credential generation. Queued
+ * requests can otherwise reject a rotated refresh token and disable a newer
+ * login that was saved while they were waiting.
+ */
+export declare function refreshTokenFromLatest(account: RefreshableAccount, target?: TokenPersistTarget): Promise<RefreshResult>;
 export declare function clearRefreshStateForTests(): void;
 export declare function persistTokens(target: TokenPersistTarget, account: RefreshableAccount): Promise<void>;

package/dist/proxy/tokenRefresh.js

@@ -1,12 +1,14 @@
 import { logger } from "../utils/logger.js";
 import { tokenStore } from "../auth/tokenStore.js";
+import { ANTHROPIC_TOKEN_URL, ANTHROPIC_TOKEN_URL_FALLBACK, CLAUDE_CLI_USER_AGENT, CLAUDE_CODE_CLIENT_ID, } from "../auth/anthropicOAuth.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";
+import { withTimeout } from "../utils/async/withTimeout.js";
+import { redactUrlForError } from "../utils/logSanitize.js";
 const BUFFER_MS = 5 * 60 * 1000;
 const SUCCESS_CACHE_MS = 60_000;
-const USER_AGENT = "claude-cli/2.1.80 (external, cli)";
+// Bound the best-effort persisted-credential reconciliation read so a hung or
+// slow token-store decrypt can never stall (or abort) a live token refresh.
+const PEEK_TOKENS_TIMEOUT_MS = 2_000;
 const refreshesInFlight = new Map();
 export function needsRefresh(account) {
     return !!(account.expiresAt &&
@@ -23,28 +25,33 @@ async function performTokenRefresh(account) {
     if (!account.refreshToken) {
         return { success: false, error: "No refresh token available" };
     }
-    const formBody = new URLSearchParams({
+    // OAuth 2.0 token endpoints require an `application/x-www-form-urlencoded`
+    // request body (RFC 6749 §6); a JSON body is nonstandard for this grant and
+    // is rejected by RFC-compliant endpoints. Mirror the interactive auth flow
+    // in `anthropicOAuth.ts::_refreshAccessToken`.
+    const requestBody = new URLSearchParams({
         grant_type: "refresh_token",
         refresh_token: account.refreshToken,
-        client_id: CLIENT_ID,
+        client_id: CLAUDE_CODE_CLIENT_ID,
     }).toString();
     const headers = {
         "Content-Type": "application/x-www-form-urlencoded",
-        "User-Agent": USER_AGENT,
+        Accept: "application/json",
+        "User-Agent": CLAUDE_CLI_USER_AGENT,
     };
-    const urls = [REFRESH_URL, REFRESH_URL_FALLBACK];
+    const urls = [ANTHROPIC_TOKEN_URL, ANTHROPIC_TOKEN_URL_FALLBACK];
     let terminalFailure;
     for (const url of urls) {
         try {
             const resp = await fetch(url, {
                 method: "POST",
                 headers,
-                body: formBody,
+                body: requestBody,
                 signal: AbortSignal.timeout(10_000),
             });
             if (!resp.ok) {
                 const errorBody = await resp.text();
-                logger.warn(`[token-refresh] failed for ${account.label} at ${url}`, {
+                logger.warn(`[token-refresh] failed for ${account.label} at ${redactUrlForError(url)}`, {
                     status: resp.status,
                     error: errorBody.slice(0, 500),
                 });
@@ -57,7 +64,7 @@ async function performTokenRefresh(account) {
                     terminalFailure = failure;
                 }
                 // If primary URL returned a non-ok status, try fallback.
-                if (url === REFRESH_URL) {
+                if (url === ANTHROPIC_TOKEN_URL) {
                     continue;
                 }
                 return terminalFailure ?? failure;
@@ -75,11 +82,11 @@ async function performTokenRefresh(account) {
             return { success: true };
         }
         catch (e) {
-            logger.warn(`[token-refresh] exception for ${account.label} at ${url}`, {
+            logger.warn(`[token-refresh] exception for ${account.label} at ${redactUrlForError(url)}`, {
                 error: String(e),
             });
             // If primary URL threw, try fallback
-            if (url === REFRESH_URL) {
+            if (url === ANTHROPIC_TOKEN_URL) {
                 continue;
             }
             return terminalFailure ?? { success: false, error: String(e) };
@@ -151,6 +158,54 @@ export async function refreshToken(account) {
     }
     return shared.result;
 }
+async function reloadPersistedTokenStoreAccount(account, target) {
+    if (!target || typeof target === "string" || !("providerKey" in target)) {
+        return false;
+    }
+    // Best-effort, bounded reconciliation: this only adopts a newer persisted
+    // credential generation if one exists. A decryption/IO failure — or a hung
+    // read — must NOT abort the caller, which can still refresh with the
+    // already-loaded token. Swallow the failure and treat it as "no newer
+    // persisted generation found" so refresh proceeds instead of the account
+    // being spuriously disabled.
+    let stored;
+    try {
+        stored = await withTimeout(tokenStore.peekTokens(target.providerKey), PEEK_TOKENS_TIMEOUT_MS, "[token-refresh] peekTokens reconciliation timed out");
+    }
+    catch (err) {
+        logger.debug("[token-refresh] skipping persisted-state reconciliation (peek failed)", { error: err instanceof Error ? err.message : String(err) });
+        return false;
+    }
+    if (!stored ||
+        stored.expiresAt <= (account.expiresAt ?? 0) ||
+        (stored.accessToken === account.token &&
+            stored.refreshToken === account.refreshToken &&
+            stored.expiresAt === account.expiresAt)) {
+        return false;
+    }
+    account.token = stored.accessToken;
+    account.refreshToken = stored.refreshToken;
+    account.expiresAt = stored.expiresAt;
+    return true;
+}
+/**
+ * Refreshes against the latest persisted credential generation. Queued
+ * requests can otherwise reject a rotated refresh token and disable a newer
+ * login that was saved while they were waiting.
+ */
+export async function refreshTokenFromLatest(account, target) {
+    const reloadedBeforeRefresh = await reloadPersistedTokenStoreAccount(account, target);
+    if (reloadedBeforeRefresh && !needsRefresh(account)) {
+        return { success: true };
+    }
+    const result = await refreshToken(account);
+    if (result.success) {
+        return result;
+    }
+    return (await reloadPersistedTokenStoreAccount(account, target))
+        ? { success: true }
+        : result;
+}
 export function clearRefreshStateForTests() {
     refreshesInFlight.clear();
 }
@@ -183,7 +238,7 @@ async function persistLegacyCredentials(credPath, account) {
 }
 async function persistTokenStoreAccount(providerKey, account) {
     try {
-        const existing = await tokenStore.loadTokens(providerKey);
+        const existing = await withTimeout(tokenStore.peekTokens(providerKey), PEEK_TOKENS_TIMEOUT_MS, "[token-refresh] peekTokens for persistence timed out");
         const merged = {
             accessToken: account.token,
             refreshToken: account.refreshToken ?? existing?.refreshToken,
@@ -191,7 +246,7 @@ async function persistTokenStoreAccount(providerKey, account) {
             tokenType: existing?.tokenType ?? "Bearer",
             ...(existing?.scope ? { scope: existing.scope } : {}),
         };
-        await tokenStore.saveTokens(providerKey, merged);
+        await withTimeout(tokenStore.saveTokens(providerKey, merged), PEEK_TOKENS_TIMEOUT_MS, "[token-refresh] saveTokens timed out");
     }
     catch (err) {
         logger.warn("[token-refresh] Failed to persist TokenStore credentials", {

package/dist/proxy/usageStats.d.ts

@@ -5,34 +5,49 @@
  * shared snapshot asynchronously, under a cross-process lock, so overlapping
  * rolling workers cannot overwrite each other's counters.
  */
-import type { AccountStats, ProxyStats, ProxyStatsPersistenceStatus, ProxyUsageStatsStoreOptions } from "../types/index.js";
+import type { AccountStats, ProxyTerminalErrorDetails, ProxyTerminalErrorJournal, ProxyStats, ProxyStatsPersistenceStatus, ProxyUsageStatsSnapshot, ProxyUsageStatsStoreOptions } from "../types/index.js";
 export declare class ProxyUsageStatsStore {
     private readonly now;
     private readonly flushIntervalMs;
     private readonly lockTimeoutMs;
     private readonly staleLockMs;
     private filePath?;
+    private terminalErrorsFilePath?;
     private stats;
     private pending;
+    private terminalErrors;
+    private pendingTerminalErrors;
     private pendingMutations;
     private inFlightMutations;
+    private pendingTerminalErrorMutations;
+    private inFlightTerminalErrorMutations;
     private revision;
+    private terminalErrorsRevision;
     private flushTimer;
     private readonly flushMutex;
     private lastFlushedAt?;
     private lastReconciledAt?;
     private lastRecoveryAt?;
     private lastError?;
+    private terminalErrorsLastFlushedAt?;
+    private terminalErrorsLastRecoveryAt?;
+    private terminalErrorsLastError?;
+    private snapshotVersion;
     constructor(options?: ProxyUsageStatsStoreOptions);
     initialize(filePath?: string): Promise<void>;
     recordAttempt(accountLabel: string, accountType: string): void;
     recordFinalSuccess(accountLabel?: string, accountType?: string): void;
     recordAttemptError(accountLabel: string, accountType: string, status: number, rateLimitKind?: "transient" | "quota"): void;
-    recordFinalError(_status: number, accountLabel?: string, accountType?: string): void;
+    recordFinalError(status: number, accountLabel?: string, accountType?: string, details?: ProxyTerminalErrorDetails): void;
     getStats(): ProxyStats;
     getAccountStats(label: string): AccountStats | undefined;
+    getTerminalErrors(): ProxyTerminalErrorJournal;
+    getUsageSnapshot(): ProxyUsageStatsSnapshot;
     getPersistenceStatus(): ProxyStatsPersistenceStatus;
     flush(): Promise<void>;
+    private persistStatsDelta;
+    private persistTerminalErrorDelta;
+    reconcileUsageSnapshot(): Promise<ProxyUsageStatsSnapshot>;
     reconcile(): Promise<ProxyStats>;
     resetMemory(): void;
     resetForTests(): Promise<void>;
@@ -41,13 +56,18 @@ export declare class ProxyUsageStatsStore {
     private applyFinalSuccess;
     private applyAttemptError;
     private applyFinalError;
+    private applyTerminalError;
     private ensureAccount;
     private scheduleFlush;
     private cancelFlushTimer;
     private readSnapshot;
+    private readTerminalErrorSnapshot;
     private applySnapshot;
+    private applyTerminalErrorSnapshot;
     private recoverCorruptSnapshot;
+    private recoverCorruptTerminalErrorSnapshot;
     private quarantineCorruptSnapshot;
+    private quarantineCorruptTerminalErrorSnapshot;
     private pruneCorruptSnapshots;
     private describeError;
 }
@@ -55,10 +75,12 @@ export declare function initUsageStats(filePath: string): Promise<void>;
 export declare function recordAttempt(accountLabel: string, accountType: string): void;
 export declare function recordFinalSuccess(accountLabel?: string, accountType?: string): void;
 export declare function recordAttemptError(accountLabel: string, accountType: string, status: number, rateLimitKind?: "transient" | "quota"): void;
-export declare function recordFinalError(_status: number, accountLabel?: string, accountType?: string): void;
+export declare function recordFinalError(status: number, accountLabel?: string, accountType?: string, details?: ProxyTerminalErrorDetails): void;
 export declare function getStats(): ProxyStats;
 export declare function getReconciledStats(): Promise<ProxyStats>;
+export declare function getReconciledUsageSnapshot(): Promise<ProxyUsageStatsSnapshot>;
 export declare function getAccountStats(label: string): AccountStats | undefined;
+export declare function getTerminalErrors(): ProxyTerminalErrorJournal;
 export declare function getUsageStatsPersistenceStatus(): ProxyStatsPersistenceStatus;
 export declare function flushUsageStats(): Promise<void>;
 /** Reset process-local counters while intentionally preserving durable state. */