@juspay/neurolink 9.93.1 → 9.94.0

package/dist/cli/utils/serverUtils.js

@@ -112,7 +112,10 @@ export class StateFileManager {
         if (!fs.existsSync(dir)) {
             fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
         }
-        fs.writeFileSync(this.filePath, JSON.stringify(state, null, 2));
+        fs.writeFileSync(this.filePath, JSON.stringify(state, null, 2), {
+            mode: 0o600,
+        });
+        fs.chmodSync(this.filePath, 0o600);
     }
     /**
      * Load state from the state file

package/dist/lib/proxy/globalInstaller.js

@@ -14,7 +14,7 @@ function writableDirectory(path) {
         if (!existsSync(path)) {
             return false;
         }
-        accessSync(path, constants.W_OK);
+        accessSync(path, constants.W_OK | constants.X_OK);
         return true;
     }
     catch {

package/dist/lib/proxy/openaiFormat.js

@@ -760,6 +760,7 @@ export function createClaudeToOpenAIStreamTransform(requestModel, options = {})
                 finished = true;
                 options.onError?.(message);
                 emit(controller, serializer.emitError(message));
+                controller.terminate();
                 return;
             }
             default:

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

@@ -0,0 +1,3 @@
+import type { RollingProxyServer, RollingProxyServerOptions } from "../types/index.js";
+/** Keep one public listener stable while serving workers start and rotate. */
+export declare function startRollingProxyServer(options: RollingProxyServerOptions): Promise<RollingProxyServer>;

package/dist/lib/proxy/rollingProxyServer.js

@@ -0,0 +1,149 @@
+import { createServer } from "node:net";
+import { ErrorFactory } from "../utils/errorHandling.js";
+import { RollingWorkerSupervisor } from "./rollingWorkerSupervisor.js";
+const DEFAULT_RECOVERY_DELAY_MS = 250;
+const DEFAULT_MAX_RECOVERY_DELAY_MS = 10_000;
+/** Keep one public listener stable while serving workers start and rotate. */
+export async function startRollingProxyServer(options) {
+    let desiredVersion = options.initialVersion;
+    let closing = false;
+    let listening = false;
+    let recoveryFailures = 0;
+    let recoveryTimer;
+    const recoveryDelayMs = Math.max(1, options.recoveryDelayMs ?? DEFAULT_RECOVERY_DELAY_MS);
+    const maxRecoveryDelayMs = Math.max(recoveryDelayMs, options.maxRecoveryDelayMs ?? DEFAULT_MAX_RECOVERY_DELAY_MS);
+    const scheduleRecovery = () => {
+        if (closing || !listening || recoveryTimer) {
+            return;
+        }
+        const delay = Math.min(maxRecoveryDelayMs, recoveryDelayMs * 2 ** Math.min(recoveryFailures, 8));
+        options.log?.(`[proxy-supervisor] scheduling worker recovery version=${desiredVersion} delayMs=${delay}`);
+        recoveryTimer = setTimeout(() => {
+            recoveryTimer = undefined;
+            // 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(() => {
+                recoveryFailures = 0;
+            }, (error) => {
+                recoveryFailures += 1;
+                options.log?.(`[proxy-supervisor] worker recovery failed: ${error instanceof Error ? error.message : String(error)}`);
+                scheduleRecovery();
+            });
+        }, delay);
+        recoveryTimer.unref?.();
+    };
+    const stateChanged = (snapshot) => {
+        try {
+            options.onStateChange?.(snapshot);
+        }
+        catch (error) {
+            options.log?.(`[proxy-supervisor] failed to publish server state: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (listening && !closing && !snapshot.active && !snapshot.candidate) {
+            scheduleRecovery();
+        }
+    };
+    const supervisor = new RollingWorkerSupervisor({
+        spawnWorker: options.spawnWorker,
+        readyTimeoutMs: options.readyTimeoutMs,
+        socketQueueLimit: options.socketQueueLimit,
+        socketQueueTimeoutMs: options.socketQueueTimeoutMs,
+        shutdownTimeoutMs: options.shutdownTimeoutMs,
+        onStateChange: stateChanged,
+        log: options.log,
+    });
+    const listener = createServer({ pauseOnConnect: true }, (socket) => {
+        supervisor.acceptSocket(socket);
+    });
+    await new Promise((resolve, reject) => {
+        const onError = (error) => {
+            listener.off("listening", onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            listener.off("error", onError);
+            resolve();
+        };
+        listener.once("error", onError);
+        listener.once("listening", onListening);
+        listener.listen(options.port, options.host);
+    }).catch(async (error) => {
+        await supervisor.close();
+        throw error;
+    });
+    listening = true;
+    try {
+        await supervisor.start(desiredVersion);
+    }
+    catch (error) {
+        recoveryFailures = 1;
+        options.log?.(`[proxy-supervisor] initial worker failed; listener will remain available during recovery: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!supervisor.snapshot().active) {
+        scheduleRecovery();
+    }
+    const address = listener.address();
+    if (!address || typeof address === "string") {
+        listener.close();
+        void supervisor.close();
+        throw ErrorFactory.proxyWorkerLifecycle("rolling proxy listener did not expose a TCP address");
+    }
+    return {
+        address: { host: options.host, port: address.port },
+        replace: async (expectedVersion) => {
+            // Adopt the requested version as the recovery target up front (once it is
+            // a valid version string) so the autonomous recovery loop converges on it
+            // even if this explicit call collides with an in-flight recovery
+            // replacement — otherwise recovery keeps re-targeting a stale version and
+            // starves the caller (e.g. an update rollback) for the whole retry window.
+            const isValidVersion = /^\d+\.\d+\.\d+$/.test(expectedVersion);
+            if (isValidVersion) {
+                desiredVersion = expectedVersion;
+            }
+            // Cancel any pending recovery so it cannot race this explicit
+            // replacement and spawn a second, conflicting generation.
+            if (recoveryTimer) {
+                clearTimeout(recoveryTimer);
+                recoveryTimer = undefined;
+            }
+            try {
+                const snapshot = await supervisor.replace(expectedVersion);
+                recoveryFailures = 0;
+                return snapshot;
+            }
+            catch (error) {
+                // The explicit replacement failed (invalid version, closed, or a
+                // conflicting replacement is already in progress). Since we cancelled
+                // the pending recovery timer above, re-schedule recovery when nothing
+                // is serving so a crashed worker is not left unreplaced.
+                const snapshot = supervisor.snapshot();
+                if (!snapshot.active && !snapshot.candidate) {
+                    scheduleRecovery();
+                }
+                throw error;
+            }
+        },
+        snapshot: () => supervisor.snapshot(),
+        close: async () => {
+            if (closing) {
+                return;
+            }
+            closing = true;
+            listening = false;
+            if (recoveryTimer) {
+                clearTimeout(recoveryTimer);
+                recoveryTimer = undefined;
+            }
+            const listenerClosed = new Promise((resolve, reject) => {
+                listener.close((error) => (error ? reject(error) : resolve()));
+            });
+            await Promise.all([listenerClosed, supervisor.close()]);
+        },
+    };
+}
+//# sourceMappingURL=rollingProxyServer.js.map

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

@@ -0,0 +1,2 @@
+import type { RollingWorkerHandle, SpawnProxySocketWorkerOptions } from "../types/index.js";
+export declare function spawnProxySocketWorker(options: SpawnProxySocketWorkerOptions): RollingWorkerHandle;

package/dist/lib/proxy/rollingWorkerProcess.js

@@ -0,0 +1,194 @@
+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);
+    let nextSocketId = 0;
+    const pendingSockets = new Map();
+    const statusListeners = new Set();
+    const pendingStatusMessages = [];
+    let spawnError;
+    const child = spawn(options.command, options.args, {
+        env: {
+            ...process.env,
+            ...options.env,
+            [PROXY_SOCKET_WORKER_ENV]: "1",
+            NEUROLINK_PROXY_WORKER_GENERATION: String(options.generation),
+            NEUROLINK_PROXY_WORKER_EXPECTED_VERSION: options.expectedVersion,
+        },
+        stdio: [
+            "ignore",
+            options.stdout ?? "inherit",
+            options.stderr ?? "inherit",
+            "ipc",
+        ],
+    });
+    const childPid = child.pid;
+    const publishStatus = (message) => {
+        if (statusListeners.size === 0) {
+            if (pendingStatusMessages.length >= 32) {
+                pendingStatusMessages.shift();
+            }
+            pendingStatusMessages.push(message);
+            return;
+        }
+        for (const listener of statusListeners) {
+            listener(message);
+        }
+    };
+    child.once("error", (error) => {
+        spawnError = error;
+        if (!childPid) {
+            return;
+        }
+        publishStatus({
+            type: "proxy-worker:fatal",
+            generation: options.generation,
+            pid: childPid,
+            message: error.message,
+        });
+    });
+    if (!childPid) {
+        child.kill("SIGTERM");
+        throw ErrorFactory.proxyWorkerLifecycle("proxy worker spawn did not return a pid");
+    }
+    const settleSocket = (socketId, error) => {
+        const pending = pendingSockets.get(socketId);
+        if (!pending) {
+            return;
+        }
+        pendingSockets.delete(socketId);
+        clearTimeout(pending.timeout);
+        if (!error) {
+            pending.socket.destroy();
+        }
+        pending.callback(error);
+    };
+    const onInternalMessage = (message) => {
+        if (isProxyWorkerStatusMessage(message) &&
+            message.type === "proxy-worker:socket-accepted" &&
+            message.generation === options.generation &&
+            message.pid === childPid) {
+            const pending = pendingSockets.get(message.socketId);
+            if (!pending || pending.accepted) {
+                return;
+            }
+            pending.accepted = true;
+            try {
+                child.send({
+                    type: "proxy-worker:socket-commit",
+                    generation: options.generation,
+                    socketId: message.socketId,
+                }, (error) => settleSocket(message.socketId, error ?? undefined));
+            }
+            catch (error) {
+                settleSocket(message.socketId, error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+    };
+    child.on("message", (message) => {
+        onInternalMessage(message);
+        if (isProxyWorkerStatusMessage(message)) {
+            publishStatus(message);
+        }
+    });
+    child.once("exit", () => {
+        for (const socketId of [...pendingSockets.keys()]) {
+            settleSocket(socketId, new Error(`proxy worker ${childPid} exited before accepting socket`));
+        }
+    });
+    const sendControl = (message) => {
+        if (!child.connected) {
+            throw new Error(`proxy worker ${childPid} IPC channel is closed`);
+        }
+        child.send(message, (error) => {
+            if (error && child.exitCode === null && child.signalCode === null) {
+                child.kill("SIGTERM");
+            }
+        });
+    };
+    return {
+        pid: childPid,
+        sendControl,
+        sendSocket: (generation, socket, callback) => {
+            if (!child.connected) {
+                callback(new Error(`proxy worker ${childPid} IPC channel is closed`));
+                return;
+            }
+            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?.();
+            pendingSockets.set(socketId, {
+                socket,
+                callback,
+                timeout,
+                accepted: false,
+            });
+            try {
+                child.send({ type: "proxy-worker:socket", generation, socketId }, socket, { keepOpen: true }, (error) => {
+                    if (error) {
+                        settleSocket(socketId, error);
+                    }
+                });
+            }
+            catch (error) {
+                settleSocket(socketId, error instanceof Error ? error : new Error(String(error)));
+            }
+        },
+        terminate: (signal = "SIGTERM") => {
+            if (child.exitCode === null && child.signalCode === null) {
+                child.kill(signal);
+            }
+        },
+        onMessage: (listener) => {
+            statusListeners.add(listener);
+            if (pendingStatusMessages.length > 0) {
+                const buffered = pendingStatusMessages.splice(0);
+                queueMicrotask(() => {
+                    if (statusListeners.has(listener)) {
+                        for (const message of buffered) {
+                            listener(message);
+                        }
+                    }
+                });
+            }
+            else if (spawnError) {
+                const error = spawnError;
+                queueMicrotask(() => {
+                    if (statusListeners.has(listener)) {
+                        listener({
+                            type: "proxy-worker:fatal",
+                            generation: options.generation,
+                            pid: childPid,
+                            message: error.message,
+                        });
+                    }
+                });
+            }
+            return () => statusListeners.delete(listener);
+        },
+        onExit: (listener) => {
+            if (child.exitCode !== null || child.signalCode !== null) {
+                queueMicrotask(() => listener(child.exitCode, child.signalCode));
+                return () => undefined;
+            }
+            child.on("exit", listener);
+            return () => child.off("exit", listener);
+        },
+    };
+}
+//# sourceMappingURL=rollingWorkerProcess.js.map

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

@@ -0,0 +1,5 @@
+import type { ProxyWorkerControlMessage, ProxyWorkerStatusMessage } from "../types/index.js";
+export declare const PROXY_SOCKET_WORKER_ENV = "NEUROLINK_PROXY_SOCKET_WORKER";
+export declare const PROXY_ROLLING_SUPERVISOR_ENV = "NEUROLINK_PROXY_ROLLING_SUPERVISOR";
+export declare function isProxyWorkerControlMessage(value: unknown): value is ProxyWorkerControlMessage;
+export declare function isProxyWorkerStatusMessage(value: unknown): value is ProxyWorkerStatusMessage;

package/dist/lib/proxy/rollingWorkerProtocol.js

@@ -0,0 +1,43 @@
+export const PROXY_SOCKET_WORKER_ENV = "NEUROLINK_PROXY_SOCKET_WORKER";
+export const PROXY_ROLLING_SUPERVISOR_ENV = "NEUROLINK_PROXY_ROLLING_SUPERVISOR";
+export function isProxyWorkerControlMessage(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const message = value;
+    if (!Number.isSafeInteger(message.generation) ||
+        Number(message.generation) <= 0) {
+        return false;
+    }
+    if (message.type === "proxy-worker:socket-commit" ||
+        message.type === "proxy-worker:socket-cancel") {
+        return typeof message.socketId === "string" && message.socketId.length > 0;
+    }
+    return (message.type === "proxy-worker:drain" ||
+        message.type === "proxy-worker:activate" ||
+        message.type === "proxy-worker:shutdown");
+}
+export function isProxyWorkerStatusMessage(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const message = value;
+    if (!Number.isSafeInteger(message.generation) ||
+        Number(message.generation) <= 0 ||
+        !Number.isSafeInteger(message.pid) ||
+        Number(message.pid) <= 0) {
+        return false;
+    }
+    if (message.type === "proxy-worker:ready") {
+        return typeof message.version === "string" && message.version.length > 0;
+    }
+    if (message.type === "proxy-worker:activated" ||
+        message.type === "proxy-worker:drained") {
+        return true;
+    }
+    if (message.type === "proxy-worker:socket-accepted") {
+        return typeof message.socketId === "string" && message.socketId.length > 0;
+    }
+    return (message.type === "proxy-worker:fatal" && typeof message.message === "string");
+}
+//# sourceMappingURL=rollingWorkerProtocol.js.map

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

@@ -0,0 +1,39 @@
+import type { RollingWorkerSupervisorOptions, RollingWorkerSupervisorSnapshot, TransferableProxySocket } from "../types/index.js";
+/**
+ * Owns worker generations while the caller owns the public listening socket.
+ * Sockets are transferred once to the active worker, so response bytes never
+ * traverse a supervisor-side proxy hop.
+ */
+export declare class RollingWorkerSupervisor {
+    private readonly options;
+    private generation;
+    private active;
+    private candidate;
+    private readonly draining;
+    private readonly queuedSockets;
+    private replacement;
+    private rejectedSockets;
+    private failedTransfers;
+    private lastFailure;
+    private closed;
+    private shutdownPromise;
+    private readonly shutdownWaiters;
+    constructor(options: RollingWorkerSupervisorOptions);
+    snapshot(): RollingWorkerSupervisorSnapshot;
+    start(expectedVersion: string): Promise<RollingWorkerSupervisorSnapshot>;
+    replace(expectedVersion: string): Promise<RollingWorkerSupervisorSnapshot>;
+    acceptSocket(socket: TransferableProxySocket): void;
+    private queueSocket;
+    close(): Promise<void>;
+    private closeWorkers;
+    private requestWorkerShutdown;
+    private forceTerminateWorkers;
+    private notifyShutdownWaiters;
+    private spawnCandidate;
+    private flushQueuedSockets;
+    private transferSocket;
+    private handleTransferFailure;
+    private rejectSocket;
+    private recordFailure;
+    private publishState;
+}