@selesai/code 0.13.39 → 0.13.40

package/dist/modes/rpc/rpc-client.js

@@ -173,6 +173,49 @@ export class RpcClient {
     /**
      * Get current session state.
      */
+    /** Read-only native subagent snapshot; never invokes a model. */
+    async subagentStatus() {
+        return this.getData(await this.send({ type: "subagent_status", version: 1 }));
+    }
+    /** Authoritative "is it safe to stop this process now" answer; never invokes a model. */
+    async releaseReadiness() {
+        return this.getData(await this.send({ type: "release_readiness", version: 1 }));
+    }
+    /**
+     * Atomic "release if safe". `released: true` means the process has committed to a gentle exit (code 0, no abort) and rejects
+     * every further command except `release`/`release_readiness`; `released: false` carries the blockers and the process keeps running.
+     * "Nobody answered" (no extension contributors) is never released.
+     */
+    async release() {
+        return this.getData(await this.send({ type: "release", version: 1 }));
+    }
+    /**
+     * DESTRUCTIVE kill switch for an explicit user "Quit anyway": aborts the turn (retry, compaction, bash, queued messages), stops every
+     * async/detached subagent run of this session (detached runners terminate on their own), disarms this session's session-only
+     * schedules (paused, project schedules untouched) and cancels pending outbound intercom asks. Per-item failures are `ok:false`
+     * in `stopped`; `remaining` is the readiness computed after the stop. Idempotent; refused while the session is releasing.
+     */
+    async stopAllBackground() {
+        return this.getData(await this.send({ type: "stop_all_background", version: 1 }));
+    }
+    async intercomStatus() {
+        return this.getData(await this.send({ type: "intercom_status" }));
+    }
+    async intercomList() {
+        return this.getData(await this.send({ type: "intercom_list" }));
+    }
+    async intercomPending() {
+        return this.getData(await this.send({ type: "intercom_pending" }));
+    }
+    async intercomSend(to, options) {
+        return this.getData(await this.send({ type: "intercom_send", to, ...options }));
+    }
+    async intercomAsk(to, options) {
+        return this.getData(await this.send({ type: "intercom_ask", to, ...options }, (options.timeoutMs ?? 600_000) + 5000));
+    }
+    async intercomReply(options) {
+        return this.getData(await this.send({ type: "intercom_reply", ...options }));
+    }
     async getState() {
         const response = await this.send({ type: "get_state" });
         return this.getData(response);
@@ -652,7 +695,7 @@ export class RpcClient {
         }
         this.pendingRequests.clear();
     }
-    async send(command) {
+    async send(command, timeoutMs = 35_000) {
         const childProcess = this.process;
         const stdin = childProcess?.stdin;
         if (!childProcess || !stdin) {
@@ -677,7 +720,7 @@ export class RpcClient {
             const timeout = setTimeout(() => {
                 this.pendingRequests.delete(id);
                 reject(new Error(`Timeout waiting for response to ${command.type}. Stderr: ${this.stderr}`));
-            }, 30000);
+            }, timeoutMs);
             this.pendingRequests.set(id, {
                 resolve: (response) => {
                     clearTimeout(timeout);

package/dist/modes/rpc/rpc-intercom-transport.test.d.ts

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

package/dist/modes/rpc/rpc-intercom-transport.test.js

@@ -0,0 +1,85 @@
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { mkdtempSync, rmSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { describe, expect, it } from "vitest";
+import { RpcClient } from "./rpc-client.js";
+// Run after npm run build: exercises built SDK host JSONL transport, avoiding unrelated CLI onboarding.
+describe("Intercom RPC JSONL transport", () => {
+    it("starts the bundled standalone broker without a host-package alias", async () => {
+        const agentDir = mkdtempSync(join(tmpdir(), "rpc-broker-"));
+        const require = createRequire(import.meta.url);
+        const tsxCli = join(dirname(require.resolve("tsx")), "cli.mjs");
+        const broker = spawn(process.execPath, [tsxCli, resolve("dist/extensions/pi-intercom/broker/broker.ts")], {
+            cwd: agentDir, env: { ...process.env, SELESAI_CODING_AGENT_DIR: agentDir }, stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stderr = "";
+        broker.stderr.on("data", chunk => { stderr += chunk.toString(); });
+        try {
+            await new Promise((resolveReady, reject) => {
+                const timer = setTimeout(() => reject(new Error(`Standalone broker startup timed out: ${stderr}`)), 5000);
+                broker.once("error", error => { clearTimeout(timer); reject(error); });
+                broker.once("exit", code => { clearTimeout(timer); reject(new Error(`Standalone broker exited ${code}: ${stderr}`)); });
+                broker.stdout.on("data", chunk => {
+                    if (chunk.toString().includes("Intercom broker started")) {
+                        clearTimeout(timer);
+                        resolveReady();
+                    }
+                });
+            });
+            expect(stderr).not.toContain("ERR_MODULE_NOT_FOUND");
+        }
+        finally {
+            if (broker.pid !== undefined && broker.exitCode === null && broker.signalCode === null) {
+                const exited = new Promise(resolveExit => broker.once("exit", () => resolveExit()));
+                broker.kill("SIGTERM");
+                await exited;
+            }
+            rmSync(agentDir, { recursive: true, force: true });
+        }
+    });
+    it("returns missing-backend errors without a model turn", async () => {
+        const agentDir = mkdtempSync(join(tmpdir(), "rpc-missing-"));
+        const client = new RpcClient({ cliPath: resolve("dist/modes/rpc/test-fixtures/intercom-host.js"), cwd: agentDir,
+            env: { SELESAI_CODING_AGENT_DIR: agentDir } });
+        try {
+            await client.start();
+            await expect(client.intercomList()).rejects.toThrow("Intercom extension unavailable");
+        }
+        finally {
+            await client.stop();
+            rmSync(agentDir, { recursive: true, force: true });
+        }
+    });
+    it("streams connection events while idle and rebinds on new session/reload", async () => {
+        const agentDir = mkdtempSync(join(tmpdir(), "rpc-live-"));
+        const client = new RpcClient({ cliPath: resolve("dist/modes/rpc/test-fixtures/intercom-host.js"), cwd: agentDir,
+            env: { SELESAI_CODING_AGENT_DIR: agentDir, RPC_INTERCOM_EXTENSION: resolve("dist/extensions/pi-intercom/index.ts"), PI_INTERCOM_STABLE_ID: "", SELESAI_SUBAGENT_ORCHESTRATOR_TARGET: "", SELESAI_SUBAGENT_RUN_ID: "" } });
+        const events = [];
+        const unsubscribe = client.onEvent(event => events.push(event));
+        try {
+            await client.start();
+            const first = await client.intercomList();
+            expect(first.sessions.some(peer => peer.id === first.sessionId)).toBe(true);
+            expect((await client.intercomStatus()).connected).toBe(true);
+            expect((await client.intercomPending()).asks).toEqual([]);
+            expect(events.some(event => event.type === "intercom_connection" && event.connected)).toBe(true);
+            expect(events.some(event => event.type === "agent_start")).toBe(false);
+            await client.newSession();
+            const next = await client.intercomList();
+            expect(next.sessionId).not.toBe(first.sessionId);
+            await client.reload();
+            const reloaded = await client.intercomList();
+            expect(reloaded.sessionId).toBe(next.sessionId);
+            expect(reloaded.sessions.filter(peer => peer.id === next.sessionId)).toHaveLength(1);
+            await expect(client.intercomSend(reloaded.sessionId, { message: "Self must fail" })).rejects.toThrow("current session");
+            expect(events.some(event => event.type === "agent_start")).toBe(false);
+        }
+        finally {
+            unsubscribe();
+            await client.stop();
+            rmSync(agentDir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/modes/rpc/rpc-mode.d.ts

@@ -1,17 +1,5 @@
-/**
- * RPC mode: Headless operation with JSON stdin/stdout protocol.
- *
- * Used for embedding the agent in other applications.
- * Receives commands as JSON on stdin, outputs events and responses as JSON on stdout.
- *
- * Protocol:
- * - Commands: JSON objects with `type` field, optional `id` for correlation
- * - Responses: JSON objects with `type: "response"`, `command`, `success`, and optional `data`/`error`
- * - Events: AgentSessionEvent objects streamed as they occur
- * - Extension UI: Extension UI requests are emitted, client responds with extension_ui_response
- */
 import type { AgentSessionRuntime } from "../../core/agent-session-runtime.ts";
-export type { RpcCommand, RpcExtensionUIRequest, RpcExtensionUIResponse, RpcResponse, RpcSessionInfo, RpcSessionState, RpcSlashCommand, PrototypePhase, QuicktypePhase, WorkflowState, } from "./rpc-types.ts";
+export type { RpcCommand, RpcEvent, IntercomRpcCommand, IntercomRpcResponse, IntercomRpcEvent, IntercomRpcStatus, IntercomRpcDelivery, IntercomRpcMessageOptions, IntercomRpcDataMap, RpcExtensionUIRequest, RpcExtensionUIResponse, RpcResponse, RpcSessionInfo, RpcSessionState, RpcSlashCommand, PrototypePhase, QuicktypePhase, WorkflowState, } from "./rpc-types.ts";
 /**
  * Run in RPC mode.
  * Listens for JSON commands on stdin, outputs events and responses on stdout.

package/dist/modes/rpc/rpc-mode.js

@@ -1,3 +1,6 @@
+import { RpcSubagentBridge } from "./subagent-bridge.js";
+import { RpcReleaseBridge, validateReleaseCommand } from "./release-bridge.js";
+import { RELEASING_BLOCKER_KIND } from "../../core/release-rpc.js";
 /**
  * RPC mode: Headless operation with JSON stdin/stdout protocol.
  *
@@ -10,6 +13,7 @@
  * - Events: AgentSessionEvent objects streamed as they occur
  * - Extension UI: Extension UI requests are emitted, client responds with extension_ui_response
  */
+import { RpcIntercomBridge } from "./intercom-bridge.js";
 import * as crypto from "node:crypto";
 import { spawnSync } from "node:child_process";
 import { chmodSync, copyFileSync, existsSync, readFileSync, unlinkSync } from "node:fs";
@@ -42,6 +46,9 @@ export async function runRpcMode(runtimeHost) {
     let session = runtimeHost.session;
     let unsubscribe;
     let unsubscribeBackpressure;
+    let intercomBridge;
+    let subagentBridge;
+    let releaseBridge;
     const output = (obj) => {
         writeRawStdout(serializeJsonLine(obj));
     };
@@ -95,6 +102,27 @@ export async function runRpcMode(runtimeHost) {
     const pendingExtensionRequests = new Map();
     // Prompts buffered while compacting (queueWhileCompacting) — flushed after compaction_end.
     const compactionPromptQueue = [];
+    // In-flight session transitions (switch/new/fork/reload/extension rebind) and prompts still inside preflight or
+    // run, tracked so release_readiness never answers "safe" in a window where session state is being swapped.
+    let sessionTransitions = 0;
+    let promptsInFlight = 0;
+    const withTransition = async (fn) => {
+        sessionTransitions++;
+        try {
+            return await fn();
+        }
+        finally {
+            sessionTransitions--;
+        }
+    };
+    const TRANSITION_COMMANDS = new Set([
+        "new_session", "handoff_new", "switch_session", "fork", "clone", "import_jsonl", "reload", "navigate_tree",
+    ]);
+    // Atomic `release` command: once committed (synchronously, in the same step as the readiness check) every other command is
+    // refused and the process exits gently right after the response is flushed. `releasedReadiness` is what the commit was based on.
+    let releasing = false;
+    let releaseShutdownPending = false;
+    let releasedReadiness;
     // Shutdown request flag
     let shutdownRequested = false;
     let shuttingDown = false;
@@ -302,16 +330,43 @@ export async function runRpcMode(runtimeHost) {
     runtimeHost.setRebindSession(async () => {
         await rebindSession();
     });
-    const rebindSession = async () => {
+    const bindObservationBridges = () => {
+        intercomBridge?.dispose();
+        subagentBridge?.dispose();
+        releaseBridge?.dispose();
         session = runtimeHost.session;
+        const epoch = crypto.randomUUID();
+        const bus = session.resourceLoader.getEventBus?.();
+        intercomBridge = new RpcIntercomBridge(bus, output, session.sessionId, epoch);
+        subagentBridge = new RpcSubagentBridge(bus, output, { version: 1, sessionId: session.sessionId, epoch });
+        releaseBridge = new RpcReleaseBridge(bus, { version: 1, sessionId: session.sessionId, epoch });
+    };
+    const reloadSession = () => withTransition(reloadSessionUnguarded);
+    const reloadSessionUnguarded = async () => {
+        intercomBridge?.dispose();
+        subagentBridge?.dispose();
+        releaseBridge?.dispose();
+        let rebound = false;
+        try {
+            await session.reload({ beforeSessionStart: () => { bindObservationBridges(); rebound = true; } });
+        }
+        finally {
+            if (!rebound)
+                bindObservationBridges();
+            subagentBridge?.initialize();
+        }
+    };
+    const rebindSession = () => withTransition(rebindSessionUnguarded);
+    const rebindSessionUnguarded = async () => {
+        bindObservationBridges();
         await session.bindExtensions({
             uiContext: createExtensionUIContext(),
             mode: "rpc",
             commandContextActions: {
                 waitForIdle: () => session.waitForIdle(),
-                newSession: async (options) => runtimeHost.newSession(options),
+                newSession: async (options) => withTransition(() => runtimeHost.newSession(options)),
                 fork: async (entryId, forkOptions) => {
-                    const result = await runtimeHost.fork(entryId, forkOptions);
+                    const result = await withTransition(() => runtimeHost.fork(entryId, forkOptions));
                     return { cancelled: result.cancelled };
                 },
                 navigateTree: async (targetId, options) => {
@@ -324,10 +379,10 @@ export async function runRpcMode(runtimeHost) {
                     return { cancelled: result.cancelled };
                 },
                 switchSession: async (sessionPath, options) => {
-                    return runtimeHost.switchSession(sessionPath, options);
+                    return withTransition(() => runtimeHost.switchSession(sessionPath, options));
                 },
                 reload: async () => {
-                    await session.reload();
+                    await reloadSession();
                 },
             },
             shutdownHandler: () => {
@@ -337,6 +392,7 @@ export async function runRpcMode(runtimeHost) {
                 output({ type: "extension_error", extensionPath: err.extensionPath, event: err.event, error: err.error });
             },
         });
+        subagentBridge?.initialize();
         unsubscribe?.();
         unsubscribeBackpressure?.();
         unsubscribe = session.subscribe((event) => {
@@ -389,10 +445,168 @@ export async function runRpcMode(runtimeHost) {
     };
     await rebindSession();
     registerSignalHandlers();
+    /**
+     * Release blockers owned by this process (not by an extension). Fail closed: if a probe throws, report it
+     * instead of answering "safe". Extension blockers are collected by RpcReleaseBridge.
+     */
+    const coreReleaseBlockers = () => {
+        const blockers = [];
+        const block = (kind, detail) => blockers.push({ source: "core", kind, detail });
+        if (releasing)
+            block(RELEASING_BLOCKER_KIND, "A release was committed; this process is shutting down");
+        if (sessionTransitions > 0)
+            block("session_transition", "Session switch, reload or extension rebind in progress");
+        if (promptsInFlight > 0)
+            block("prompt_in_flight", `${promptsInFlight} prompt command(s) still being processed`);
+        const probe = (kind, check) => {
+            try {
+                check();
+            }
+            catch (e) {
+                block("contributor_error", `${kind} probe failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        };
+        probe("streaming", () => { if (session.isStreaming)
+            block("streaming", "Agent run in progress"); });
+        probe("compacting", () => { if (session.isCompacting)
+            block("compacting", "Compaction or branch summarization in progress"); });
+        probe("retrying", () => { if (session.isRetrying)
+            block("retrying", `Auto-retry in progress (attempt ${session.retryAttempt})`); });
+        probe("queued_messages", () => {
+            const steering = session.getSteeringMessages().length;
+            const followUp = session.getFollowUpMessages().length;
+            if (session.agent.hasQueuedMessages() || session.pendingMessageCount > 0)
+                block("queued_messages", `Queued messages: ${steering} steering, ${followUp} follow-up`);
+        });
+        probe("pending_tool_calls", () => {
+            const pending = session.agent.state.pendingToolCalls.size;
+            if (pending > 0)
+                block("pending_tool_calls", `${pending} tool call(s) in flight`);
+        });
+        probe("pending_bash", () => {
+            if (session.isBashRunning)
+                block("pending_bash", "Bash command running");
+            if (session.hasPendingBashMessages)
+                block("pending_bash", "Bash output awaiting flush into the session");
+        });
+        if (pendingExtensionRequests.size > 0)
+            block("extension_dialog", `${pendingExtensionRequests.size} extension dialog(s) awaiting a response`);
+        if (compactionPromptQueue.length > 0)
+            block("compaction_prompt_queue", `${compactionPromptQueue.length} prompt(s) buffered until compaction ends`);
+        return blockers;
+    };
+    /**
+     * Core half of `stop_all_background`: everything this process runs for the session itself. Mirrors the `abort` command (agent
+     * turn, retry, compaction, branch summary) and additionally kills a running `!bash`, drops queued steer/follow-up messages and
+     * buffered compaction prompts so nothing restarts the turn after the abort. Only what was actually active is reported, so an
+     * idle session yields no items. Foreground subagent runs belong to the turn: they are killed through the turn's abort signal.
+     * Extension dialogs are not touched (they are the host's UI, not background work).
+     */
+    const stopCoreWork = async () => {
+        const items = [];
+        const active = (kind, probe) => {
+            try {
+                return probe();
+            }
+            catch (e) {
+                items.push({ source: "core", kind, detail: `${kind} probe failed: ${e instanceof Error ? e.message : String(e)}`, ok: false, error: "probe_failed" });
+                return true;
+            }
+        };
+        const turn = active("turn", () => session.isStreaming);
+        const retry = active("retry", () => session.isRetrying);
+        const compaction = active("compaction", () => session.isCompacting);
+        const bash = active("bash", () => session.isBashRunning);
+        let queued = { steering: 0, followUp: 0 };
+        try {
+            queued = { steering: session.getSteeringMessages().length, followUp: session.getFollowUpMessages().length };
+        }
+        catch { /* reported by the abort below */ }
+        const bufferedPrompts = compactionPromptQueue.length;
+        const done = (kind, detail, failure) => {
+            const message = failure === undefined ? undefined : (failure instanceof Error ? failure.message : String(failure)).slice(0, 256);
+            items.push({ source: "core", kind, detail: message === undefined ? detail : `${detail} failed: ${message}`, ok: message === undefined, ...(message === undefined ? {} : { error: message }) });
+        };
+        // Order matters: drop queued work first so the abort's idle transition cannot start the next queued turn.
+        let queueFailure;
+        try {
+            compactionPromptQueue.length = 0;
+            session.clearQueue();
+        }
+        catch (e) {
+            queueFailure = e;
+        }
+        if (queued.steering + queued.followUp > 0)
+            done("queued_messages", `Dropped ${queued.steering} steering and ${queued.followUp} follow-up message(s)`, queueFailure);
+        if (bufferedPrompts > 0)
+            done("compaction_prompt_queue", `Dropped ${bufferedPrompts} prompt(s) buffered until compaction ends`, queueFailure);
+        let bashFailure;
+        try {
+            session.abortBash();
+        }
+        catch (e) {
+            bashFailure = e;
+        }
+        if (bash)
+            done("bash", "Aborted running bash command", bashFailure);
+        let abortFailure;
+        try {
+            session.abortBranchSummary();
+            session.abortCompaction();
+            await session.abort();
+        }
+        catch (e) {
+            abortFailure = e;
+        }
+        if (turn)
+            done("turn", "Aborted in-flight agent turn", abortFailure);
+        if (retry)
+            done("retry", "Cancelled auto-retry", abortFailure);
+        if (compaction)
+            done("compaction", "Aborted compaction or branch summarization", abortFailure);
+        if (abortFailure !== undefined && !turn && !retry && !compaction)
+            done("turn", "Abort", abortFailure);
+        return items;
+    };
     // Handle a single command
     const handleCommand = async (command) => {
         const id = command.id;
+        // Committed release: nothing new may start. Only the release probes still answer.
+        if (releasing && command.type !== "release" && command.type !== "release_readiness") {
+            return error(id, command.type, "Session is releasing");
+        }
         switch (command.type) {
+            case "subagent_status":
+                return subagentBridge.request(command);
+            case "release_readiness":
+                return releaseBridge.request(command, coreReleaseBlockers());
+            case "stop_all_background":
+                // Destructive kill switch for "Quit anyway". Refused above while `releasing`. The core abort and every extension's stop
+                // start synchronously inside the bridge and are awaited together under one ~5s budget.
+                return releaseBridge.stopAll(command, stopCoreWork, coreReleaseBlockers);
+            case "release": {
+                // ONE synchronous section: readiness check (core + extension broadcast) and commitment, no `await` in between.
+                // The shutdown itself runs from handleInputLine after the response is written and flushed.
+                if (releasing) {
+                    // Idempotent: a repeated (valid) release reports the committed decision.
+                    const invalid = validateReleaseCommand(command);
+                    if (invalid)
+                        return error(id, command.type, invalid);
+                    return success(id, "release", { released: true, readiness: releasedReadiness });
+                }
+                return releaseBridge.release(command, coreReleaseBlockers(), (readiness) => {
+                    releasing = true;
+                    releasedReadiness = readiness;
+                    releaseShutdownPending = true;
+                });
+            }
+            case "intercom_status":
+            case "intercom_list":
+            case "intercom_send":
+            case "intercom_ask":
+            case "intercom_reply":
+            case "intercom_pending":
+                return intercomBridge.request(command);
             // =================================================================
             // Prompting
             // =================================================================
@@ -415,6 +629,7 @@ export async function runRpcMode(runtimeHost) {
                     compactionPromptQueue.push(queued);
                     return undefined;
                 }
+                promptsInFlight++;
                 void session
                     .prompt(command.message, {
                     images: command.images,
@@ -431,6 +646,9 @@ export async function runRpcMode(runtimeHost) {
                     if (!preflightSucceeded) {
                         output(error(id, "prompt", e.message));
                     }
+                })
+                    .finally(() => {
+                    promptsInFlight--;
                 });
                 return undefined;
             }
@@ -492,6 +710,7 @@ export async function runRpcMode(runtimeHost) {
                     thinkingLevel: session.thinkingLevel,
                     isStreaming: session.isStreaming,
                     isCompacting: session.isCompacting,
+                    isRetrying: session.isRetrying,
                     steeringMode: session.steeringMode,
                     followUpMode: session.followUpMode,
                     sessionFile: session.sessionFile,
@@ -1008,7 +1227,7 @@ export async function runRpcMode(runtimeHost) {
                     catch {
                         // best-effort
                     }
-                    await session.reload();
+                    await reloadSession();
                     return success(id, "factory_reset_settings");
                 }
                 catch (resetError) {
@@ -1276,7 +1495,7 @@ export async function runRpcMode(runtimeHost) {
                     return error(id, "reload", "Wait for compaction to finish before reloading.");
                 }
                 try {
-                    await session.reload();
+                    await reloadSession();
                     return success(id, "reload");
                 }
                 catch (reloadError) {
@@ -1396,6 +1615,9 @@ export async function runRpcMode(runtimeHost) {
         }
         unsubscribe?.();
         unsubscribeBackpressure?.();
+        intercomBridge?.dispose();
+        subagentBridge?.dispose();
+        releaseBridge?.dispose();
         await runtimeHost.dispose();
         detachInput();
         process.stdin.pause();
@@ -1434,11 +1656,17 @@ export async function runRpcMode(runtimeHost) {
         }
         const command = parsed;
         try {
-            const response = await handleCommand(command);
+            const response = await (TRANSITION_COMMANDS.has(command.type) ? withTransition(() => handleCommand(command)) : handleCommand(command));
             if (response) {
                 output(response);
                 await waitForRawStdoutBackpressure();
             }
+            if (releaseShutdownPending) {
+                // The release response is out: flush it fully, then take the normal gentle shutdown path (extensions disposed, exit 0).
+                releaseShutdownPending = false;
+                await flushRawStdout();
+                await shutdown();
+            }
             await checkShutdownRequested();
         }
         catch (commandError) {
@@ -1447,6 +1675,9 @@ export async function runRpcMode(runtimeHost) {
         }
     };
     const onInputEnd = () => {
+        // A committed release already owns the shutdown (response flush, then dispose); a second shutdown() would cut it short.
+        if (releasing)
+            return;
         void shutdown();
     };
     process.stdin.on("end", onInputEnd);

package/dist/modes/rpc/rpc-release-transport.test.d.ts

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