@juspay/neurolink 10.4.2 → 10.4.4

package/dist/lib/proxy/rollingProxyServer.js

@@ -10,8 +10,28 @@ export async function startRollingProxyServer(options) {
     let listening = false;
     let recoveryFailures = 0;
     let recoveryTimer;
+    let requestedReplacementTimer;
+    let requestedReplacementSchedule = 0;
+    let requestedReplacementPending = false;
+    let replacementQueueTail = null;
     const recoveryDelayMs = Math.max(1, options.recoveryDelayMs ?? DEFAULT_RECOVERY_DELAY_MS);
     const maxRecoveryDelayMs = Math.max(recoveryDelayMs, options.maxRecoveryDelayMs ?? DEFAULT_MAX_RECOVERY_DELAY_MS);
+    const queueReplacement = (operation) => {
+        const predecessor = replacementQueueTail;
+        const result = (predecessor ?? Promise.resolve()).then(operation);
+        const completion = result.then(() => undefined, () => undefined);
+        replacementQueueTail = completion;
+        void completion.finally(() => {
+            if (replacementQueueTail !== completion) {
+                return;
+            }
+            replacementQueueTail = null;
+            if (requestedReplacementPending) {
+                scheduleRequestedReplacement();
+            }
+        });
+        return result;
+    };
     const scheduleRecovery = () => {
         if (closing || !listening || recoveryTimer) {
             return;
@@ -23,11 +43,13 @@ export async function startRollingProxyServer(options) {
             // An explicit replace() may have started (or completed) a generation
             // while this timer was pending. Re-validate before recovering so we never
             // launch a duplicate generation that conflicts with the requested worker.
-            const snapshot = supervisor.snapshot();
-            if (closing || snapshot.active || snapshot.candidate) {
-                return;
-            }
-            void supervisor.replace(desiredVersion).then(() => {
+            void queueReplacement(async () => {
+                const snapshot = supervisor.snapshot();
+                if (closing || snapshot.active || snapshot.candidate) {
+                    return;
+                }
+                await supervisor.replace(desiredVersion);
+            }).then(() => {
                 recoveryFailures = 0;
             }, (error) => {
                 recoveryFailures += 1;
@@ -48,6 +70,38 @@ export async function startRollingProxyServer(options) {
             scheduleRecovery();
         }
     };
+    function scheduleRequestedReplacement() {
+        if (closing) {
+            return;
+        }
+        requestedReplacementPending = true;
+        if (requestedReplacementTimer || replacementQueueTail) {
+            return;
+        }
+        const schedule = ++requestedReplacementSchedule;
+        requestedReplacementTimer = setTimeout(() => {
+            requestedReplacementTimer = undefined;
+            if (schedule !== requestedReplacementSchedule) {
+                return;
+            }
+            if (closing || !supervisor.snapshot().active) {
+                return;
+            }
+            requestedReplacementPending = false;
+            const replacementVersion = desiredVersion;
+            void queueReplacement(async () => {
+                if (closing || !supervisor.snapshot().active) {
+                    return;
+                }
+                options.log?.(`[proxy-supervisor] preparing same-version worker replacement version=${replacementVersion} reason=environment`);
+                await supervisor.replace(replacementVersion);
+                options.log?.(`[proxy-supervisor] same-version worker replacement complete version=${replacementVersion} reason=environment`);
+            }).catch((error) => {
+                options.log?.(`[proxy-supervisor] same-version worker replacement failed version=${replacementVersion} reason=environment: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }, 50);
+        requestedReplacementTimer.unref?.();
+    }
     const supervisor = new RollingWorkerSupervisor({
         spawnWorker: options.spawnWorker,
         readyTimeoutMs: options.readyTimeoutMs,
@@ -55,9 +109,14 @@ export async function startRollingProxyServer(options) {
         socketQueueTimeoutMs: options.socketQueueTimeoutMs,
         shutdownTimeoutMs: options.shutdownTimeoutMs,
         onStateChange: stateChanged,
+        onReplacementRequested: scheduleRequestedReplacement,
         log: options.log,
     });
     const listener = createServer({ pauseOnConnect: true }, (socket) => {
+        // The parent keeps its descriptor until the worker commits the IPC
+        // transfer. Consume client resets during that interval so they cannot
+        // terminate the long-lived supervisor process.
+        socket.once("error", () => socket.destroy());
         supervisor.acceptSocket(socket);
     });
     await new Promise((resolve, reject) => {
@@ -89,8 +148,8 @@ export async function startRollingProxyServer(options) {
     }
     const address = listener.address();
     if (!address || typeof address === "string") {
-        listener.close();
-        void supervisor.close();
+        await new Promise((resolve) => listener.close(() => resolve()));
+        await supervisor.close().catch(() => undefined);
         throw ErrorFactory.proxyWorkerLifecycle("rolling proxy listener did not expose a TCP address");
     }
     return {
@@ -111,8 +170,14 @@ export async function startRollingProxyServer(options) {
                 clearTimeout(recoveryTimer);
                 recoveryTimer = undefined;
             }
+            if (requestedReplacementTimer) {
+                clearTimeout(requestedReplacementTimer);
+                requestedReplacementTimer = undefined;
+            }
+            requestedReplacementSchedule += 1;
+            requestedReplacementPending = false;
             try {
-                const snapshot = await supervisor.replace(expectedVersion);
+                const snapshot = await queueReplacement(() => supervisor.replace(expectedVersion));
                 recoveryFailures = 0;
                 return snapshot;
             }
@@ -139,6 +204,12 @@ export async function startRollingProxyServer(options) {
                 clearTimeout(recoveryTimer);
                 recoveryTimer = undefined;
             }
+            if (requestedReplacementTimer) {
+                clearTimeout(requestedReplacementTimer);
+                requestedReplacementTimer = undefined;
+            }
+            requestedReplacementSchedule += 1;
+            requestedReplacementPending = false;
             const listenerClosed = new Promise((resolve, reject) => {
                 listener.close((error) => (error ? reject(error) : resolve()));
             });

package/dist/lib/proxy/rollingWorkerProcess.js

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import { ErrorFactory } from "../utils/errorHandling.js";
 import { isProxyWorkerStatusMessage, PROXY_SOCKET_WORKER_ENV, } from "./rollingWorkerProtocol.js";
 export function spawnProxySocketWorker(options) {
-    const socketAckTimeoutMs = Math.max(1, options.socketAckTimeoutMs ?? 5_000);
+    const socketAckTimeoutMs = Math.max(1, options.socketAckTimeoutMs ?? 30_000);
     let nextSocketId = 0;
     const pendingSockets = new Map();
     const statusListeners = new Set();
@@ -59,6 +59,18 @@ export function spawnProxySocketWorker(options) {
         }
         pendingSockets.delete(socketId);
         clearTimeout(pending.timeout);
+        if (error && child.connected && !pending.accepted) {
+            try {
+                child.send({
+                    type: "proxy-worker:socket-cancel",
+                    generation: options.generation,
+                    socketId,
+                }, () => undefined);
+            }
+            catch {
+                // The supervisor will quarantine the worker after the failed transfer.
+            }
+        }
         if (!error) {
             pending.socket.destroy();
         }
@@ -92,9 +104,14 @@ export function spawnProxySocketWorker(options) {
             publishStatus(message);
         }
     });
-    child.once("exit", () => {
+    child.once("exit", (code, signal) => {
         for (const socketId of [...pendingSockets.keys()]) {
-            settleSocket(socketId, new Error(`proxy worker ${childPid} exited before accepting socket`));
+            settleSocket(socketId, ErrorFactory.proxyWorkerLifecycle(`proxy worker ${childPid} exited before socket transfer committed (code=${code ?? "none"}, signal=${signal ?? "none"})`, {
+                workerPid: childPid,
+                generation: options.generation,
+                exitCode: code,
+                signal,
+            }));
         }
     });
     const sendControl = (message) => {
@@ -117,18 +134,6 @@ export function spawnProxySocketWorker(options) {
             }
             const socketId = `${generation}:${++nextSocketId}`;
             const timeout = setTimeout(() => {
-                if (child.connected) {
-                    try {
-                        child.send({
-                            type: "proxy-worker:socket-cancel",
-                            generation,
-                            socketId,
-                        });
-                    }
-                    catch {
-                        // The worker is terminated after the failed transfer is reported.
-                    }
-                }
                 settleSocket(socketId, new Error(`proxy worker ${childPid} did not accept socket within ${socketAckTimeoutMs}ms`));
             }, socketAckTimeoutMs);
             timeout.unref?.();

package/dist/lib/proxy/rollingWorkerProtocol.js

@@ -38,6 +38,9 @@ export function isProxyWorkerStatusMessage(value) {
     if (message.type === "proxy-worker:socket-accepted") {
         return typeof message.socketId === "string" && message.socketId.length > 0;
     }
+    if (message.type === "proxy-worker:replacement-requested") {
+        return message.reason === "environment";
+    }
     return (message.type === "proxy-worker:fatal" && typeof message.message === "string");
 }
 //# sourceMappingURL=rollingWorkerProtocol.js.map

package/dist/lib/proxy/rollingWorkerSupervisor.d.ts

@@ -34,6 +34,7 @@ export declare class RollingWorkerSupervisor {
     private transferSocket;
     private handleTransferFailure;
     private rejectSocket;
+    private describeTransferError;
     private recordFailure;
     private publishState;
 }

package/dist/lib/proxy/rollingWorkerSupervisor.js

@@ -79,7 +79,6 @@ export class RollingWorkerSupervisor {
                 ? this.replacement
                 : Promise.reject(ErrorFactory.proxyWorkerLifecycle(`worker replacement for v${this.candidate?.expectedVersion ?? "unknown"} is already in progress`, { requestedVersion: expectedVersion }));
         }
-        this.lastFailure = null;
         this.replacement = this.spawnCandidate(expectedVersion).finally(() => {
             this.replacement = null;
         });
@@ -242,6 +241,16 @@ export class RollingWorkerSupervisor {
                     }
                     return;
                 }
+                if (message.type === "proxy-worker:replacement-requested") {
+                    if (this.active?.generation === generation) {
+                        this.options.onReplacementRequested?.({
+                            generation,
+                            pid: handle.pid,
+                            reason: message.reason,
+                        });
+                    }
+                    return;
+                }
                 if (message.type === "proxy-worker:ready") {
                     if (message.version !== expectedVersion) {
                         finish(new Error(`worker ${handle.pid} reported v${message.version}; expected v${expectedVersion}`));
@@ -309,7 +318,7 @@ export class RollingWorkerSupervisor {
                     if (!this.closed) {
                         this.recordFailure(generation, expectedVersion, "runtime", `worker exited (code=${code ?? "none"}, signal=${signal ?? "none"})`);
                     }
-                    this.options.log?.(`[proxy-supervisor] active worker exited generation=${generation} pid=${handle.pid}`);
+                    this.options.log?.(`[proxy-supervisor] active worker exited generation=${generation} pid=${handle.pid} code=${code ?? "none"} signal=${signal ?? "none"}`);
                 }
                 const drained = this.draining.get(generation);
                 if (drained) {
@@ -356,23 +365,27 @@ export class RollingWorkerSupervisor {
         try {
             worker.handle.sendSocket(worker.generation, socket, (error) => {
                 if (error) {
-                    this.handleTransferFailure(worker, socket);
+                    this.handleTransferFailure(worker, socket, error);
                 }
             });
         }
-        catch {
-            this.handleTransferFailure(worker, socket);
+        catch (error) {
+            this.handleTransferFailure(worker, socket, error);
         }
     }
-    handleTransferFailure(worker, socket) {
+    handleTransferFailure(worker, socket, error) {
         this.failedTransfers += 1;
-        this.recordFailure(worker.generation, worker.version, "transfer", `worker ${worker.handle.pid} failed to accept a transferred socket`);
+        const detail = this.describeTransferError(error);
+        this.recordFailure(worker.generation, worker.version, "transfer", `worker ${worker.handle.pid} failed to accept a transferred socket: ${detail}`);
+        this.options.log?.(`[proxy-supervisor] socket transfer failed generation=${worker.generation} pid=${worker.handle.pid}: ${detail}`);
         if (this.active?.generation === worker.generation && !this.closed) {
-            // Do not let worker-side graceful shutdown call shutdown(2) on an
-            // offered-but-uncommitted duplicate descriptor.
-            worker.dispose();
-            worker.handle.terminate("SIGKILL");
             this.active = null;
+            this.draining.set(worker.generation, worker);
+            // The child may own a duplicate of an incompletely transferred socket.
+            // SIGKILL closes its descriptor without worker-side shutdown(2), after
+            // which the parent rejects its copy rather than attempting unsafe replay.
+            worker.handle.terminate("SIGKILL");
+            this.publishState();
         }
         this.rejectSocket(socket);
     }
@@ -381,6 +394,13 @@ export class RollingWorkerSupervisor {
         socket.destroy();
         this.publishState();
     }
+    describeTransferError(error) {
+        if (!(error instanceof Error)) {
+            return String(error ?? "unknown transfer failure");
+        }
+        const code = error.code;
+        return code ? `${code}: ${error.message}` : error.message;
+    }
     recordFailure(generation, version, phase, message) {
         this.lastFailure = {
             at: new Date().toISOString(),

package/dist/lib/proxy/runtimeConfig.d.ts

@@ -10,6 +10,7 @@ export declare class ProxyRuntimeConfigStore {
     private reloadTimer;
     private configFileObserved;
     private envFileObserved;
+    private currentEnvFileHash;
     private readonly watchListener;
     private constructor();
     static create(options: ProxyRuntimeConfigStoreOptions): Promise<ProxyRuntimeConfigStore>;

package/dist/lib/proxy/runtimeConfig.js

@@ -162,11 +162,13 @@ function assertResolvedRoutingValues(value, path = "routing") {
 async function buildCandidate(options, generation, allowMissingConfig, allowMissingEnvFile, rejectInvalidHotEnv) {
     const effectiveEnv = { ...options.baseEnv };
     let envFilePresent = false;
+    let envFileValues = {};
     if (options.envFilePath) {
         try {
-            const envContent = await readFile(options.envFilePath, "utf8");
+            const envFileContent = await readFile(options.envFilePath, "utf8");
             const { parse } = await import("dotenv");
-            Object.assign(effectiveEnv, parse(envContent));
+            envFileValues = parse(envFileContent);
+            Object.assign(effectiveEnv, envFileValues);
             envFilePresent = true;
         }
         catch (error) {
@@ -218,6 +220,12 @@ async function buildCandidate(options, generation, allowMissingConfig, allowMiss
             accountAllowlist: routing.accountAllowlist,
         })
         : undefined;
+    const envFileHash = createHash("sha256")
+        .update(envFilePresent
+        ? JSON.stringify(Object.entries(envFileValues).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0))
+        : "[missing]")
+        .digest("hex")
+        .slice(0, 16);
     const fingerprintSource = JSON.stringify({
         strategy,
         passthrough: options.passthrough,
@@ -249,6 +257,7 @@ async function buildCandidate(options, generation, allowMissingConfig, allowMiss
         }),
         configFilePresent,
         envFilePresent,
+        envFileHash,
     };
 }
 /** Atomic last-known-good runtime configuration with file-triggered reloads. */
@@ -262,6 +271,7 @@ export class ProxyRuntimeConfigStore {
     reloadTimer;
     configFileObserved;
     envFileObserved;
+    currentEnvFileHash;
     watchListener = (current, previous) => {
         if (current.mtimeMs === previous.mtimeMs &&
             current.size === previous.size &&
@@ -270,11 +280,12 @@ export class ProxyRuntimeConfigStore {
         }
         this.scheduleWatchReload();
     };
-    constructor(options, snapshot, configFileObserved, envFileObserved) {
+    constructor(options, snapshot, configFileObserved, envFileObserved, envFileHash) {
         this.options = { ...options, baseEnv: { ...options.baseEnv } };
         this.currentSnapshot = snapshot;
         this.configFileObserved = configFileObserved;
         this.envFileObserved = envFileObserved;
+        this.currentEnvFileHash = envFileHash;
         this.status = {
             configPath: options.configPath,
             ...(options.envFilePath ? { envFilePath: options.envFilePath } : {}),
@@ -287,7 +298,7 @@ export class ProxyRuntimeConfigStore {
     }
     static async create(options) {
         const candidate = await buildCandidate(options, 1, true, true, false);
-        return new ProxyRuntimeConfigStore(options, candidate.snapshot, candidate.configFilePresent, candidate.envFilePresent);
+        return new ProxyRuntimeConfigStore(options, candidate.snapshot, candidate.configFilePresent, candidate.envFilePresent, candidate.envFileHash);
     }
     getSnapshot() {
         return this.currentSnapshot;
@@ -354,7 +365,8 @@ export class ProxyRuntimeConfigStore {
             const candidate = await buildCandidate(this.options, this.currentSnapshot.generation + 1, !this.configFileObserved, !this.envFileObserved, true);
             this.configFileObserved ||= candidate.configFilePresent;
             this.envFileObserved ||= candidate.envFilePresent;
-            if (candidate.snapshot.configHash === this.currentSnapshot.configHash) {
+            if (candidate.snapshot.configHash === this.currentSnapshot.configHash &&
+                candidate.envFileHash === this.currentEnvFileHash) {
                 this.status = {
                     ...this.status,
                     lastReloadAt: attemptedAt,
@@ -369,7 +381,9 @@ export class ProxyRuntimeConfigStore {
                 this.notifyReloadListeners(result);
                 return result;
             }
+            const environmentChanged = candidate.envFileHash !== this.currentEnvFileHash;
             this.currentSnapshot = candidate.snapshot;
+            this.currentEnvFileHash = candidate.envFileHash;
             this.status = {
                 ...this.status,
                 generation: candidate.snapshot.generation,
@@ -392,6 +406,7 @@ export class ProxyRuntimeConfigStore {
                 applied: true,
                 changed: true,
                 generation: candidate.snapshot.generation,
+                ...(environmentChanged ? { environmentChanged: true } : {}),
             };
             this.notifyReloadListeners(result);
             return result;

package/dist/lib/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/lib/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/lib/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>;