@nowcrew/daemon 0.5.26 → 0.5.27

package/dist/execution-supervisor.js

@@ -67,10 +67,12 @@ async function signalOwnedTreeIfPresent(pid, signal, platform, signalTree) {
             throw error;
     }
 }
-async function terminateAndConfirmOwnedTree(pid, platform, timeoutMs, supervisorClosed, signalTree) {
+async function terminateAndConfirmOwnedTree(pid, platform, timeoutMs, supervisorExited, hasSupervisorExited, signalTree) {
     const waitUntilStopped = () => platform === "win32"
-        ? waitForExit(supervisorClosed.then(() => ({ exitCode: 0 })), timeoutMs, pid)
+        ? waitForExit(supervisorExited.then(() => ({ exitCode: 0 })), timeoutMs, pid)
         : waitForProcessGroupExit(pid, timeoutMs);
+    if (platform === "win32" && hasSupervisorExited())
+        return;
     let termError;
     try {
         await signalOwnedTreeIfPresent(pid, "SIGTERM", platform, signalTree);
@@ -78,6 +80,8 @@ async function terminateAndConfirmOwnedTree(pid, platform, timeoutMs, supervisor
         return;
     }
     catch (error) {
+        if (platform === "win32" && hasSupervisorExited())
+            return;
         termError = error;
     }
     try {
@@ -85,13 +89,15 @@ async function terminateAndConfirmOwnedTree(pid, platform, timeoutMs, supervisor
         await waitUntilStopped();
     }
     catch (killError) {
+        if (platform === "win32" && hasSupervisorExited())
+            return;
         throw new AggregateError([termError, killError], "Supervisor process-tree termination failed");
     }
 }
-async function confirmOrTerminateOwnedTree(pid, platform, timeoutMs, supervisorClosed, signalTree) {
+async function confirmOrTerminateOwnedTree(pid, platform, timeoutMs, supervisorExited, hasSupervisorExited, signalTree) {
     if (platform !== "win32" && !(await processGroupExists(pid)))
         return;
-    await terminateAndConfirmOwnedTree(pid, platform, timeoutMs, supervisorClosed, signalTree);
+    await terminateAndConfirmOwnedTree(pid, platform, timeoutMs, supervisorExited, hasSupervisorExited, signalTree);
 }
 async function withTimeout(promise, timeoutMs, phase) {
     let timer;
@@ -174,9 +180,17 @@ export async function startDormantSupervisor(launch, options = {}) {
         }));
     });
     const supervisorClosed = new Promise((resolve) => child.once("close", () => resolve()));
+    // Windows PID ownership ends at `exit`; `close` may lag while stdio/IPC handles drain.
+    let didSupervisorExit = false;
+    const supervisorExited = new Promise((resolve) => {
+        child.once("exit", () => {
+            didSupervisorExit = true;
+            resolve();
+        });
+    });
     let treeStopPromise = null;
     const ensureTreeStopped = () => {
-        treeStopPromise ??= confirmOrTerminateOwnedTree(pid, platform, abortTimeoutMs, supervisorClosed, signalTree);
+        treeStopPromise ??= confirmOrTerminateOwnedTree(pid, platform, abortTimeoutMs, supervisorExited, () => didSupervisorExit, signalTree);
         return treeStopPromise;
     };
     const exit = supervisorExit.then(async (result) => {

package/dist/remote/claude-bridge.js

@@ -0,0 +1,402 @@
+import { randomUUID } from "node:crypto";
+import { createInterface } from "node:readline";
+import { query, } from "@anthropic-ai/claude-agent-sdk";
+import { WebSocket } from "ws";
+import { z } from "zod";
+import { toConsoleLines } from "../console.js";
+import { ChannelToGatewaySchema, GatewayToChannelSchema, REMOTE_PROTOCOL_VERSION, } from "./protocol.js";
+import { resolveClaudeWrapperSession } from "./wrapper.js";
+class InputStream {
+    values = [];
+    waiters = [];
+    stopped = false;
+    push(value) {
+        if (this.stopped)
+            return;
+        const waiter = this.waiters.shift();
+        if (waiter)
+            waiter({ value, done: false });
+        else
+            this.values.push(value);
+    }
+    close() {
+        this.stopped = true;
+        for (const waiter of this.waiters.splice(0))
+            waiter({ value: undefined, done: true });
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                const value = this.values.shift();
+                if (value)
+                    return Promise.resolve({ value, done: false });
+                if (this.stopped)
+                    return Promise.resolve({ value: undefined, done: true });
+                return new Promise((resolve) => this.waiters.push(resolve));
+            },
+        };
+    }
+}
+const AskQuestionInputSchema = z.object({
+    questions: z.array(z.object({
+        question: z.string().min(1),
+        header: z.string().default("Question"),
+        options: z.array(z.object({
+            label: z.string(),
+            description: z.string().default(""),
+        }).passthrough()).default([]),
+    }).passthrough()).min(1).max(4),
+}).passthrough();
+function takeValue(args, index, option) {
+    const value = args[index + 1];
+    if (!value || value.startsWith("-"))
+        throw new Error(`${option} requires a value`);
+    return value;
+}
+function splitTools(value) {
+    return value.split(/[ ,]+/).map((part) => part.trim()).filter(Boolean);
+}
+export function parseClaudeBridgeArgs(userArgs) {
+    const resolved = resolveClaudeWrapperSession(userArgs);
+    const options = {};
+    const prompts = [];
+    let title;
+    const args = resolved.args;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        const inline = (name) => arg.startsWith(`${name}=`) ? arg.slice(name.length + 1) : null;
+        if (["--session-id", "--resume", "-r"].includes(arg)) {
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--session-id=") || arg.startsWith("--resume="))
+            continue;
+        if (arg === "--model" || arg === "--effort" || arg === "--permission-mode" || arg === "--name" || arg === "-n"
+            || arg === "--add-dir" || arg === "--allowedTools" || arg === "--allowed-tools"
+            || arg === "--disallowedTools" || arg === "--disallowed-tools" || arg === "--settings") {
+            const value = takeValue(args, index, arg);
+            index += 1;
+            if (arg === "--model")
+                options.model = value;
+            else if (arg === "--effort")
+                options.effort = z.enum(["low", "medium", "high", "xhigh", "max"]).parse(value);
+            else if (arg === "--permission-mode")
+                options.permissionMode = z.enum(["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"]).parse(value);
+            else if (arg === "--name" || arg === "-n")
+                title = value;
+            else if (arg === "--add-dir")
+                (options.additionalDirectories ??= []).push(value);
+            else if (arg === "--allowedTools" || arg === "--allowed-tools")
+                options.allowedTools = splitTools(value);
+            else if (arg === "--disallowedTools" || arg === "--disallowed-tools")
+                options.disallowedTools = splitTools(value);
+            else
+                options.settings = value;
+            continue;
+        }
+        const model = inline("--model");
+        const effort = inline("--effort");
+        const permission = inline("--permission-mode");
+        const name = inline("--name");
+        if (model !== null)
+            options.model = model;
+        else if (effort !== null)
+            options.effort = z.enum(["low", "medium", "high", "xhigh", "max"]).parse(effort);
+        else if (permission !== null)
+            options.permissionMode = z.enum(["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"]).parse(permission);
+        else if (name !== null)
+            title = name;
+        else if (arg === "--dangerously-skip-permissions") {
+            options.permissionMode = "bypassPermissions";
+            options.allowDangerouslySkipPermissions = true;
+        }
+        else if (arg.startsWith("-")) {
+            throw new Error(`Claude mobile bridge does not support ${arg}`);
+        }
+        else
+            prompts.push(arg);
+    }
+    const hasResume = userArgs.some((value) => value === "--resume" || value === "-r" || value.startsWith("--resume="));
+    return {
+        sessionId: resolved.sessionId,
+        resume: hasResume,
+        ...(title === undefined ? {} : { title }),
+        ...(prompts.length === 0 ? {} : { initialPrompt: prompts.join(" ") }),
+        options,
+    };
+}
+function userMessage(sessionId, text) {
+    return {
+        type: "user",
+        message: { role: "user", content: text },
+        parent_tool_use_id: null,
+        session_id: sessionId,
+    };
+}
+function preview(input) {
+    const command = typeof input.command === "string" ? input.command : null;
+    const path = typeof input.file_path === "string" ? input.file_path : null;
+    return (command ?? path ?? JSON.stringify(input)).slice(0, 16_000);
+}
+function printMessage(message) {
+    let printedText = false;
+    for (const line of toConsoleLines(message)) {
+        if (line.stream === "result" || !line.text.trim())
+            continue;
+        if (line.stream === "text")
+            printedText = true;
+        const prefix = line.stream === "thinking" ? "Thinking: "
+            : line.stream === "tool" ? "Tool: "
+                : line.stream === "tool_result" ? "Result: "
+                    : line.stream === "error" ? "Error: " : "";
+        process.stdout.write(`\n${prefix}${line.text}\n`);
+    }
+    return printedText;
+}
+export async function runClaudeBridge(userArgs, context) {
+    const parsed = parseClaudeBridgeArgs(userArgs);
+    const generation = randomUUID();
+    const inputStream = new InputStream();
+    const inputs = [];
+    const interactions = new Map();
+    const terminalInteractions = [];
+    let terminalHandler = null;
+    let active = null;
+    let stopped = false;
+    let socket = null;
+    let reconnectTimer;
+    let assistantPrinted = false;
+    const url = new URL("/ws/channel", context.gatewayUrl);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    const send = (value) => {
+        if (socket?.readyState === WebSocket.OPEN)
+            socket.send(JSON.stringify(ChannelToGatewaySchema.parse(value)));
+    };
+    const register = () => send({
+        type: "channel.register",
+        protocolVersion: REMOTE_PROTOCOL_VERSION,
+        sessionId: parsed.sessionId,
+        cwd: context.cwd,
+        pid: process.pid,
+        generation,
+        ...(parsed.title === undefined ? {} : { title: parsed.title }),
+    });
+    const finishInteraction = (requestId, value, local) => {
+        const interaction = interactions.get(requestId);
+        if (!interaction)
+            return;
+        interactions.delete(requestId);
+        const index = terminalInteractions.indexOf(requestId);
+        if (index >= 0)
+            terminalInteractions.splice(index, 1);
+        terminalHandler = null;
+        interaction.resolve(value);
+        if (local)
+            send({
+                type: "bridge.resolved",
+                protocolVersion: REMOTE_PROTOCOL_VERSION,
+                sessionId: parsed.sessionId,
+                requestId,
+            });
+    };
+    const connectGateway = () => new Promise((resolve, reject) => {
+        const next = new WebSocket(url, { headers: { authorization: `Bearer ${context.token}` } });
+        socket = next;
+        next.once("open", () => {
+            register();
+            if (active)
+                send({ type: "bridge.status", protocolVersion: REMOTE_PROTOCOL_VERSION, sessionId: parsed.sessionId, busy: true });
+            for (const interaction of interactions.values())
+                send(interaction.requestFrame);
+            resolve();
+        });
+        next.on("message", (raw) => {
+            let decoded;
+            try {
+                decoded = JSON.parse(raw.toString());
+            }
+            catch {
+                return;
+            }
+            const frame = GatewayToChannelSchema.safeParse(decoded);
+            if (!frame.success)
+                return;
+            if (frame.data.type === "channel.prompt")
+                enqueue({ text: frame.data.text, requestId: frame.data.requestId });
+            else if (frame.data.type === "bridge.approval_response") {
+                finishInteraction(frame.data.requestId, { decision: frame.data.decision }, false);
+            }
+            else if (frame.data.type === "bridge.question_response") {
+                finishInteraction(frame.data.requestId, { answers: frame.data.answers }, false);
+            }
+        });
+        next.once("error", reject);
+        next.on("close", () => {
+            if (socket === next)
+                socket = null;
+            if (!stopped)
+                reconnectTimer = setTimeout(() => { void connectGateway().catch(() => { }); }, 1_000);
+        });
+    });
+    const sendNext = () => {
+        if (active || inputs.length === 0 || stopped)
+            return;
+        active = inputs.shift();
+        assistantPrinted = false;
+        inputStream.push(userMessage(parsed.sessionId, active.text));
+        send({ type: "bridge.status", protocolVersion: REMOTE_PROTOCOL_VERSION, sessionId: parsed.sessionId, busy: true });
+    };
+    function enqueue(value) {
+        inputs.push(value);
+        sendNext();
+    }
+    const waitForInteraction = (interaction, render, handleLine) => {
+        const promise = new Promise((resolve) => {
+            interactions.set(interaction.id, { ...interaction, resolve });
+        });
+        terminalInteractions.push(interaction.id);
+        render();
+        terminalHandler = (line) => {
+            const result = handleLine(line);
+            if (result)
+                finishInteraction(interaction.id, result, true);
+        };
+        return promise;
+    };
+    const canUseTool = async (toolName, input, { signal }) => {
+        const requestId = randomUUID();
+        if (toolName === "AskUserQuestion") {
+            const parsedQuestions = AskQuestionInputSchema.safeParse(input);
+            if (!parsedQuestions.success)
+                return { behavior: "deny", message: "Unsupported question format" };
+            const questions = parsedQuestions.data.questions.map((question, index) => ({
+                id: `q${index}`,
+                header: question.header,
+                question: question.question,
+                isSecret: false,
+                options: question.options,
+            }));
+            const requestFrame = {
+                type: "bridge.question",
+                protocolVersion: REMOTE_PROTOCOL_VERSION,
+                sessionId: parsed.sessionId,
+                requestId,
+                questions,
+            };
+            send(requestFrame);
+            const waiting = waitForInteraction({ id: requestId, kind: "question", questions, requestFrame }, () => {
+                process.stdout.write("\nInput needed:\n");
+                for (const [index, question] of questions.entries()) {
+                    process.stdout.write(`${index + 1}. ${question.header}: ${question.question}\n`);
+                    for (const option of question.options)
+                        process.stdout.write(`   - ${option.label}: ${option.description}\n`);
+                }
+                process.stdout.write("Answer: ");
+            }, (line) => {
+                const values = line.split(";").map((value) => value.trim());
+                return { answers: Object.fromEntries(questions.map((question, index) => [question.id, [values[index] ?? ""]])) };
+            });
+            signal.addEventListener("abort", () => finishInteraction(requestId, { decision: "deny" }, true), { once: true });
+            const result = await waiting;
+            if (!result.answers)
+                return { behavior: "deny", message: "User input cancelled" };
+            const answers = Object.fromEntries(questions.map((question) => [
+                question.question,
+                result.answers?.[question.id]?.join(", ") ?? "",
+            ]));
+            return { behavior: "allow", updatedInput: { ...input, answers } };
+        }
+        const requestFrame = {
+            type: "bridge.approval",
+            protocolVersion: REMOTE_PROTOCOL_VERSION,
+            sessionId: parsed.sessionId,
+            requestId,
+            tool: toolName,
+            preview: preview(input),
+        };
+        send(requestFrame);
+        const waiting = waitForInteraction({ id: requestId, kind: "approval", requestFrame }, () => process.stdout.write(`\nApproval required: ${toolName}\n${preview(input)}\nAllow? `), (line) => /^(y|yes|allow)$/i.test(line.trim()) ? { decision: "allow" }
+            : /^(n|no|deny)$/i.test(line.trim()) ? { decision: "deny" } : null);
+        signal.addEventListener("abort", () => finishInteraction(requestId, { decision: "deny" }, true), { once: true });
+        const result = await waiting;
+        return result.decision === "allow"
+            ? { behavior: "allow", updatedInput: input }
+            : { behavior: "deny", message: "User denied this action" };
+    };
+    await connectGateway();
+    const conversation = query({
+        prompt: inputStream,
+        options: {
+            cwd: context.cwd,
+            canUseTool,
+            settingSources: ["user", "project", "local"],
+            includePartialMessages: false,
+            ...(parsed.resume ? { resume: parsed.sessionId } : { sessionId: parsed.sessionId }),
+            ...parsed.options,
+            ...(process.env.NOWCREW_CLAUDE_BIN ? { pathToClaudeCodeExecutable: process.env.NOWCREW_CLAUDE_BIN } : {}),
+        },
+    });
+    const terminal = createInterface({ input: process.stdin, output: process.stdout });
+    terminal.setPrompt("› ");
+    terminal.on("line", (line) => {
+        if (terminalHandler && terminalInteractions.length > 0)
+            terminalHandler(line);
+        else if (line.trim())
+            enqueue({ text: line.trim(), requestId: null });
+        terminal.prompt();
+    });
+    terminal.on("close", () => { stopped = true; conversation.close(); });
+    process.stdout.write(`Claude mobile session ${parsed.sessionId}\n`);
+    terminal.prompt();
+    if (parsed.initialPrompt)
+        enqueue({ text: parsed.initialPrompt, requestId: null });
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        if (reconnectTimer)
+            clearTimeout(reconnectTimer);
+        inputStream.close();
+        conversation.close();
+        terminal.close();
+        socket?.close();
+        for (const id of [...interactions.keys()])
+            finishInteraction(id, { decision: "deny" }, true);
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    try {
+        for await (const message of conversation) {
+            if (message.type === "assistant")
+                assistantPrinted = printMessage(message) || assistantPrinted;
+            else
+                printMessage(message);
+            if (message.type !== "result")
+                continue;
+            const result = message.subtype === "success" && "result" in message && typeof message.result === "string"
+                ? message.result.trim()
+                : "";
+            if (!assistantPrinted && result)
+                process.stdout.write(`\n${result}\n`);
+            const completedInput = active;
+            if (completedInput?.requestId && result)
+                send({
+                    type: "channel.reply",
+                    protocolVersion: REMOTE_PROTOCOL_VERSION,
+                    sessionId: parsed.sessionId,
+                    requestId: completedInput.requestId,
+                    text: result,
+                });
+            active = null;
+            send({ type: "bridge.status", protocolVersion: REMOTE_PROTOCOL_VERSION, sessionId: parsed.sessionId, busy: false });
+            terminal.prompt();
+            sendNext();
+        }
+        return stopped ? 0 : 1;
+    }
+    finally {
+        process.off("SIGINT", stop);
+        process.off("SIGTERM", stop);
+        stop();
+    }
+}

package/dist/remote/claude-channel.js

@@ -0,0 +1,164 @@
+import { readFile } from "node:fs/promises";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, NotificationSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { WebSocket } from "ws";
+import { z } from "zod";
+import { z as z4 } from "zod/v4";
+import { ChannelToGatewaySchema, GatewayToChannelSchema, REMOTE_PROTOCOL_VERSION, } from "./protocol.js";
+const PermissionRequestSchema = NotificationSchema.extend({
+    method: z4.literal("notifications/claude/channel/permission_request"),
+    params: z4.object({
+        request_id: z4.string().regex(/^[a-km-z]{5}$/),
+        tool_name: z4.string(),
+        description: z4.string(),
+        input_preview: z4.string(),
+    }),
+});
+const ChannelEnvironmentSchema = z.object({
+    NOWCREW_REMOTE_URL: z.string().url(),
+    NOWCREW_REMOTE_TOKEN_FILE: z.string().min(1),
+    NOWCREW_REMOTE_SESSION_ID: z.string().uuid(),
+    NOWCREW_REMOTE_GENERATION: z.string().uuid(),
+    NOWCREW_REMOTE_CWD: z.string().min(1),
+}).passthrough();
+export function createClaudeChannelServer(sendToGateway) {
+    const mcp = new Server({ name: "nowcrew", version: "1.0.0" }, {
+        capabilities: {
+            experimental: {
+                "claude/channel": {},
+                "claude/channel/permission": {},
+            },
+            tools: {},
+        },
+        instructions: "Messages from the user's authenticated NowCrew phone arrive as <channel source=\"nowcrew\" request_id=\"...\">. "
+            + "Handle them as direct user requests in this session. Render the complete user-facing answer normally in the terminal, "
+            + "then call the reply tool exactly once with the same complete answer and request_id so the phone stays synchronized.",
+    });
+    mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [{
+                name: "reply",
+                description: "Send the complete user-facing answer back to the authenticated NowCrew phone",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        request_id: { type: "string", format: "uuid" },
+                        text: { type: "string", minLength: 1 },
+                    },
+                    required: ["request_id", "text"],
+                    additionalProperties: false,
+                },
+            }],
+    }));
+    mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
+        if (request.params.name !== "reply")
+            throw new Error(`unknown tool: ${request.params.name}`);
+        const args = z.object({ request_id: z.string().uuid(), text: z.string().min(1).max(200_000) })
+            .parse(request.params.arguments);
+        sendToGateway({ type: "reply", ...args });
+        return { content: [{ type: "text", text: "sent" }] };
+    });
+    mcp.setNotificationHandler(PermissionRequestSchema, ({ params }) => {
+        sendToGateway({
+            type: "permission",
+            requestId: params.request_id,
+            tool: params.tool_name,
+            description: params.description,
+            preview: params.input_preview,
+        });
+    });
+    return mcp;
+}
+export async function runClaudeChannel(env = process.env) {
+    const parsed = ChannelEnvironmentSchema.parse(env);
+    const token = (await readFile(parsed.NOWCREW_REMOTE_TOKEN_FILE, "utf8")).trim();
+    const url = new URL("/ws/channel", parsed.NOWCREW_REMOTE_URL);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    let socket = null;
+    const queued = [];
+    const send = (value) => {
+        if (socket?.readyState === WebSocket.OPEN)
+            socket.send(JSON.stringify(value));
+        else
+            queued.push(value);
+    };
+    const mcp = createClaudeChannelServer((value) => {
+        const record = value;
+        if (record.type === "reply") {
+            send(ChannelToGatewaySchema.parse({
+                type: "channel.reply",
+                protocolVersion: REMOTE_PROTOCOL_VERSION,
+                sessionId: parsed.NOWCREW_REMOTE_SESSION_ID,
+                requestId: record.request_id,
+                text: record.text,
+            }));
+            return;
+        }
+        send(ChannelToGatewaySchema.parse({
+            type: "channel.permission",
+            protocolVersion: REMOTE_PROTOCOL_VERSION,
+            sessionId: parsed.NOWCREW_REMOTE_SESSION_ID,
+            requestId: record.requestId,
+            tool: record.tool,
+            description: record.description,
+            preview: record.preview,
+        }));
+    });
+    await mcp.connect(new StdioServerTransport());
+    let stopped = false;
+    const connect = () => {
+        if (stopped)
+            return;
+        const next = new WebSocket(url, { headers: { authorization: `Bearer ${token}` } });
+        socket = next;
+        next.on("open", () => {
+            next.send(JSON.stringify(ChannelToGatewaySchema.parse({
+                type: "channel.register",
+                protocolVersion: REMOTE_PROTOCOL_VERSION,
+                sessionId: parsed.NOWCREW_REMOTE_SESSION_ID,
+                cwd: parsed.NOWCREW_REMOTE_CWD,
+                pid: process.ppid,
+                generation: parsed.NOWCREW_REMOTE_GENERATION,
+            })));
+            for (const value of queued.splice(0))
+                next.send(JSON.stringify(value));
+        });
+        next.on("message", (raw) => {
+            const frame = GatewayToChannelSchema.safeParse(JSON.parse(raw.toString()));
+            if (!frame.success)
+                return;
+            if (frame.data.type === "channel.prompt") {
+                void mcp.notification({
+                    method: "notifications/claude/channel",
+                    params: {
+                        content: frame.data.text,
+                        meta: { request_id: frame.data.requestId },
+                    },
+                });
+            }
+            else if (frame.data.type === "channel.permission_response") {
+                void mcp.notification({
+                    method: "notifications/claude/channel/permission",
+                    params: {
+                        request_id: frame.data.requestId,
+                        behavior: frame.data.decision,
+                    },
+                });
+            }
+        });
+        next.on("close", () => {
+            if (socket === next)
+                socket = null;
+            if (!stopped)
+                setTimeout(connect, 1_000).unref();
+        });
+        next.on("error", () => { });
+    };
+    connect();
+    const stop = () => {
+        stopped = true;
+        socket?.close();
+    };
+    process.once("SIGTERM", stop);
+    process.once("SIGINT", stop);
+}