@juspay/neurolink 12.14.4 → 12.14.6

package/dist/cli/commands/proxy.d.ts

@@ -11,7 +11,7 @@
  */
 import type { CommandModule } from "yargs";
 import type { Hono } from "hono";
-import type { AccountAllowlist, LoadedProxyConfig, ModelRouterInterface, ProxyGuardArgs, ProxyHealthProbe, ProxyNeurolinkRuntime, ProxyStartArgs, ProxyStartStrategy, ProxySupervisorState, ProxyStatusArgs, ProxyTelemetryArgs, ProxyReadinessState } from "../../types/index.js";
+import type { AccountAllowlist, LoadedProxyConfig, ModelRouterInterface, ProxyGuardArgs, ProxyHealthProbe, ProxyNeurolinkRuntime, ProxyStartArgs, ProxyStartStrategy, ProxyRestartSupervisorState as ProxySupervisorState, ProxyStatusArgs, ProxyTelemetryArgs, ProxyReadinessState } from "../../types/index.js";
 import { ProxyRuntimeConfigStore } from "../../proxy/runtimeConfig.js";
 /**
  * Drop a supervisor `version` that is not a string.

package/dist/cli/commands/proxy.js

@@ -24,6 +24,7 @@ import { describeInstallFailure, getGlobalInstallArgs, isTransientInstallFailure
 import { startUpdaterWorkerSupervisor } from "../../proxy/updaterSupervisor.js";
 import { openProxyWorkerLog } from "../../proxy/workerLog.js";
 import { startRollingProxyServer } from "../../proxy/rollingProxyServer.js";
+import { startProxyRestartControl } from "../../proxy/restartControl.js";
 import { isProxyAuxiliaryRequest } from "../../proxy/proxyRequestKind.js";
 import { spawnProxySocketWorker } from "../../proxy/rollingWorkerProcess.js";
 import { PROXY_ROLLING_SUPERVISOR_ENV, PROXY_SOCKET_WORKER_ENV, } from "../../proxy/rollingWorkerProtocol.js";
@@ -1079,6 +1080,8 @@ function registerProxyRequestTracking(app, requestMetadata, readiness) {
         requestMetadata.set(c.req.raw, metadata);
         const stopObservingFinalLog = observeProxyFinalLog(metadata.requestId, (entry) => {
             metadata.terminalResult = entry;
+        }, (entry) => {
+            metadata.lastUpstreamAttempt = { ...entry };
         });
         const finishActivity = metadata.rejectForUpdate
             ? () => undefined
@@ -1306,7 +1309,8 @@ export async function createProxyStartApp(params) {
     const recordRuntimeError = async (metadata, status, errorType, errorMessage, options) => {
         const clientMessage = options?.clientMessage ?? errorMessage;
         const clientErrorType = options?.clientErrorType ?? errorType;
-        recordFinalError(status, PROXY_INTERNAL_ACCOUNT_LABEL, PROXY_INTERNAL_ACCOUNT_TYPE, {
+        const attempt = metadata.lastUpstreamAttempt;
+        recordFinalError(status, attempt?.account ?? PROXY_INTERNAL_ACCOUNT_LABEL, attempt?.accountType ?? PROXY_INTERNAL_ACCOUNT_TYPE, {
             requestId: metadata.requestId,
             errorType,
             errorCode: options?.errorCode,
@@ -1322,8 +1326,13 @@ export async function createProxyStartApp(params) {
                 model: metadata.model,
                 stream: metadata.stream,
                 toolCount: metadata.toolCount,
-                account: "",
-                accountType: "proxy-runtime",
+                account: attempt?.account ?? "",
+                accountType: attempt?.accountType ?? "proxy-runtime",
+                accountKey: attempt?.accountKey,
+                provider: attempt?.provider,
+                transportScope: attempt?.transportScope,
+                traceId: attempt?.traceId,
+                spanId: attempt?.spanId,
                 responseStatus: status,
                 responseTimeMs: Date.now() - metadata.startedAt,
                 errorType,
@@ -1392,6 +1401,15 @@ export async function createProxyStartApp(params) {
             .json()
             .catch(() => ({ action: undefined }));
         if (payload.action === "drain") {
+            // A rolling worker must keep admitting until the supervisor has a ready
+            // replacement. The legacy global drain can otherwise strand the listener
+            // behind maintenance responses when its caller stalls or disappears.
+            if (isProxySocketWorkerProcess()) {
+                return c.json({
+                    error: "rolling_restart_required",
+                    message: "Use neurolink proxy restart; global update drain is disabled for rolling workers.",
+                }, 409);
+            }
             if (!markProxyDrainingForUpdate(readiness)) {
                 return c.json({ error: "proxy_not_ready" }, 409);
             }
@@ -2769,6 +2787,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
         filePrefix: "proxy-supervisor",
     });
     let currentUpdaterPid;
+    let restartControl;
     const rollingServer = await startRollingProxyServer({
         onEvent: (event) => logProxyLifecycleEvent({
             event: "supervisor_event",
@@ -2799,6 +2818,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
                 version: PROXY_VERSION,
                 updaterPid: currentUpdaterPid,
                 rolling: snapshot,
+                restartControl: restartControl?.identity,
             });
         },
         log: (message) => logger.always(message),
@@ -2835,13 +2855,46 @@ async function runLaunchdProxySupervisor(argv, spinner) {
     };
     process.on("SIGUSR2", activatePendingUpdate);
     const readinessHost = host === "0.0.0.0" ? "127.0.0.1" : host;
+    try {
+        restartControl = await startProxyRestartControl({
+            stateDir: join(homedir(), ".neurolink"),
+            server: rollingServer,
+            log: (message) => logger.warn(message),
+            isUpdatePending: () => !!rollingReplacement || !!loadUpdateState()?.pendingRestartVersion,
+            getInstalledVersion: async () => {
+                const { execFile } = await import("node:child_process");
+                const { promisify } = await import("node:util");
+                const { stdout } = await promisify(execFile)(TRAMPOLINE_PATH, ["--version"], { timeout: 5_000, maxBuffer: 65_536 });
+                return stdout.trim();
+            },
+            getStatus: async () => {
+                const probeHost = readinessHost === "::" ? "::1" : readinessHost;
+                const response = await fetch(`http://${probeHost.includes(":") ? `[${probeHost}]` : probeHost}:${rollingServer.address.port}/status`, {
+                    headers: { connection: "close" },
+                    signal: AbortSignal.timeout(3_000),
+                });
+                if (!response.ok) {
+                    throw new Error("Serving status is unavailable.");
+                }
+                return response.json();
+            },
+        });
+    }
+    catch (error) {
+        // A control-plane setup failure must not stop an otherwise serving proxy.
+        logger.warn(`[proxy-supervisor] safe restart control unavailable: ${error instanceof Error ? error.message : String(error)}`);
+    }
     const updatePersistedUpdaterPid = (updaterPid) => {
         currentUpdaterPid = updaterPid;
         const state = loadProxySupervisorState();
         if (!state || state.pid !== process.pid) {
             return;
         }
-        saveProxySupervisorState({ ...state, updaterPid });
+        saveProxySupervisorState({
+            ...state,
+            updaterPid,
+            restartControl: restartControl?.identity,
+        });
     };
     const updaterSupervisor = startUpdaterWorkerSupervisor({
         spawnWorker: () => spawnProxyUpdater(readinessHost, rollingServer.address.port, process.pid, true),
@@ -2864,6 +2917,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
         stopping = true;
         logger.always(`[proxy-supervisor] shutting down (${signal})`);
         process.off("SIGUSR2", activatePendingUpdate);
+        await restartControl?.close();
         updaterSupervisor.stop();
         await rollingServer.close();
         await flushProxyLifecycleEvents().catch((error) => logger.warn(String(error)));

package/dist/cli/commands/proxyRestart.d.ts

@@ -0,0 +1,3 @@
+import type { CommandModule } from "yargs";
+import type { ProxyRestartArgs } from "../../types/index.js";
+export declare const proxyRestartCommand: CommandModule<object, ProxyRestartArgs>;

package/dist/cli/commands/proxyRestart.js

@@ -0,0 +1,88 @@
+import { readFile, lstat } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+import { resolveProxyPaths } from "../../proxy/proxyPaths.js";
+import { requestProxyRestart } from "../../proxy/restartControl.js";
+const supervisorSchema = z.object({
+    pid: z.number().int().positive(),
+    restartControl: z.object({
+        protocol: z.literal(1),
+        socketPath: z.string(),
+        instanceId: z.string().uuid(),
+    }),
+});
+export const proxyRestartCommand = {
+    command: "restart",
+    describe: "Replace the serving worker without stopping the proxy listener",
+    builder: (yargs) => yargs
+        .option("check", {
+        type: "boolean",
+        default: false,
+        description: "Check restart readiness without changing the running proxy",
+    })
+        .option("dev", {
+        type: "boolean",
+        default: false,
+        description: "Use the isolated proxy state in .neurolink-dev/",
+    })
+        .option("format", {
+        type: "string",
+        choices: ["text", "json"],
+        default: "text",
+    })
+        .example("neurolink proxy restart --check", "Verify the running supervisor supports safe worker replacement")
+        .example("neurolink proxy restart", "Start a replacement, verify it, then let existing streams finish"),
+    handler: async (argv) => {
+        try {
+            const { stateDir } = resolveProxyPaths(argv.dev);
+            const saved = supervisorSchema.safeParse(JSON.parse(await readFile(join(stateDir, "proxy-supervisor-state.json"), "utf8")));
+            if (!saved.success) {
+                throw new Error("This running supervisor does not advertise safe restart support. It must first be upgraded through a separately planned service activation.");
+            }
+            const { pid, restartControl } = saved.data;
+            if (restartControl.socketPath !==
+                join(stateDir, `restart-${pid}-${restartControl.instanceId}.sock`)) {
+                throw new Error("Restart control path does not match the recorded supervisor.");
+            }
+            const socket = await lstat(restartControl.socketPath);
+            if (!socket.isSocket() ||
+                (socket.mode & 0o077) !== 0 ||
+                (process.getuid && socket.uid !== process.getuid())) {
+                throw new Error("Restart control socket ownership or permissions are invalid.");
+            }
+            const result = await requestProxyRestart(restartControl, argv.check);
+            if (result.supervisorPid !== pid) {
+                throw new Error("Restart control identity changed; outcome is unverified.");
+            }
+            if (argv.format === "json") {
+                console.info(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.info(result.message);
+                console.info(`Supervisor ${result.supervisorPid}; worker ${result.workerPid ?? "unknown"}; version ${result.version ?? "unknown"}; previous workers finishing requests: ${result.drainingWorkers}.`);
+                console.info("This operation preserves the supervisor and launchd settings. It does not reinstall the service.");
+            }
+            if (!result.ok) {
+                process.exitCode = 1;
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error
+                ? error.message
+                : "Restart control is unavailable.";
+            if (argv.format === "json") {
+                const result = {
+                    ok: false,
+                    phase: "unverified",
+                    message,
+                };
+                console.info(JSON.stringify(result));
+            }
+            else {
+                console.error(message);
+            }
+            process.exitCode = 1;
+        }
+    },
+};
+//# sourceMappingURL=proxyRestart.js.map

package/dist/cli/parser.js

@@ -23,6 +23,7 @@ import { ObservabilityCommandFactory } from "./commands/observability.js";
 import { TelemetryCommandFactory } from "./commands/telemetry.js";
 import { proxyStartCommand, proxyStatusCommand, proxyTelemetryCommand, proxySetupCommand, proxyGuardCommand, proxyInstallCommand, proxyUninstallCommand, } from "./commands/proxy.js";
 import { proxyAnalyzeCommand } from "./commands/proxyAnalyze.js";
+import { proxyRestartCommand } from "./commands/proxyRestart.js";
 import { proxyShareCommand } from "./commands/proxyShare.js";
 import { proxyPeerCommand } from "./commands/proxyPeer.js";
 import { proxyExposeCommand } from "./commands/proxyExpose.js";
@@ -218,6 +219,7 @@ export function initializeCliParser() {
         builder: (yargs) => yargs
             .command(proxyStartCommand)
             .command(proxyStatusCommand)
+            .command(proxyRestartCommand)
             .command(proxyShareCommand)
             .command(proxyPeerCommand)
             .command(proxyExposeCommand)
@@ -228,7 +230,7 @@ export function initializeCliParser() {
             .command(proxyGuardCommand)
             .command(proxyInstallCommand)
             .command(proxyUninstallCommand)
-            .demandCommand(1, "Please specify a proxy subcommand: start, status, share <create|provision|url|list|status|pause|resume|revoke|topup|set|link|rotate|level|note|notes|receipts|delete>, peer <add|request|sync|receipts|net|redeem|list|status|test|remove|pause|resume|set>, expose, analyze, replay <export|compare>, telemetry <setup|start|stop|status|logs|import-dashboard>, setup, guard, install, or uninstall"),
+            .demandCommand(1, "Please specify a proxy subcommand: start, status, restart, share <create|provision|url|list|status|pause|resume|revoke|topup|set|link|rotate|level|note|notes|receipts|delete>, peer <add|request|sync|receipts|net|redeem|list|status|test|remove|pause|resume|set>, expose, analyze, replay <export|compare>, telemetry <setup|start|stop|status|logs|import-dashboard>, setup, guard, install, or uninstall"),
         handler: () => { },
     })
         // Evaluate Command Group - Using EvaluateCommandFactory

package/dist/proxy/bodyCaptureProcessing.d.ts

@@ -9,6 +9,7 @@ export declare function prepareProxyBodyForLogging(body: unknown): {
     value?: string;
     bytes?: number;
     truncated: boolean;
+    originalBytes?: number;
 };
 /**
  * Expose the same header-redaction policy to replay and metadata

package/dist/proxy/bodyCaptureProcessing.js

@@ -6,6 +6,7 @@ import { gzip as gzipCallback } from "node:zlib";
 const REQUEST_LOG_IO_TIMEOUT_MS = 5_000;
 /** Maximum redacted body bytes persisted per capture entry. */
 const MAX_CAPTURED_BODY_BYTES = 1024 * 1024;
+const MAX_OTEL_CAPTURED_BODY_BYTES = 8 * 1024 * 1024;
 const BODY_TRUNCATION_MARKER = "\n...[TRUNCATED]";
 const gzip = promisify(gzipCallback);
 /** Headers whose values must always be redacted. */
@@ -130,12 +131,15 @@ export function splitUtf8StringByBytes(input, maxBytes) {
  * Apply structural redaction before enforcing the per-artifact byte
  * ceiling.
  */
-function prepareRedactedBody(body) {
+function prepareRedactedBody(body, maxBytes = MAX_CAPTURED_BODY_BYTES) {
     const redacted = redactBody(body);
     if (redacted === undefined) {
         return { truncated: false };
     }
-    return truncateUtf8String(redacted, MAX_CAPTURED_BODY_BYTES);
+    return {
+        ...truncateUtf8String(redacted, maxBytes),
+        originalBytes: utf8ByteLength(redacted),
+    };
 }
 /**
  * Write a private gzip artifact with a unique name and return its
@@ -202,7 +206,8 @@ export function redactProxyHeadersForLogging(headers) {
  */
 export async function processProxyBodyCapture(entry, logDir) {
     const headers = redactHeaders(entry.headers);
-    const prepared = prepareRedactedBody(entry.body);
+    const limit = logDir === null ? MAX_OTEL_CAPTURED_BODY_BYTES : MAX_CAPTURED_BODY_BYTES;
+    const prepared = prepareRedactedBody(entry.body, limit);
     if (logDir === null) {
         return {
             headers,
@@ -210,6 +215,9 @@ export async function processProxyBodyCapture(entry, logDir) {
                 redactedBody: prepared.value,
                 redactedBodyBytes: prepared.bytes,
                 bodyTruncated: prepared.truncated,
+                bodyCaptureLimitBytes: limit,
+                originalRedactedBodyBytes: prepared.originalBytes,
+                bodySha256: prepared.value === undefined ? undefined : sha256(prepared.value),
             },
         };
     }
@@ -225,5 +233,12 @@ export async function processProxyBodyCapture(entry, logDir) {
             bodyWriteFailed: true,
         };
     }
-    return { headers, stored };
+    return {
+        headers,
+        stored: {
+            ...stored,
+            bodyCaptureLimitBytes: limit,
+            originalRedactedBodyBytes: prepared.originalBytes,
+        },
+    };
 }

package/dist/proxy/bodyCaptureWorker.js

@@ -1,7 +1,9 @@
 import { Worker } from "node:worker_threads";
 const MAX_PENDING = 16;
 const MAX_PENDING_BYTES = 32 * 1024 * 1024;
-const MAX_ENTRY_BYTES = 8 * 1024 * 1024;
+// Bound retained UTF-16 strings rather than a 3x UTF-8 guess. This accommodates
+// the observed 7.3 MB JSON requests while retaining a 32 MiB aggregate pool.
+const MAX_ENTRY_BYTES = 16 * 1024 * 1024;
 export const PROXY_BODY_CAPTURE_DEADLINE_MS = 20_000;
 let worker;
 let workerUrl;
@@ -16,6 +18,7 @@ const snapshot = {
     pendingBytes: 0,
     maxPending: MAX_PENDING,
     maxPendingBytes: MAX_PENDING_BYTES,
+    rejectionReasons: {},
 };
 const pending = new Map();
 // Bound traversal as well as the structured clone sent to the worker. Never
@@ -29,12 +32,15 @@ function estimateCloneBytes(value) {
     const seen = new Set();
     let bytes = 0, nodes = 0;
     while (stack.length) {
-        if (++nodes > 100_000 || bytes > MAX_ENTRY_BYTES) {
-            return Infinity;
+        if (++nodes > 100_000) {
+            throw new Error("body_capture_traversal_limit");
+        }
+        if (bytes > MAX_ENTRY_BYTES) {
+            throw new Error("body_capture_entry_too_large");
         }
         const item = stack.pop();
         if (typeof item === "string") {
-            bytes += item.length * 3;
+            bytes += 16 + item.length * 2;
             continue;
         }
         bytes += 16;
@@ -42,23 +48,26 @@ function estimateCloneBytes(value) {
             continue;
         }
         if (seen.has(item)) {
-            return Infinity;
+            throw new Error("body_capture_unsupported_value");
         }
         seen.add(item);
         if (!Array.isArray(item) &&
             Object.getPrototypeOf(item) !== Object.prototype &&
             Object.getPrototypeOf(item) !== null) {
-            return Infinity;
+            throw new Error("body_capture_unsupported_value");
         }
         for (const key of Object.keys(item)) {
-            bytes += key.length * 3;
+            bytes += 16 + key.length * 2;
             const descriptor = Object.getOwnPropertyDescriptor(item, key);
             if (!descriptor || descriptor.get || descriptor.set) {
-                return Infinity;
+                throw new Error("body_capture_unsupported_value");
             }
             stack.push(descriptor.value);
-            if (stack.length > 100_000 || bytes > MAX_ENTRY_BYTES) {
-                return Infinity;
+            if (stack.length > 100_000) {
+                throw new Error("body_capture_traversal_limit");
+            }
+            if (bytes > MAX_ENTRY_BYTES) {
+                throw new Error("body_capture_entry_too_large");
             }
         }
     }
@@ -125,11 +134,21 @@ function getWorker() {
 export async function captureProxyBody(entry, logDir, consume) {
     snapshot.attempted += 1;
     let bytes;
+    let admissionError;
     try {
         bytes = estimateCloneBytes(entry);
     }
-    catch {
+    catch (error) {
         bytes = Infinity;
+        admissionError =
+            error instanceof Error &&
+                [
+                    "body_capture_entry_too_large",
+                    "body_capture_traversal_limit",
+                    "body_capture_unsupported_value",
+                ].includes(error.message)
+                ? error.message
+                : "body_capture_unsupported_value";
     }
     if (bytes > MAX_ENTRY_BYTES ||
         snapshot.pending >= MAX_PENDING ||
@@ -137,11 +156,13 @@ export async function captureProxyBody(entry, logDir, consume) {
         Date.now() < retryAfter) {
         snapshot.rejected += 1;
         const error = bytes > MAX_ENTRY_BYTES
-            ? "body_capture_too_large_or_non_json"
+            ? (admissionError ?? "body_capture_entry_too_large")
             : Date.now() < retryAfter
                 ? "body_worker_backoff"
                 : "body_capture_queue_full";
         snapshot.lastError = error;
+        snapshot.rejectionReasons[error] =
+            (snapshot.rejectionReasons[error] ?? 0) + 1;
         return consume({ error, stored: { bodyWriteFailed: true } });
     }
     let current;
@@ -204,7 +225,7 @@ export async function captureProxyBody(entry, logDir, consume) {
  * retained publication work.
  */
 export function getBodyCaptureWorkerSnapshot() {
-    return { ...snapshot };
+    return { ...snapshot, rejectionReasons: { ...snapshot.rejectionReasons } };
 }
 /** Isolated tests point at a separately executed built worker. */
 export const __bodyCaptureWorkerTestHooks = {
@@ -227,6 +248,7 @@ export const __bodyCaptureWorkerTestHooks = {
             pending: 0,
             pendingBytes: 0,
             lastError: undefined,
+            rejectionReasons: {},
         });
     },
 };

package/dist/proxy/otelLogSink.d.ts

@@ -1,6 +1,13 @@
 import { LoggerProvider } from "@opentelemetry/sdk-logs";
+import type { ProxyBodyChunkEmitter, ProxyBodyDeliveryResult } from "../types/index.js";
 /** Explicit opt-in; configuration never silently falls back to file logging. */
 export declare function isProxyOtelOnly(): boolean;
+/**
+ * Own a whole capture within byte/count bounds, then pace its chunks by actual
+ * export callbacks. SDK forceFlush alone does not await an automatic export
+ * already in flight. Serial publication prevents bursts from dropping tails.
+ */
+export declare function publishProxyOtelBody(captureId: string, body: string, emit: ProxyBodyChunkEmitter): Promise<ProxyBodyDeliveryResult>;
 /** Initialize a log-only provider in every proxy process, including the supervisor. */
 export declare function initializeProxyOtelLogs(role?: string): LoggerProvider | undefined;
 /** Structured evidence without final-request dashboard fields on auxiliary events. */
@@ -13,6 +20,19 @@ export declare function getProxyOtelLogSnapshot(): {
     initialized: boolean;
     deliveryGuarantee: string;
     invalidRecords: number;
+    bodyDelivery: {
+        attempted: number;
+        transportAcknowledged: number;
+        exportUnconfirmed: number;
+        rejected: number;
+        partial: number;
+        pending: number;
+        pendingBytes: number;
+        highWaterPending: number;
+        highWaterBytes: number;
+        maxPending: number;
+        maxPendingBytes: number;
+    };
     queues: {
         attempted: number;
         submitted: number;
@@ -22,7 +42,8 @@ export declare function getProxyOtelLogSnapshot(): {
         outstanding: number;
         lastAcknowledgedAt: string | undefined;
         lastFailureAt: string | undefined;
-        kind: string;
+        highWaterOutstanding: number;
+        kind: "metadata" | "bodies";
         capacity: number;
     }[];
 };