@juspay/neurolink 9.87.2 → 9.87.4

package/dist/lib/server/routes/openaiProxyRoutes.js

@@ -146,12 +146,53 @@ async function handleOpenAIToAnthropicBridge(args) {
             });
             return buildOpenAIErrorResponse(502, "Anthropic loopback returned empty stream body");
         }
-        // Streaming success: log now since the response body is consumed by the
-        // client. Token counts are not visible at this layer (the inner /v1/messages
-        // handler accounts them), so we omit them here.
-        await writeLifecycle(200);
-        const transformed = upstream.body.pipeThrough(createClaudeToOpenAIStreamTransform(body.model));
-        return new Response(transformed, {
+        let terminalStreamError;
+        const transformed = upstream.body.pipeThrough(createClaudeToOpenAIStreamTransform(body.model, {
+            onError: (message) => {
+                terminalStreamError = sanitizeForLog(message);
+            },
+        }));
+        const reader = transformed.getReader();
+        let lifecycleWritten = false;
+        const finishLifecycle = async (status, errorType, errorMessage) => {
+            if (lifecycleWritten) {
+                return;
+            }
+            lifecycleWritten = true;
+            await writeLifecycle(status, { errorType, errorMessage });
+        };
+        const trackedStream = new ReadableStream({
+            async pull(controller) {
+                try {
+                    const { value, done } = await reader.read();
+                    if (done) {
+                        if (terminalStreamError) {
+                            await finishLifecycle(502, "loopback_stream_error", terminalStreamError);
+                        }
+                        else {
+                            await finishLifecycle(200);
+                        }
+                        controller.close();
+                        return;
+                    }
+                    controller.enqueue(value);
+                }
+                catch (error) {
+                    const message = sanitizeForLog(error instanceof Error ? error.message : String(error));
+                    await finishLifecycle(502, "loopback_stream_error", message);
+                    controller.error(error);
+                }
+            },
+            async cancel(reason) {
+                try {
+                    await reader.cancel(reason);
+                }
+                finally {
+                    await finishLifecycle(499, "client_cancelled", "Client cancelled the OpenAI-compatible stream");
+                }
+            },
+        });
+        return new Response(trackedStream, {
             status: 200,
             headers: {
                 "content-type": "text/event-stream",

package/dist/lib/types/cli.d.ts

@@ -800,6 +800,8 @@ export type ProxyGuardArgs = {
     failureThreshold?: number;
     pollIntervalMs?: number;
     quiet?: boolean;
+    /** Run update checks only; never mutate client settings. */
+    updaterOnly?: boolean;
 };
 /** Arguments accepted by `neurolink proxy telemetry <subcommand>` */
 export type ProxyTelemetryArgs = {
@@ -829,6 +831,8 @@ export type ProxyState = {
     accountAllowlist?: string[];
     /** Optional fail-open guard PID that reverts Claude settings if proxy dies */
     guardPid?: number;
+    /** Dedicated updater PID for launchd-managed proxy installations. */
+    updaterPid?: number;
     /** How the proxy was launched — "launchd" if installed as service, "manual" otherwise */
     managedBy?: "launchd" | "manual";
     /** Whether the proxy is running in transparent passthrough mode */

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

@@ -518,6 +518,7 @@ export type AnthropicLoopState = {
     } | null;
     authFailureMessage: string | null;
     authCooldownMessage: string | null;
+    fallbackFailureMessage?: string;
     attemptNumber: number;
 };
 export type AnthropicUpstreamBody = {
@@ -586,6 +587,10 @@ export type AccountCooldownPlan = {
      *  burst), a small number of jittered same-account retries is allowed first. */
     rotateImmediately: boolean;
 };
+export type TransientRateLimitRetryBudget = {
+    coolingUntil: number;
+    retriesClaimed: number;
+};
 export type AnthropicUpstreamFetchResult = {
     continueLoop: boolean;
     retrySameAccount?: boolean;
@@ -595,6 +600,15 @@ export type AnthropicUpstreamFetchResult = {
     cooldownPlan?: AccountCooldownPlan;
     /** Quota snapshot parsed from the response headers (429 or success), if present. */
     quota?: AccountQuota;
+    /** A terminal upstream rejection already captured and classified by the
+     *  fetch layer. The route must finalize it directly instead of feeding it
+     *  through the generic non-OK handler a second time. */
+    terminalError?: {
+        status: number;
+        body: string;
+        headers: Record<string, string>;
+        errorType: "construction_rejection";
+    };
     response?: Response;
     lastError: unknown;
     sawRateLimit: boolean;
@@ -897,6 +911,26 @@ export type QuietStatus = {
     lastActivityAt: Date | null;
     silenceDurationMs: number;
 };
+/** In-process proxy request activity used to protect streaming restarts. */
+export type ProxyActivitySnapshot = {
+    activeRequests: number;
+    lastActivityAt: Date | null;
+};
+/** Activity payload exposed by the running proxy status endpoint. */
+export type ProxyRuntimeActivity = {
+    activeRequests: number;
+    lastActivityAt: string | null;
+};
+/** Request metadata retained by the HTTP adapter for terminal error logging. */
+export type RuntimeRequestMetadata = {
+    requestId: string;
+    method: string;
+    path: string;
+    startedAt: number;
+    model: string;
+    stream: boolean;
+    toolCount: number;
+};
 /** Accumulated upstream body capture from a raw stream. */
 export type RawStreamCapture = {
     totalBytes: number;
@@ -1060,6 +1094,34 @@ export type UpdateState = {
     lastUpdateAt: string | null;
     lastUpdateVersion: string | null;
 };
+/** Supported global package managers for proxy self-updates. */
+export type GlobalInstallerKind = "npm" | "pnpm";
+/** Result of probing one global package-manager executable. */
+export type GlobalInstallerProbe = {
+    kind: GlobalInstallerKind;
+    bin: string;
+    version?: string;
+    globalRoot?: string;
+    globalBinDir?: string;
+    working: boolean;
+    installable: boolean;
+    matchesCurrentInstall: boolean;
+    reason?: string;
+};
+/** Selected package manager plus all candidates considered. */
+export type GlobalInstallerResolution = {
+    installer?: GlobalInstallerProbe;
+    tried: GlobalInstallerProbe[];
+};
+/** Injectable command runner used by global-installer tests. */
+export type GlobalInstallerExecFile = typeof import("node:child_process").execFileSync;
+/** Overrides used while resolving the global package manager. */
+export type ResolveGlobalInstallerOptions = {
+    entryScript?: string;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+    execFileSync?: GlobalInstallerExecFile;
+};
 /** Shape of the dynamically-imported js-yaml module. `dump` is optional —
  *  read-only consumers (proxy config loader) only need `load`; writers
  *  (CLI primary-account commands) check `dump` before calling. */

package/dist/proxy/globalInstaller.d.ts

@@ -0,0 +1,5 @@
+import type { GlobalInstallerKind, GlobalInstallerResolution, ResolveGlobalInstallerOptions } from "../types/index.js";
+/** Resolve a package manager that can update the installation currently running. */
+export declare function resolveGlobalInstaller(options?: ResolveGlobalInstallerOptions): GlobalInstallerResolution;
+export declare function getGlobalInstallArgs(kind: GlobalInstallerKind, packageSpec: string): string[];
+export declare function describeInstallFailure(error: unknown): string;

package/dist/proxy/globalInstaller.js

@@ -0,0 +1,155 @@
+import { execFileSync as nodeExecFileSync } from "node:child_process";
+import { accessSync, constants, existsSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+function runText(execFileSync, bin, args) {
+    return String(execFileSync(bin, args, {
+        encoding: "utf8",
+        timeout: 10_000,
+        stdio: ["ignore", "pipe", "pipe"],
+    })).trim();
+}
+function writableDirectory(path) {
+    try {
+        if (!existsSync(path)) {
+            return false;
+        }
+        accessSync(path, constants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isPathInside(path, parent) {
+    if (!path) {
+        return false;
+    }
+    try {
+        const candidate = realpathSync(path);
+        const root = realpathSync(parent);
+        return candidate === root || candidate.startsWith(`${root}/`);
+    }
+    catch {
+        const candidate = resolve(path);
+        const root = resolve(parent);
+        return candidate === root || candidate.startsWith(`${root}/`);
+    }
+}
+function probeInstaller(kind, bin, entryScript, execFileSync) {
+    const base = {
+        kind,
+        bin,
+        working: false,
+        installable: false,
+        matchesCurrentInstall: false,
+    };
+    try {
+        base.version = runText(execFileSync, bin, ["--version"]);
+        base.working = base.version.length > 0;
+        base.globalRoot = runText(execFileSync, bin, ["root", "-g"]);
+        base.globalBinDir =
+            kind === "pnpm"
+                ? runText(execFileSync, bin, ["bin", "-g"])
+                : join(runText(execFileSync, bin, ["prefix", "-g"]), "bin");
+        if (!base.globalRoot || !writableDirectory(base.globalRoot)) {
+            base.reason = "global package root is missing or not writable";
+            return base;
+        }
+        if (!base.globalBinDir || !writableDirectory(base.globalBinDir)) {
+            base.reason = "global executable directory is missing or not writable";
+            return base;
+        }
+        base.installable = true;
+        base.matchesCurrentInstall = isPathInside(entryScript, base.globalRoot);
+        return base;
+    }
+    catch (error) {
+        base.reason = error instanceof Error ? error.message : String(error);
+        return base;
+    }
+}
+function resolveFromPath(command, execFileSync) {
+    try {
+        const result = runText(execFileSync, "which", [command]);
+        return result || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Resolve a package manager that can update the installation currently running. */
+export function resolveGlobalInstaller(options = {}) {
+    const env = options.env ?? process.env;
+    const homeDir = options.homeDir ?? homedir();
+    const entryScript = options.entryScript ?? process.argv[1];
+    const execFileSync = options.execFileSync ?? nodeExecFileSync;
+    const candidates = [];
+    if (env.NEUROLINK_PACKAGE_MANAGER_PATH) {
+        const configuredKind = env.NEUROLINK_PACKAGE_MANAGER?.toLowerCase();
+        const inferredName = basename(env.NEUROLINK_PACKAGE_MANAGER_PATH);
+        const kind = configuredKind === "npm" || configuredKind === "pnpm"
+            ? configuredKind
+            : inferredName.startsWith("npm")
+                ? "npm"
+                : "pnpm";
+        candidates.push({ kind, bin: env.NEUROLINK_PACKAGE_MANAGER_PATH });
+    }
+    if (env.NEUROLINK_PNPM_PATH) {
+        candidates.push({ kind: "pnpm", bin: env.NEUROLINK_PNPM_PATH });
+    }
+    if (env.PNPM_HOME) {
+        candidates.push({ kind: "pnpm", bin: join(env.PNPM_HOME, "pnpm") });
+    }
+    const nodeBinDir = dirname(process.execPath);
+    candidates.push({ kind: "npm", bin: join(nodeBinDir, "npm") });
+    const pathPnpm = resolveFromPath("pnpm", execFileSync);
+    const pathNpm = resolveFromPath("npm", execFileSync);
+    if (pathPnpm) {
+        candidates.push({ kind: "pnpm", bin: pathPnpm });
+    }
+    if (pathNpm) {
+        candidates.push({ kind: "npm", bin: pathNpm });
+    }
+    candidates.push({ kind: "pnpm", bin: join(homeDir, ".local", "share", "pnpm", "pnpm") }, { kind: "pnpm", bin: join(homeDir, "Library", "pnpm", "pnpm") }, { kind: "npm", bin: "/opt/homebrew/bin/npm" }, { kind: "npm", bin: "/usr/local/bin/npm" });
+    const seen = new Set();
+    const tried = candidates
+        .filter(({ kind, bin }) => {
+        const key = `${kind}:${bin}`;
+        if (!bin || seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    })
+        .map(({ kind, bin }) => probeInstaller(kind, bin, entryScript, execFileSync));
+    const matchingInstaller = tried.find((probe) => probe.installable && probe.matchesCurrentInstall);
+    // When the running entry script is known, installing into a different
+    // global root cannot update that process and may shadow another install.
+    const installer = entryScript
+        ? matchingInstaller
+        : (matchingInstaller ?? tried.find((probe) => probe.installable));
+    return { installer, tried };
+}
+export function getGlobalInstallArgs(kind, packageSpec) {
+    return kind === "pnpm"
+        ? ["add", "-g", packageSpec]
+        : ["install", "--global", "--no-audit", "--no-fund", packageSpec];
+}
+function capturedOutput(error, key) {
+    if (!error || typeof error !== "object" || !(key in error)) {
+        return "";
+    }
+    const raw = error[key];
+    return String(raw ?? "")
+        .trim()
+        .slice(0, 1_000);
+}
+export function describeInstallFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const stdout = capturedOutput(error, "stdout");
+    const stderr = capturedOutput(error, "stderr");
+    return [message, stdout && `stdout: ${stdout}`, stderr && `stderr: ${stderr}`]
+        .filter(Boolean)
+        .join("\n");
+}

package/dist/proxy/openaiFormat.d.ts

@@ -134,4 +134,6 @@ export declare function convertClaudeToOpenAIResponse(claude: ClaudeResponse, re
  *  - message_delta       -> captures stop_reason and output token usage
  *  - message_stop        -> emits the final `finish_reason` chunk + `[DONE]`
  */
-export declare function createClaudeToOpenAIStreamTransform(requestModel: string): TransformStream<Uint8Array, Uint8Array>;
+export declare function createClaudeToOpenAIStreamTransform(requestModel: string, options?: {
+    onError?: (message: string) => void;
+}): TransformStream<Uint8Array, Uint8Array>;

package/dist/proxy/openaiFormat.js

@@ -651,7 +651,7 @@ export function convertClaudeToOpenAIResponse(claude, requestModel) {
  *  - message_delta       -> captures stop_reason and output token usage
  *  - message_stop        -> emits the final `finish_reason` chunk + `[DONE]`
  */
-export function createClaudeToOpenAIStreamTransform(requestModel) {
+export function createClaudeToOpenAIStreamTransform(requestModel, options = {}) {
     const serializer = new OpenAIStreamSerializer(requestModel);
     const encoder = new TextEncoder();
     const decoder = new TextDecoder();
@@ -677,6 +677,9 @@ export function createClaudeToOpenAIStreamTransform(requestModel) {
         catch {
             return;
         }
+        if (finished) {
+            return;
+        }
         switch (eventName) {
             case "message_start": {
                 const message = (data.message ?? {});
@@ -749,8 +752,18 @@ export function createClaudeToOpenAIStreamTransform(requestModel) {
                 }
                 return;
             }
+            case "error": {
+                const error = (data.error ?? {});
+                const message = typeof error.message === "string"
+                    ? error.message
+                    : "Anthropic stream failed";
+                finished = true;
+                options.onError?.(message);
+                emit(controller, serializer.emitError(message));
+                return;
+            }
             default:
-                // ping, error, and unknown events are ignored.
+                // ping and unknown events are ignored.
                 return;
         }
     };
@@ -790,10 +803,12 @@ export function createClaudeToOpenAIStreamTransform(requestModel) {
             // closing `\n\n` is not silently lost.
             buffer += decoder.decode();
             drainBufferedEvents(controller);
-            // If the upstream closed without a message_stop, still finalize.
+            // Closing without message_stop is an interrupted stream, not success.
             if (!finished) {
                 finished = true;
-                emit(controller, serializer.finish(stopReason, usage));
+                const message = "Anthropic stream ended before message_stop";
+                options.onError?.(message);
+                emit(controller, serializer.emitError(message));
             }
         },
     });

package/dist/proxy/proxyActivity.d.ts

@@ -0,0 +1,8 @@
+import type { ProxyActivitySnapshot } from "../types/index.js";
+/** Track one client-facing proxy request until its response body settles. */
+export declare function beginProxyRequest(): () => void;
+export declare function getProxyActivitySnapshot(): ProxyActivitySnapshot;
+export declare function isProxyActivityQuiet(snapshot: ProxyActivitySnapshot, quietThresholdMs: number, nowMs?: number): boolean;
+/** Keep activity open until the response body completes, errors, or is cancelled. */
+export declare function trackProxyResponse(response: Response, finishRequest: () => void): Response;
+export declare function resetProxyActivityForTests(): void;

package/dist/proxy/proxyActivity.js

@@ -0,0 +1,76 @@
+let activeRequests = 0;
+let lastActivityAtMs = null;
+function touchActivity() {
+    lastActivityAtMs = Date.now();
+}
+/** Track one client-facing proxy request until its response body settles. */
+export function beginProxyRequest() {
+    activeRequests += 1;
+    touchActivity();
+    let finished = false;
+    return () => {
+        if (finished) {
+            return;
+        }
+        finished = true;
+        activeRequests = Math.max(0, activeRequests - 1);
+        touchActivity();
+    };
+}
+export function getProxyActivitySnapshot() {
+    return {
+        activeRequests,
+        lastActivityAt: lastActivityAtMs === null ? null : new Date(lastActivityAtMs),
+    };
+}
+export function isProxyActivityQuiet(snapshot, quietThresholdMs, nowMs = Date.now()) {
+    if (snapshot.activeRequests > 0) {
+        return false;
+    }
+    if (snapshot.lastActivityAt === null) {
+        return true;
+    }
+    return nowMs - snapshot.lastActivityAt.getTime() >= quietThresholdMs;
+}
+/** Keep activity open until the response body completes, errors, or is cancelled. */
+export function trackProxyResponse(response, finishRequest) {
+    if (!response.body) {
+        finishRequest();
+        return response;
+    }
+    const reader = response.body.getReader();
+    const trackedBody = new ReadableStream({
+        async pull(controller) {
+            try {
+                const { value, done } = await reader.read();
+                if (done) {
+                    finishRequest();
+                    controller.close();
+                    return;
+                }
+                controller.enqueue(value);
+            }
+            catch (error) {
+                finishRequest();
+                controller.error(error);
+            }
+        },
+        async cancel(reason) {
+            try {
+                await reader.cancel(reason);
+            }
+            finally {
+                finishRequest();
+            }
+        },
+    });
+    return new Response(trackedBody, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}
+export function resetProxyActivityForTests() {
+    activeRequests = 0;
+    lastActivityAtMs = null;
+}