@juspay/neurolink 12.54.0 → 12.54.2

package/CHANGELOG.md

@@ -1,9 +1,8 @@
-## [12.54.0](https://github.com/juspay/neurolink/compare/v12.53.0...v12.54.0) (2026-10-12)
+## [12.54.2](https://github.com/juspay/neurolink/compare/v12.54.1...v12.54.2) (2026-10-12)
 
-### Features
+### Bug Fixes
 
-- **(examples):** rebuild voice bench as a React app ([e8ee2c3](https://github.com/juspay/neurolink/commit/e8ee2c399a05aa15d4fd9273c58a1d4ad081744f))
-- **(observability):** keep conversation, tool arguments and turn outcome on Vertex Claude traces ([0aa412c](https://github.com/juspay/neurolink/commit/0aa412c49634f3fd86f92179a0b45b7797877707))
+- **(proxy):** prune superseded package builds after update and on updater start ([a9915f6](https://github.com/juspay/neurolink/commit/a9915f633825c07715cefdeb0d7587affe473f5b))
 
 ## [11.2.3](https://github.com/juspay/neurolink/compare/v11.2.2...v11.2.3) (2026-08-19)
 

package/dist/cli/commands/proxy.js

@@ -24,6 +24,7 @@ import { resolveProxyStatusAccountIdentity } from "../../proxy/codexAccountUsage
 import { beginProxyRequest, consumeInternalProxyRequest, releaseProxyRequestAccounting, withProxyFinalLogOwnership, getProxyActivitySnapshot, observeProxyFinalLog, takeProxyResponseObservers, trackProxyResponse, } from "../../proxy/proxyActivity.js";
 import { configureProxyLifecycleLogger, flushProxyLifecycleEvents, persistProxyLifecycleAcceptance, getProxyLifecycleLoggerSnapshot, hashProxyLifecycleSessionId, logProxyLifecycleEvent, } from "../../proxy/proxyLifecycle.js";
 import { describeInstallFailure, assertProxyServiceInstallIdle, probeProxyLaunchdPresence, inspectProxyPackage, isProxyServiceEnvironmentKey, parseProxyServiceInstallSettings, installStagedProxyPackage, prepareProxyPackageUpgrade, readProxyPackageSelection, resolveProxyWorkerPackage, selectProxyPackage, writeProxyPackageLauncher, isTransientInstallFailure, resolveGlobalInstaller, validateInstalledVersion, } from "../../proxy/globalInstaller.js";
+import { pruneProxyPackages } from "../../proxy/packagePrune.js";
 import { startUpdaterWorkerSupervisor } from "../../proxy/updaterSupervisor.js";
 import { openProxyWorkerLog } from "../../proxy/workerLog.js";
 import { startRollingProxyServer } from "../../proxy/rollingProxyServer.js";
@@ -4094,13 +4095,55 @@ export const proxyGuardCommand = {
                 runtimeUpdaterPid: runtime?.updaterPid,
             });
         };
+        // Each release installs a full dependency tree into its own directory and
+        // nothing else ever removes one, so the store has to be trimmed here: on
+        // updater start for the backlog, and after each confirmed update.
         let updateInProgress = false;
         let updateRestartInProgress = false;
+        let packagePruneInFlight;
+        const prunePackageStore = (trigger) => {
+            packagePruneInFlight ??= (async () => {
+                // A stale updater must not mutate package state a newer owner relies on.
+                // An update that reuses an existing unselected build would also race the
+                // rename; the post-update pass runs inside the update and is safe.
+                if (!isCurrentUpdateOwner() ||
+                    (updateInProgress && trigger !== "after update")) {
+                    return;
+                }
+                try {
+                    const outcome = await pruneProxyPackages({
+                        packagesDir: PROXY_PACKAGES_DIR,
+                        currentEntryScript: process.argv[1],
+                        isCurrentOwner: isCurrentUpdateOwner,
+                    });
+                    if (outcome.skipped) {
+                        logger.always(`[updater] package store prune skipped (${trigger}): ${outcome.skipped}`);
+                    }
+                    else if (outcome.removed.length > 0) {
+                        logger.always(`[updater] package store prune (${trigger}): removed ${outcome.removed.length} old build(s); retained ${outcome.retained
+                            .map((build) => `${build.name} [${build.reason}]`)
+                            .join(", ")}`);
+                    }
+                    for (const failure of outcome.failed) {
+                        logger.always(`[updater] WARNING: could not remove old build ${failure.name}: ${failure.message}`);
+                    }
+                }
+                catch (error) {
+                    logger.always(`[updater] WARNING: package store prune failed (${trigger}): ${error instanceof Error ? error.message : String(error)}`);
+                }
+            })().finally(() => {
+                packagePruneInFlight = undefined;
+            });
+            return packagePruneInFlight;
+        };
         const runUpdateCheck = async () => {
             if (updateInProgress || !isCurrentUpdateOwner()) {
                 return;
             }
             updateInProgress = true;
+            // A pass already under way works from a snapshot of the store and could
+            // rename a build this update is about to reuse.
+            await packagePruneInFlight?.catch(() => undefined);
             let updateVersion = runningVersion;
             let drainActive = false;
             let previousPackage;
@@ -4662,6 +4705,9 @@ export const proxyGuardCommand = {
                     persistUpdaterState("record successful update", () => recordSuccessfulUpdate(result.latestVersion));
                     updateRetryAttempts = 0;
                     updateRetryVersion = null;
+                    // The new version is serving and the selection pair is committed, so
+                    // the build that just fell out of retention is unreferenced.
+                    await prunePackageStore("after update");
                     // The replacement proxy starts a worker running the new version.
                     await shutdownProxyOtelLogs().catch(() => undefined);
                     process.exit(0);
@@ -4769,6 +4815,14 @@ export const proxyGuardCommand = {
             }, delay);
             updateRetryTimeout.unref?.();
         };
+        // Not gated on canAutoUpdate: builds left by earlier runs are dead weight
+        // whether or not this process will install another one. The periodic pass
+        // is cheap (one readdir and one process listing) and covers a startup pass
+        // that ran before the supervisor had recorded this updater as the owner.
+        if (updaterOnly) {
+            setTimeout(() => void prunePackageStore("startup"), 60_000).unref();
+            setInterval(() => void prunePackageStore("periodic"), UPDATE_CHECK_INTERVAL_MS).unref();
+        }
         // Run first check after a short delay, then on interval
         if (canAutoUpdate) {
             updateCheckTimeout = setTimeout(runUpdateCheck, 30_000);

package/dist/proxy/packagePrune.d.ts

@@ -0,0 +1,8 @@
+import type { ProxyPackagePruneOptions, ProxyPackagePruneResult } from "../types/index.js";
+/**
+ * Keep the selected pair (active and rollback) and remove every other build the
+ * installer generated. Nothing is removed unless the active selection is valid,
+ * the live process list could be read, and the build is neither referenced by a
+ * running process nor recently written.
+ */
+export declare function pruneProxyPackages(options: ProxyPackagePruneOptions): Promise<ProxyPackagePruneResult>;

package/dist/proxy/packagePrune.js

@@ -0,0 +1,219 @@
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { readFileSync, realpathSync } from "node:fs";
+import { lstat, readdir, rename, rm } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { promisify } from "node:util";
+import { readProxyPackageSelection } from "./globalInstaller.js";
+const execFileAsync = promisify(execFile);
+// Only the names globalInstaller.ts generates: `<version>`,
+// `<version>-release-<uuid>` and `<version>-polyfills-<digest>-<uuid>`. Anything
+// else in the store (a hand-made `-official` copy, an in-flight `.install-*`
+// staging tree) is not ours to delete.
+const GENERATED_BUILD_NAME = /^\d+\.\d+\.\d+(?:-release-[0-9a-f-]{36}|-polyfills-[0-9a-f]{16}-[0-9a-f-]{36})?$/;
+const TOMBSTONE_PREFIX = ".prune-";
+const DEFAULT_MIN_AGE_MS = 60 * 60_000;
+function entryScriptOf(value) {
+    return typeof value === "object" &&
+        value !== null &&
+        "entryScript" in value &&
+        typeof value.entryScript === "string"
+        ? value.entryScript
+        : undefined;
+}
+function canonical(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return path;
+    }
+}
+/** First path segment below the store, i.e. the build directory a file lives in. */
+function buildDirectoryOf(storeRoot, path) {
+    const rel = relative(storeRoot, canonical(path));
+    if (!rel || rel.startsWith("..") || isAbsolute(rel)) {
+        return null;
+    }
+    return rel.split(sep)[0] ?? null;
+}
+/**
+ * Read selections.json without validating the builds it names: a build that
+ * failed validation once must still count as referenced, not as garbage.
+ */
+function rawSelectedEntryScripts(packagesDir) {
+    try {
+        const state = JSON.parse(readFileSync(join(packagesDir, "selections.json"), "utf8"));
+        if (typeof state !== "object" || state === null) {
+            return [];
+        }
+        return [
+            "active" in state ? entryScriptOf(state.active) : undefined,
+            "previous" in state ? entryScriptOf(state.previous) : undefined,
+        ].filter((entry) => entry !== undefined);
+    }
+    catch {
+        return [];
+    }
+}
+async function listProcessCommandLines() {
+    if (process.platform === "win32") {
+        return null;
+    }
+    try {
+        const { stdout } = await execFileAsync("ps", ["-axo", "command="], {
+            maxBuffer: 64 * 1024 * 1024,
+            timeout: 10_000,
+        });
+        return stdout.split("\n");
+    }
+    catch {
+        return null;
+    }
+}
+function mentionsDirectory(line, directory) {
+    return (line.includes(`${directory}${sep}`) ||
+        line.includes(`${directory} `) ||
+        line.endsWith(directory));
+}
+/**
+ * Keep the selected pair (active and rollback) and remove every other build the
+ * installer generated. Nothing is removed unless the active selection is valid,
+ * the live process list could be read, and the build is neither referenced by a
+ * running process nor recently written.
+ */
+export async function pruneProxyPackages(options) {
+    const skip = (reason) => ({
+        skipped: reason,
+        removed: [],
+        retained: [],
+        failed: [],
+    });
+    let storeRoot;
+    try {
+        storeRoot = realpathSync(options.packagesDir);
+    }
+    catch {
+        return skip("package store does not exist");
+    }
+    const buildDirectories = (entryScripts) => new Set(entryScripts
+        .filter((entry) => entry !== undefined)
+        .map((entry) => buildDirectoryOf(storeRoot, entry))
+        .filter((name) => name !== null));
+    // Read again before every removal, not once: a pass can outlive the selection
+    // it started from. Null means the active selection no longer validates.
+    const readSelected = () => {
+        const active = readProxyPackageSelection(options.packagesDir);
+        if (!active) {
+            return null;
+        }
+        return buildDirectories([
+            active.entryScript,
+            readProxyPackageSelection(options.packagesDir, true)?.entryScript,
+            ...rawSelectedEntryScripts(options.packagesDir),
+        ]);
+    };
+    const selected = readSelected();
+    if (!selected) {
+        return skip("no validated active package selection");
+    }
+    const running = buildDirectories([options.currentEntryScript]);
+    const entries = await readdir(storeRoot, { withFileTypes: true });
+    const failed = [];
+    // A pass killed between rename and rm leaves a tombstone; nothing else reads it.
+    for (const entry of entries) {
+        if (!options.dryRun &&
+            entry.isDirectory() &&
+            entry.name.startsWith(TOMBSTONE_PREFIX)) {
+            await rm(join(storeRoot, entry.name), {
+                recursive: true,
+                force: true,
+            }).catch((error) => {
+                failed.push({ name: entry.name, message: String(error) });
+            });
+        }
+    }
+    const candidates = entries
+        .filter((entry) => entry.isDirectory() && GENERATED_BUILD_NAME.test(entry.name))
+        .map((entry) => entry.name)
+        .sort();
+    const unselected = candidates.filter((name) => !selected.has(name));
+    const processLines = unselected.length
+        ? await (options.listProcessCommandLines ?? listProcessCommandLines)()
+        : [];
+    if (processLines === null) {
+        return skip("running processes could not be enumerated");
+    }
+    const retained = candidates
+        .filter((name) => selected.has(name))
+        .map((name) => ({ name, reason: "selected" }));
+    const removed = [];
+    const now = options.now ?? Date.now();
+    const minAgeMs = options.minAgeMs ?? DEFAULT_MIN_AGE_MS;
+    // A process may name the store through a symlinked spelling (/var vs
+    // /private/var), so match the path as configured as well as the real one.
+    const storeSpellings = [
+        ...new Set([storeRoot, resolve(options.packagesDir)]),
+    ];
+    for (const name of unselected) {
+        const directory = join(storeRoot, name);
+        const retain = (reason) => {
+            retained.push({ name, reason });
+        };
+        if (running.has(name) ||
+            processLines.some((line) => storeSpellings.some((store) => mentionsDirectory(line, join(store, name))))) {
+            retain("in-use");
+            continue;
+        }
+        try {
+            const stats = await lstat(directory);
+            if (now - Math.max(stats.mtimeMs, stats.ctimeMs) < minAgeMs) {
+                retain("recent");
+                continue;
+            }
+            if (options.dryRun) {
+                removed.push(name);
+                continue;
+            }
+            // The only thing left between this check and the rename is the rename. A
+            // replacement updater may have selected this build, or taken over, since
+            // the pass began.
+            const latest = readSelected();
+            if (!latest) {
+                return {
+                    skipped: "package selection became invalid during the pass",
+                    removed,
+                    retained,
+                    failed,
+                };
+            }
+            if (latest.has(name)) {
+                retain("selected");
+                continue;
+            }
+            if (options.isCurrentOwner && !options.isCurrentOwner()) {
+                return {
+                    skipped: "update ownership changed during the pass",
+                    removed,
+                    retained,
+                    failed,
+                };
+            }
+            // Rename first: a half-deleted directory under its real name would pass
+            // installStagedProxyPackage's existsSync() shortcut and then fail validation.
+            const tombstone = join(storeRoot, `${TOMBSTONE_PREFIX}${name}-${randomUUID()}`);
+            await rename(directory, tombstone);
+            removed.push(name);
+            await rm(tombstone, { recursive: true, force: true });
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                failed.push({
+                    name,
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
+    return { removed, retained, failed };
+}

package/dist/types/proxy.d.ts

@@ -4456,6 +4456,36 @@ export type ProxyPackageUpgradeOptions = ProxyStagedInstallOptions & {
     isCurrentOwner?: () => boolean;
     onPolyfills?: (report: ProxyPackagePolyfillReport) => void;
 };
+/** Why a build in the package store was left alone by a retention pass. */
+export type ProxyPackagePruneRetention = "selected" | "in-use" | "recent";
+/** Retention pass over the immutable package store, with injectable process listing. */
+export type ProxyPackagePruneOptions = {
+    packagesDir: string;
+    /** Entry script of the calling process; its build is never removed. */
+    currentEntryScript?: string;
+    /** Builds written more recently than this are left for a later pass. */
+    minAgeMs?: number;
+    now?: number;
+    /** Report what would be removed without touching the store. */
+    dryRun?: boolean;
+    /** Checked before each removal; the pass stops as soon as it returns false. */
+    isCurrentOwner?: () => boolean;
+    /** Command lines of live processes, or null when they cannot be listed. */
+    listProcessCommandLines?: () => Promise<string[] | null>;
+};
+export type ProxyPackagePruneResult = {
+    /** Set when the pass declined to remove anything or stopped early, with the reason. */
+    skipped?: string;
+    removed: string[];
+    retained: {
+        name: string;
+        reason: ProxyPackagePruneRetention;
+    }[];
+    failed: {
+        name: string;
+        message: string;
+    }[];
+};
 /** Capture a trusted baseline for a locally patched package without activation. */
 export type ProxyPolyfillArgs = {
     action: "capture";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.54.0",
+  "version": "12.54.2",
   "packageManager": "pnpm@10.15.1",
   "description": "The pipe layer of an AI nervous system: one interface connecting provider neurons to your application, across three inference types — generate, stream and decide. `decide` returns typed, calibrated judgements from a non-generative model (~400ms, ~$0.00002/call) for routing, tool selection and context budgeting. MCP-native (4 transports), voice TTS/STT/realtime, RAG, agents, memory, compaction, 9 observability exporters. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · TypeSafe Jev and more.",
   "author": {
@@ -217,6 +217,7 @@
     "test:tool-dedup": "pnpm exec tsx test/continuous-test-suite-tool-dedup.ts",
     "test:tools-manager-truncation": "pnpm exec tsx test/continuous-test-suite-tools-manager-truncation.ts",
     "test:tooling-scripts": "pnpm exec tsx test/continuous-test-suite-tooling-scripts.ts",
+    "test:tooling-shell-safety": "pnpm exec tsx test/continuous-test-suite-tooling-shell-safety.ts",
     "test:model-not-found-retryable": "pnpm exec tsx test/continuous-test-suite-model-not-found-retryable.ts",
     "test:reasoning-parity-live": "pnpm exec tsx test/continuous-test-suite-reasoning-parity-live.ts",
     "test:ci": "pnpm run test && pnpm run test:client && pnpm run test:hitl",