@juspay/neurolink 12.14.5 → 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";
@@ -1400,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);
             }
@@ -2777,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",
@@ -2807,6 +2818,7 @@ async function runLaunchdProxySupervisor(argv, spinner) {
                 version: PROXY_VERSION,
                 updaterPid: currentUpdaterPid,
                 rolling: snapshot,
+                restartControl: restartControl?.identity,
             });
         },
         log: (message) => logger.always(message),
@@ -2843,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),
@@ -2872,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/restartControl.d.ts

@@ -0,0 +1,12 @@
+import type { ProxyRestartControlIdentity, ProxyRestartControlOptions, ProxyRestartResult } from "../types/index.js";
+/**
+ * Own restart completion in the supervisor, so a disconnected CLI cannot leave
+ * admission closed. The control socket is private to the service's OS user.
+ * No update history, launcher, environment file or launchd unit is rewritten.
+ */
+export declare function startProxyRestartControl(options: ProxyRestartControlOptions): Promise<{
+    identity: ProxyRestartControlIdentity;
+    close: () => Promise<void>;
+}>;
+/** Perform one local control operation; never fall back to killing a process. */
+export declare function requestProxyRestart(identity: ProxyRestartControlIdentity, check: boolean): Promise<ProxyRestartResult>;

package/dist/proxy/restartControl.js

@@ -0,0 +1,283 @@
+import { createServer, request } from "node:http";
+import { chmod, mkdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+const statusSchema = z.object({
+    pid: z.number().int().positive(),
+    version: z.string(),
+    health: z.object({
+        ready: z.literal(true),
+        acceptingConnections: z.literal(true),
+        drainingForUpdate: z.literal(false),
+    }),
+    observability: z.object({
+        requestLogs: z.object({
+            diskEnabled: z.boolean(),
+            otel: z.object({ initialized: z.boolean() }),
+        }),
+    }),
+});
+const resultSchema = z.object({
+    ok: z.boolean(),
+    phase: z.enum([
+        "checked",
+        "refused",
+        "failed",
+        "activated",
+        "activated_unverified",
+    ]),
+    message: z.string(),
+    supervisorPid: z.number().int().positive(),
+    previousWorkerPid: z.number().int().positive().optional(),
+    workerPid: z.number().int().positive().optional(),
+    version: z.string().optional(),
+    drainingWorkers: z.number().int().nonnegative(),
+    rejectedSocketsDelta: z.number().int().optional(),
+    failedTransfersDelta: z.number().int().optional(),
+});
+/**
+ * Own restart completion in the supervisor, so a disconnected CLI cannot leave
+ * admission closed. The control socket is private to the service's OS user.
+ * No update history, launcher, environment file or launchd unit is rewritten.
+ */
+export async function startProxyRestartControl(options) {
+    const instanceId = randomUUID();
+    const socketPath = join(options.stateDir, `restart-${process.pid}-${instanceId}.sock`);
+    await mkdir(options.stateDir, { recursive: true, mode: 0o700 });
+    // Never unlink an existing path: an unexpected owner must make setup fail.
+    let busy = false;
+    let closing = false;
+    const result = (phase, message) => {
+        const snapshot = options.server.snapshot();
+        return {
+            ok: phase === "checked" || phase === "activated",
+            phase,
+            message,
+            supervisorPid: process.pid,
+            workerPid: snapshot.active?.pid,
+            version: snapshot.active?.version,
+            drainingWorkers: snapshot.draining.length,
+        };
+    };
+    const assertIdle = () => {
+        const snapshot = options.server.snapshot();
+        if (closing || !snapshot.active) {
+            throw new Error("No serving worker is available for a rolling restart.");
+        }
+        if (snapshot.candidate || options.isUpdatePending()) {
+            throw new Error("An update or worker replacement is already in progress.");
+        }
+        if (snapshot.draining.length) {
+            throw new Error("A previous worker is still finishing requests; another restart is deferred.");
+        }
+    };
+    const operate = async (restart) => {
+        if (busy || closing) {
+            return result("refused", "A restart check or activation is already in progress.");
+        }
+        busy = true;
+        let activated = false;
+        let previousWorkerPid;
+        let handoffBaseline;
+        const transferDeltas = () => {
+            if (!handoffBaseline) {
+                return {};
+            }
+            const latest = options.server.snapshot();
+            return {
+                rejectedSocketsDelta: latest.rejectedSockets - handoffBaseline.rejectedSockets,
+                failedTransfersDelta: latest.failedTransfers - handoffBaseline.failedTransfers,
+            };
+        };
+        try {
+            assertIdle();
+            const before = options.server.snapshot();
+            const active = before.active;
+            if (!active) {
+                throw new Error("The serving worker exited during preflight.");
+            }
+            previousWorkerPid = active.pid;
+            const status = statusSchema.parse(await options.getStatus());
+            if (status.pid !== previousWorkerPid ||
+                status.version !== active.version) {
+                throw new Error("Serving worker identity changed during preflight; retry the check.");
+            }
+            const version = await options.getInstalledVersion();
+            if (!version || !/^\d+\.\d+\.\d+$/.test(version)) {
+                throw new Error("The configured worker executable did not report a valid installed version.");
+            }
+            assertIdle();
+            if (options.server.snapshot().active?.pid !== previousWorkerPid) {
+                throw new Error("Serving worker changed during preflight; retry the check.");
+            }
+            if (!restart) {
+                return {
+                    ...result("checked", "Rolling restart is available. Service settings and existing streams will be preserved."),
+                    version,
+                };
+            }
+            // The existing supervisor imposes a 120-second candidate readiness
+            // deadline and retains the serving worker when startup/activation fails.
+            // It switches new sockets before draining the previous generation.
+            handoffBaseline = options.server.snapshot();
+            const after = await options.server.replace(version);
+            activated = true;
+            const fresh = statusSchema.parse(await options.getStatus());
+            if (fresh.pid !== after.active?.pid ||
+                fresh.pid === previousWorkerPid ||
+                fresh.version !== version) {
+                throw new Error("The replacement's serving identity could not be verified.");
+            }
+            const beforeLogs = status.observability.requestLogs;
+            const afterLogs = fresh.observability.requestLogs;
+            // Preserve the selected sink in both directions. Unexpected disk writes
+            // regress OTel-only deployments; disabling an existing disk sink loses
+            // requested logs. Restart must not silently make either policy change.
+            if (beforeLogs.diskEnabled !== afterLogs.diskEnabled ||
+                (beforeLogs.otel.initialized && !afterLogs.otel.initialized)) {
+                throw new Error("The replacement's logging state regressed; inspect telemetry before further changes.");
+            }
+            const latest = options.server.snapshot();
+            const deltas = transferDeltas();
+            // These are observed failures, not attribution to the restart. A ready
+            // worker can coexist with a handoff whose no-loss claim is unverified.
+            if (latest.active?.pid !== fresh.pid ||
+                deltas.rejectedSocketsDelta !== 0 ||
+                deltas.failedTransfersDelta !== 0) {
+                throw new Error("Worker identity or socket transfer counters changed during verification.");
+            }
+            return {
+                ...result("activated", "Replacement is serving and accepting requests. Previous streams finish on their original worker."),
+                previousWorkerPid,
+                ...deltas,
+            };
+        }
+        catch (error) {
+            // Schema errors contain paths only; never echo the status payload or env.
+            const message = error instanceof z.ZodError
+                ? "Readiness, admission or logging status could not be verified."
+                : error instanceof Error
+                    ? error.message
+                    : "Restart verification failed.";
+            return {
+                ...result(activated ? "activated_unverified" : "failed", message),
+                previousWorkerPid,
+                ...transferDeltas(),
+            };
+        }
+        finally {
+            busy = false;
+        }
+    };
+    const control = createServer((req, res) => {
+        // The instance nonce prevents a stale client from acting on a reused path.
+        if (closing || req.headers["x-neurolink-instance"] !== instanceId) {
+            res.writeHead(409).end();
+            return;
+        }
+        if (req.headers["transfer-encoding"] ||
+            (req.headers["content-length"] && req.headers["content-length"] !== "0")) {
+            res.writeHead(400, { connection: "close" }).end();
+            return;
+        }
+        if (!((req.method === "GET" && req.url === "/check") ||
+            (req.method === "POST" && req.url === "/restart"))) {
+            res.writeHead(404).end();
+            return;
+        }
+        req.resume();
+        void operate(req.method === "POST")
+            .then((outcome) => {
+            if (res.destroyed || res.writableEnded) {
+                return;
+            }
+            res.writeHead(outcome.ok ? 200 : 409, {
+                "content-type": "application/json",
+                connection: "close",
+            });
+            res.end(JSON.stringify(outcome));
+        })
+            .catch(() => {
+            if (res.destroyed || res.writableEnded) {
+                return;
+            }
+            res.writeHead(500).end();
+        });
+    });
+    control.headersTimeout = 5_000;
+    control.requestTimeout = 5_000;
+    control.maxHeadersCount = 10;
+    control.maxConnections = 16;
+    await new Promise((resolve, reject) => {
+        control.once("error", reject);
+        control.listen(socketPath, () => {
+            control.off("error", reject);
+            // Keep handling errors after binding: a control-plane accept failure
+            // must not become an unhandled event that stops the serving listener.
+            control.on("error", (error) => {
+                options.log?.(`[proxy-supervisor] safe restart control error: ${error.message}`);
+            });
+            resolve();
+        });
+    });
+    try {
+        await chmod(socketPath, 0o600);
+    }
+    catch (error) {
+        control.close();
+        throw error;
+    }
+    return {
+        identity: { protocol: 1, socketPath, instanceId },
+        close: async () => {
+            closing = true;
+            control.closeAllConnections();
+            await new Promise((resolve) => control.close(() => resolve()));
+            await rm(socketPath, { force: true });
+        },
+    };
+}
+/** Perform one local control operation; never fall back to killing a process. */
+export async function requestProxyRestart(identity, check) {
+    return new Promise((resolve, reject) => {
+        const req = request({
+            socketPath: identity.socketPath,
+            path: check ? "/check" : "/restart",
+            method: check ? "GET" : "POST",
+            headers: {
+                "x-neurolink-instance": identity.instanceId,
+                connection: "close",
+            },
+        });
+        const timeout = setTimeout(() => req.destroy(new Error("Restart result timed out; outcome is unknown. Inspect proxy status before retrying.")), check ? 15_000 : 150_000);
+        req.once("error", (error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+        req.once("response", (res) => {
+            let body = "";
+            res.setEncoding("utf8");
+            res.on("data", (chunk) => {
+                body += chunk;
+                if (body.length > 65_536) {
+                    req.destroy(new Error("Invalid restart control response."));
+                }
+            });
+            res.once("error", (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+            res.once("end", () => {
+                clearTimeout(timeout);
+                try {
+                    resolve(resultSchema.parse(JSON.parse(body)));
+                }
+                catch {
+                    reject(new Error("Restart control did not return a verified result; no service restart fallback was attempted."));
+                }
+            });
+        });
+        req.end();
+    });
+}

package/dist/proxy/rollingWorkerSupervisor.js

@@ -253,6 +253,14 @@ export class RollingWorkerSupervisor {
                     if (this.candidate?.generation === generation) {
                         this.candidate = null;
                     }
+                    // A candidate that never became ready may also ignore SIGTERM.
+                    // Bound its cleanup independently of the still-serving generation.
+                    const killTimeout = setTimeout(() => handle.terminate("SIGKILL"), 1_000);
+                    killTimeout.unref?.();
+                    const offCandidateExit = handle.onExit(() => {
+                        clearTimeout(killTimeout);
+                        offCandidateExit();
+                    });
                     handle.terminate("SIGTERM");
                     dispose();
                     this.publishState();

package/dist/types/index.d.ts

@@ -95,3 +95,4 @@ export * from "./classifierRouter.js";
 export * from "./agentNetwork.js";
 export * from "./localUsage.js";
 export * from "./dispatch.js";
+export * from "./proxyRestart.js";

package/dist/types/index.js

@@ -110,3 +110,4 @@ export * from "./agentNetwork.js";
 export * from "./localUsage.js";
 // resolveRequestKind() dispatch-decision types
 export * from "./dispatch.js";
+export * from "./proxyRestart.js";

package/dist/types/proxyRestart.d.ts

@@ -0,0 +1,49 @@
+import type { RollingProxyServer } from "./proxy.js";
+import type { ProxySupervisorState } from "./cli.js";
+/** Supervisor state with the optional local restart capability. */
+export type ProxyRestartSupervisorState = ProxySupervisorState & {
+    restartControl?: ProxyRestartControlIdentity;
+};
+export type ProxyRestartArgs = {
+    check: boolean;
+    dev: boolean;
+    format: "text" | "json";
+};
+/** Local supervisor control identity; contains no account credentials. */
+export type ProxyRestartControlIdentity = {
+    protocol: 1;
+    socketPath: string;
+    instanceId: string;
+};
+/** Terminal result of a local restart check or worker activation. */
+export type ProxyRestartResult = {
+    ok: boolean;
+    phase: "checked" | "refused" | "failed" | "activated" | "activated_unverified";
+    message: string;
+    supervisorPid: number;
+    previousWorkerPid?: number;
+    workerPid?: number;
+    version?: string;
+    drainingWorkers: number;
+    /** Observed during handoff/verification; does not attribute the cause. */
+    rejectedSocketsDelta?: number;
+    failedTransfersDelta?: number;
+};
+/** CLI failure before a supervisor result can be authenticated or received. */
+export type CliProxyRestartError = {
+    ok: false;
+    phase: "unverified";
+    message: string;
+};
+/** JSON emitted by the restart CLI, including an unknown control outcome. */
+export type CliProxyRestartOutput = ProxyRestartResult | CliProxyRestartError;
+/** Supervisor-owned restart dependencies, injectable for isolated process tests. */
+export type ProxyRestartControlOptions = {
+    stateDir: string;
+    server: RollingProxyServer;
+    getInstalledVersion: () => Promise<string | undefined>;
+    isUpdatePending: () => boolean;
+    getStatus: () => Promise<unknown>;
+    /** Report control-server errors without stopping the serving listener. */
+    log?: (message: string) => void;
+};

package/dist/types/proxyRestart.js

@@ -0,0 +1 @@
+export {};