super-dsh 0.3.2-d → 0.3.2

package/superd-hub/dist/exec-pty-session.js

@@ -0,0 +1,228 @@
+import { Utf16TailRing } from '../../remote/plugin.js';
+// PTY session machinery — PORTED from better-dsh src/remote/pty-session.ts
+// (spec §8.2 / D12 "原样照抄"), with the ONE sanctioned adaptation: the
+// subprocess spawn is replaced by the PtyChannel seam (exec-pty-channel.ts) —
+// every state transition (init nonce handshake, FIFO dispatch, P8 two-stage
+// interrupt \x03 + injected 130-marker, 3s grace, group-kill fallback, idle
+// TTL, OUTPUT_HARD_CAP with surrogate-pair-safe slicing, I1 waiter hygiene)
+// is the ported logic, unchanged.
+import { buildInitCommand, createNonceFrameParser, genNonce, wrapPtyCommand } from './exec-pty-framing.js';
+/** spec §五.2 逐字。 */
+export const RECONNECT_NOTICE = '[remote: session reconnected to fresh shell; cwd reset to default]';
+const DEFAULT_INIT_TIMEOUT_SEC = 30;
+const INTERRUPT_GRACE_MS = 3_000;
+/** pty 收集内存安全帽（Ruling P15，与 oneshot HARD_CAP 对齐）：模型面只见尾窗，保留尾部。 */
+const OUTPUT_HARD_CAP = 4_000_000;
+export class PtySession {
+    opts;
+    state = 'cold';
+    startPromise = null;
+    queue = Promise.resolve();
+    idleTimer = null;
+    onChunk = null;
+    deathWaiters = [];
+    inFlight = 0;
+    lastSettleAt = 0;
+    constructor(opts) {
+        this.opts = opts;
+        this.opts.channel.onDead(() => this.markDead());
+    }
+    get sessionState() { return this.state; }
+    /** status 面快照：state + busy（有命令在跑）+ idleMs（上次 settle 至今）。 */
+    get snapshot() {
+        return { state: this.state, busy: this.inFlight > 0, idleMs: this.lastSettleAt > 0 ? Date.now() - this.lastSettleAt : null };
+    }
+    /** 同一会话命令严格串行（FIFO）；死亡/冷态先重启。 */
+    dispatch(cmd, dOpts = {}) {
+        const attempt = async () => {
+            const started = Date.now();
+            const reconnected = this.state === 'dead';
+            if (this.state !== 'ready')
+                await this.start();
+            this.inFlight++;
+            return await new Promise((resolve) => {
+                const nonce = genNonce();
+                const ring = new Utf16TailRing(OUTPUT_HARD_CAP);
+                let interrupted = false;
+                let settled = false;
+                let interruptTimer;
+                let killTimer;
+                const deathWaiter = () => finish({ output: ring.text, exit: null, cwd: null, timedOut: interrupted });
+                const cleanup = () => {
+                    this.onChunk = null;
+                    // I1（终审）：已结算 dispatch 的死亡等待必须摘除——否则闭包钉住整段 output，
+                    // 长命会话每调用累积一个 waiter（init 路径的 filter 同款形态）
+                    this.deathWaiters = this.deathWaiters.filter((w) => w !== deathWaiter);
+                    if (interruptTimer !== undefined)
+                        clearTimeout(interruptTimer);
+                    if (killTimer !== undefined)
+                        clearTimeout(killTimer);
+                };
+                const finish = (r) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
+                    this.inFlight--;
+                    this.lastSettleAt = Date.now();
+                    this.resetIdleTimer();
+                    resolve({ ...r, outputStats: { stdout: ring.stats() }, reconnected, durationMs: Date.now() - started });
+                };
+                const parser = createNonceFrameParser(nonce, {
+                    onOutput: (t) => {
+                        ring.push(t);
+                    },
+                    onFrame: ({ exit, cwd }) => finish({ output: ring.text, exit, cwd, timedOut: interrupted }),
+                });
+                this.onChunk = (c) => parser.feed(c);
+                this.write(wrapPtyCommand(cmd, nonce));
+                if (dOpts.stdin !== undefined)
+                    this.write(dOpts.stdin); // Ruling 11: REPL 式紧随
+                interruptTimer = setTimeout(() => {
+                    interrupted = true;
+                    // P8 两段打断：\x03 中断前台作业后，交互 bash 会放弃当前命令行的剩余部分
+                    // （尾部 marker 不再执行）；紧随注入的同 nonce 130-marker 行在 bash 回到
+                    // 读取态后被执行。无论 bash 弃行还是续行，帧都在宽限内到达且 exit=130，
+                    // 会话存活；若命令 trap 掉 SIGINT，原 marker 先帧、注入行帧后字节被丢弃。
+                    this.write('\x03');
+                    this.write(`printf '\\033]133;D;${nonce};130;%s\\007' "$PWD"\n`);
+                    killTimer = setTimeout(() => {
+                        // Ruling 8 的 kill 兜底：宽限无帧 = 会话不可恢复，杀整组后收尸
+                        // （否则 trap-INT 的卡死进程永生，重连后旧组再不可达）
+                        this.opts.channel.kill();
+                        this.markDead();
+                        finish({ output: ring.text, exit: null, cwd: null, timedOut: true });
+                    }, INTERRUPT_GRACE_MS);
+                }, dOpts.timeoutSec === undefined ? 120_000 : dOpts.timeoutSec * 1_000);
+                this.deathWaiters.push(deathWaiter);
+            });
+        };
+        const run = this.queue.then(attempt, attempt);
+        this.queue = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    /** TTL / row teardown：尽力 exit，1s 后杀组，出池。 */
+    async dispose() {
+        if (this.state === 'disposed')
+            return;
+        this.clearIdleTimer();
+        this.state = 'disposed';
+        this.startPromise = null;
+        this.opts.channel.close();
+        this.opts.onDead?.();
+    }
+    write(s) {
+        this.opts.channel.write(s);
+    }
+    async start() {
+        if (this.state === 'disposed')
+            throw new Error(`[E_SESSION_DISPOSED] remote pty session '${this.opts.key}' was disposed — the pool replaces disposed sessions; this reference is stale`);
+        if (this.startPromise === null) {
+            this.state = 'starting';
+            this.startPromise = this.doStart().catch((err) => {
+                this.startPromise = null;
+                this.markDead();
+                throw err;
+            });
+        }
+        return this.startPromise;
+    }
+    async doStart() {
+        const initTimeoutSec = this.opts.initTimeoutSec ?? DEFAULT_INIT_TIMEOUT_SEC;
+        const initNonce = genNonce();
+        await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.opts.channel.kill();
+                reject(new Error(`[E_SESSION_START] remote pty session '${this.opts.key}' did not initialize in ${initTimeoutSec}s` +
+                    (this.diag().length > 0 ? `; transport stderr tail: ${this.diag()}` : '')));
+            }, initTimeoutSec * 1_000);
+            const waiter = () => {
+                clearTimeout(timer);
+                reject(new Error(`[E_SESSION_DIED] remote pty session '${this.opts.key}' died before initializing` +
+                    (this.diag().length > 0 ? `; transport stderr tail: ${this.diag()}` : '')));
+            };
+            this.deathWaiters.push(waiter);
+            const parser = createNonceFrameParser(initNonce, {
+                onFrame: () => {
+                    clearTimeout(timer);
+                    this.deathWaiters = this.deathWaiters.filter((w) => w !== waiter);
+                    if (this.state === 'disposed') {
+                        // dispose 竞态 init：不得复活已终态会话（否则重挂 idle timer + 幽灵 ready）
+                        reject(new Error(`[E_SESSION_DISPOSED] remote pty session '${this.opts.key}' disposed during init`));
+                        return;
+                    }
+                    this.state = 'ready';
+                    this.resetIdleTimer();
+                    resolve();
+                },
+            });
+            this.onChunk = (c) => parser.feed(c);
+            this.opts.channel.open((chunk) => this.onChunk?.(chunk))
+                .catch((err) => {
+                clearTimeout(timer);
+                this.deathWaiters = this.deathWaiters.filter((w) => w !== waiter);
+                reject(err instanceof Error ? err : new Error(String(err)));
+            });
+            this.write(buildInitCommand(initNonce));
+        });
+    }
+    diag() { return this.opts.channel.diag; }
+    markDead() {
+        if (this.state === 'disposed') {
+            // dispose 是终态：不再翻转 state，但在飞 dispatch 的死亡等待仍需立即结算
+            // （row teardown 不是超时——不得等 123s 看门狗，也不得错标 timedOut）
+            const waiters = this.deathWaiters;
+            this.deathWaiters = [];
+            for (const w of waiters)
+                w();
+            return;
+        }
+        this.state = 'dead';
+        this.startPromise = null;
+        this.clearIdleTimer();
+        const waiters = this.deathWaiters;
+        this.deathWaiters = [];
+        for (const w of waiters)
+            w();
+    }
+    resetIdleTimer() {
+        this.clearIdleTimer();
+        this.idleTimer = setTimeout(() => void this.dispose(), this.opts.idleTtlSec * 1_000);
+        this.idleTimer.unref();
+    }
+    clearIdleTimer() {
+        if (this.idleTimer !== null) {
+            clearTimeout(this.idleTimer);
+            this.idleTimer = null;
+        }
+    }
+}
+/** 会话池：键 → 会话。意外死亡的会话留在池内（下次 dispatch 带 reconnect 提示）。 */
+export class PtyPool {
+    defaults;
+    sessions = new Map();
+    constructor(defaults) {
+        this.defaults = defaults;
+    }
+    get size() { return this.sessions.size; }
+    /** status 面：键上的会话快照（无会话 = undefined → "none — dials on first exec"）。 */
+    inspect(key) {
+        return this.sessions.get(key)?.snapshot;
+    }
+    /** roster 面：池内全部会话。 */
+    list() {
+        return [...this.sessions.entries()].map(([key, s]) => ({ key, snapshot: s.snapshot }));
+    }
+    getOrCreate(key, channelOf) {
+        let s = this.sessions.get(key);
+        if (s === undefined || s.sessionState === 'disposed') {
+            s = new PtySession({ key, channel: channelOf(), ...this.defaults, onDead: () => this.sessions.delete(key) });
+            this.sessions.set(key, s);
+        }
+        return s;
+    }
+    async disposeAll() {
+        await Promise.all([...this.sessions.values()].map((s) => s.dispose()));
+        this.sessions.clear();
+    }
+}

package/superd-hub/dist/hub-tool.d.ts

@@ -19,7 +19,7 @@ export interface HubToolExecFace {
     pty(sessionKey: string, machine: string, cmd: string, opts?: {
         timeoutSec?: number;
         stdin?: string;
-    }): Promise<import('../../remote/plugin.js').PtyDispatchResult>;
+    }): Promise<import('./exec-pty-session.js').PtyDispatchResult>;
 }
 import type { A2aAddress, A2aInitiator, A2aService } from './a2a-service.js';
 /** The service face the tool consumes (structural subset of T2/T3's A2aService). */

package/superd-hub/dist/hub-tool.js

@@ -37,7 +37,7 @@
  */
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { parseOneShotExecBody, EXEC_TAIL_WINDOW } from './exec.js';
-import { tailWindow } from '../../remote/plugin.js';
+import { tailWindow } from './exec-pty-framing.js';
 // F2 (0.1.7-n, PC 0.1.7-m first-person): the wire/registry sentinel stays
 // '[undefined]', but the DISPLAY surface must not show it to a human — D17
 // already sanctions display-layer beautification.

package/superd-hub/dist/remote-provider.js

@@ -1,28 +1,13 @@
 import { createRemoteFileEndpoint } from './remote-file-rpc.js';
 import { startRemoteProcess } from './remote-job-client.js';
-/** Hub transport implementation. HTTP/WS/pool mechanics stay in the existing exec modules. */
-import { PtySession, buildHubPtyArgv, hubPtyAssets } from '../../remote/plugin.js';
-// ws 模块绝对路径：在 superd-hub 上下文解析（分叉的 proven 链——闭包/泵子树解析不到，
-// 0.3.2-c 定稿：按名解析只在 transport 侧做一次，经 ptyEndpoint/argv 下传）。
-const wsModulePath = () => {
-    try {
-        return createRequire(import.meta.url).resolve('ws');
-    }
-    catch (error) {
-        throw new Error(`[E_HUB_PTY_SETUP] superd-hub: the ws module could not be resolved from the hub tree — hub PTY spawns a local pump child that opens the peer WebSocket with ws; ${error instanceof Error ? error.message : String(error)}`);
-    }
-};
-import { randomUUID } from 'node:crypto';
-import { createRequire } from 'node:module';
 import { ensureSelf, listRemotes } from './machines.js';
 import { cookieOf } from './mesh-link.js';
 import { runOneShotExec, postOneShotExec, parseOneShotExecBody } from './exec.js';
+import { PtyPool } from './exec-pty-session.js';
+import { LocalScriptChannel, WsPtyChannel } from './exec-pty-channel.js';
 import { PTY_EXEC_PATH } from './exec-pty-rpc.js';
 /** One shared initiator implementation for legacy tool and the optional remote service. */
 export function createHubExec(home, log) {
-    // 0.3.2-c（Q2）：分叉 exec-pty-session 已删——本 face 与 remote 工具共用 canonical
-    // PtySession（闭包导出）。per-owner 每机器一个持久 shell（A2A 语义保持：cwd/env 跨调用存活；
-    // dead → dispatch 内部重连 = 旧 markDead/重启；disposed → 下次调用重建）。
     const owners = new Map();
     let closed = false;
     const assertOpen = () => { if (closed)
@@ -36,16 +21,6 @@ export function createHubExec(home, log) {
             throw new Error(`exec is disabled for machine "${machine}" on this registry row (enabled/execEnabled=false)`);
         return row;
     };
-    const genCommandId = () => `remote-${randomUUID().replace(/-/g, '').slice(0, 16)}`;
-    const createPtySession = (machine, row, owner) => new PtySession({
-        key: `${owner}|hub-pty:${machine}`,
-        argv: row === undefined
-            ? ['script', '-qfec', 'bash', '/dev/null']
-            : buildHubPtyArgv({ url: `${row.origin.replace(/^http/, 'ws')}${PTY_EXEC_PATH}`, cookie: cookieOf(row.id, home) ?? '', wsPath: wsModulePath() }, hubPtyAssets()),
-        id: `p-${randomUUID().slice(0, 8)}`,
-        connection: row === undefined ? 'local' : `hub:${machine}`,
-        idleTtlSec: 900,
-    });
     const face = {
         selfM4: () => ensureSelf(home, 'local').id,
         run: input => { assertOpen(); return runOneShotExec(input, log); },
@@ -62,34 +37,14 @@ export function createHubExec(home, log) {
             const row = machine === face.selfM4() ? undefined : remote(machine);
             let pool = owners.get(owner);
             if (!pool)
-                owners.set(owner, pool = new Map());
-            const attempt = async (session) => {
-                const r = await session.dispatch(cmd, { stdin: opts.stdin, timeoutSec: opts.timeoutSec, commandId: genCommandId() });
-                // P4 handoff（超时不杀）对 A2A 面保持旧语义：显式两段 ^C 后等帧结算——分叉自动中断的等价物。
-                if (r.running === true && r.job !== undefined) {
-                    r.job.interrupt();
-                    const settled = await r.job.done;
-                    return { output: settled.output, outputStats: settled.outputStats, exit: settled.exit, cwd: settled.cwd, timedOut: true, reconnected: r.reconnected, durationMs: r.durationMs, commandId: r.commandId };
-                }
-                return r;
-            };
-            const settle = (result) => {
-                log?.('info', 'exec.pty.run', { machine, cmd: cmd.slice(0, 120), exit: result.exit ?? 'none', durationMs: result.durationMs });
-                return result;
-            };
-            const existing = pool.get(machine);
-            if (existing !== undefined && existing.sessionState !== 'disposed')
-                return settle(await attempt(existing));
-            const session = createPtySession(machine, row, owner);
-            pool.set(machine, session);
-            try {
-                return settle(await attempt(session));
-            }
-            catch (err) {
-                if (session.sessionState === 'disposed' && pool.get(machine) === session)
-                    pool.delete(machine); // init 失败/auto-dispose 不留死项
-                throw err;
-            }
+                owners.set(owner, pool = new PtyPool({ idleTtlSec: 600 }));
+            const key = `${machine}|${row?.origin ?? 'local'}`;
+            const session = pool.getOrCreate(key, () => row
+                ? new WsPtyChannel(`${row.origin.replace(/^http/, 'ws')}${PTY_EXEC_PATH}`, { cookie: cookieOf(row.id, home) })
+                : new LocalScriptChannel());
+            const result = await session.dispatch(cmd, opts);
+            log?.('info', 'exec.pty.run', { machine, cmd: cmd.slice(0, 120), exit: result.exit ?? 'none', durationMs: result.durationMs });
+            return result;
         },
     };
     return {
@@ -97,11 +52,12 @@ export function createHubExec(home, log) {
         async releaseOwner(owner) {
             const pool = owners.get(owner);
             if (pool) {
-                await Promise.all([...pool.values()].map(s => s.dispose()));
-                owners.delete(owner);
+                await pool.disposeAll();
+                if (owners.get(owner) === pool)
+                    owners.delete(owner);
             }
         },
-        async dispose() { closed = true; await Promise.all([...owners.values()].flatMap(p => [...p.values()].map(s => s.dispose()))); owners.clear(); },
+        async dispose() { closed = true; await Promise.all([...owners.values()].map(p => p.disposeAll())); owners.clear(); },
     };
 }
 export function createHubRemoteTransport(home, log) {
@@ -111,10 +67,25 @@ export function createHubRemoteTransport(home, log) {
     const fileAbort = new AbortController();
     const files = new Set();
     const processes = new Map();
+    const pending = new Map();
     const requireRemote = (machine) => {
         if (!machine || machine === exec.face.selfM4())
             throw new Error('Select a remote machine from the Hub roster; local execution is not available through remote');
     };
+    const track = async (owner, work) => {
+        let set = pending.get(owner);
+        if (!set)
+            pending.set(owner, set = new Set());
+        set.add(work);
+        try {
+            return await work;
+        }
+        finally {
+            set.delete(work);
+            if (!set.size)
+                pending.delete(owner);
+        }
+    };
     return {
         protocol: 1,
         listTargets: () => listRemotes(home).filter(r => r.id !== exec.face.selfM4()).map(r => ({ id: r.id, label: r.name, execEnabled: r.enabled && r.execEnabled !== false })),
@@ -139,17 +110,12 @@ export function createHubRemoteTransport(home, log) {
                 processes.delete(owner); });
             return process;
         },
-        ptyEndpoint(machine) {
+        async pty(machine, cmd, owner, options) {
             requireRemote(machine);
-            if (closed)
-                throw new Error('Hub remote provider disposed');
-            const row = listRemotes(home).find(r => r.id === machine);
-            if (!row)
-                throw new Error(`unknown machine "${machine}"`);
-            if (!row.enabled || row.execEnabled === false)
-                throw new Error(`exec is disabled for machine "${machine}"`);
-            // P10：创建与每次 dispatch 都重取本端点（driver 侧调用）——pairing 复用不豁免。
-            return { url: `${row.origin.replace(/^http/, 'ws')}${PTY_EXEC_PATH}`, cookie: cookieOf(row.id, home) ?? '', wsPath: wsModulePath() };
+            if (closed || released.has(owner))
+                throw new Error('Hub remote owner disposed');
+            const { output, ...result } = await track(owner, exec.face.pty(owner, machine, cmd, { timeoutSec: options.timeout, stdin: options.stdin }));
+            return { mode: 'pty', target: `hub:${machine}`, ...result, stdout: output };
         },
         fileEndpoint(machine) {
             requireRemote(machine);
@@ -169,7 +135,7 @@ export function createHubRemoteTransport(home, log) {
             const owned = [...processes.get(owner) ?? []];
             for (const process of owned)
                 process.cancel('owner released');
-            await Promise.all([exec.releaseOwner(owner), ...owned.map(p => p.done)]);
+            await Promise.all([exec.releaseOwner(owner), ...owned.map(p => p.done), ...pending.get(owner) ?? []]);
         },
         async dispose() {
             closed = true;
@@ -179,7 +145,7 @@ export function createHubRemoteTransport(home, log) {
             for (const process of owned)
                 process.cancel('provider disposed');
             await exec.dispose();
-            await Promise.allSettled([...owned.map(p => p.done)]);
+            await Promise.allSettled([...owned.map(p => p.done), ...[...pending.values()].flatMap(s => [...s])]);
         },
     };
 }

package/remote/hub-pty-pump.mjs

@@ -1,97 +0,0 @@
-#!/usr/bin/env node
-// Hub PTY pump — the DUMB child of the canonical PTY session over a Hub
-// machine (0.3.2-c). The session (better-dsh/src/remote/pty-session.ts)
-// spawns `script -qfec 'stty -echo; … exec node <this file>' /dev/null`, so
-// this process's stdin/stdout ride a host-side PTY; we forward those bytes
-// over one WebSocket to the peer hub's dumb PTY executor
-// (/api/superd/exec/pty: one WS = one `script -qfec bash /dev/null`, text
-// frames = stream bytes, {"op":…} JSON frames = transport control, WS close
-// = peer group-kill). All session intelligence (nonce framing, init
-// handshake, env E-frames, two-stage interrupt, idle TTL) is in-band bytes
-// produced by the SESSION — this pump never parses the stream, only the
-// peer's control frames.
-//
-// Connection facts arrive via environment (never argv — credentials must not
-// show up in `ps`):
-//   SUPERD_HUB_PTY_URL     wss://…/api/superd/exec/pty (peer executor)
-//   SUPERD_HUB_PTY_COOKIE  pairing cookie for the upgrade request
-//   SUPERD_HUB_PTY_WS      ABSOLUTE path to a usable `ws` module (resolved by
-//                          the caller before spawning; no resolution gamble
-//                          here — a missing module is a creation-time error)
-//
-// Verbatim-asset discipline (helper-bin precedent): this file is copied
-// byte-for-byte into lib/remote/ and the Super closure; no build step
-// transforms it. Crash-proof by construction (mesh-gateway lesson): the
-// 'error' listener is registered before anything can reject, and post-close
-// sends are swallowed — the session's death path owns the teardown.
-const PUMP_ENV_PREFIX = 'SUPERD_HUB_PTY_'
-const [url, cookie, wsPath] = ['URL', 'COOKIE', 'WS'].map((k) => process.env[`SUPERD_HUB_PTY_${k}`])
-
-// cookie may be legitimately empty (an unauthenticated test lane sends no header);
-// the endpoint URL and the ws module path are the hard requirements.
-if (url === undefined || url === '' || wsPath === undefined || wsPath === '') {
-  process.stderr.write(`hub-pty-pump: missing environment (${PUMP_ENV_PREFIX}URL/WS)\n`)
-  process.exit(1)
-}
-
-let WebSocket
-try {
-  const require = (await import('node:module')).createRequire(import.meta.url)
-  const mod = require(wsPath)
-  WebSocket = typeof mod === 'function' ? mod : mod.default
-} catch (err) {
-  process.stderr.write(`hub-pty-pump: cannot load ws module at ${wsPath} — ${err instanceof Error ? err.message : String(err)}\n`)
-  process.exit(1)
-}
-if (typeof WebSocket !== 'function') {
-  process.stderr.write('hub-pty-pump: the ws module did not yield a WebSocket constructor\n')
-  process.exit(1)
-}
-
-const socket = new WebSocket(url, { headers: cookie ? { cookie } : {} })
-let opened = false
-let forward = true
-
-socket.on('error', (err) => {
-  // Always-on listener: an ECONNREFUSED or a rejected 401 upgrade must be a
-  // reported death, never an uncaught exception.
-  process.stderr.write(`hub-pty-pump: ${opened ? 'socket error' : 'connect failed'} — ${err instanceof Error ? err.message : String(err)}\n`)
-})
-socket.on('open', () => { opened = true; pumpStdin() })
-socket.on('message', (data) => {
-  if (!forward) return
-  const text = typeof data === 'string' ? data : Array.isArray(data) ? Buffer.concat(data).toString('utf8') : Buffer.from(data).toString('utf8')
-  // Transport control frames (peer: {"op":"exit"} / {"op":"spawn-error"}) are
-  // addressed to THIS pump, not to the shell stream — the exit frame is
-  // followed by a socket close, which settles us below.
-  if (text.startsWith('{"op":')) {
-    try {
-      const parsed = JSON.parse(text)
-      if (typeof parsed.op === 'string') {
-        if (parsed.op === 'spawn-error' && typeof parsed.error === 'string') process.stderr.write(`hub-pty-pump: peer could not spawn the terminal — ${parsed.error}\n`)
-        return
-      }
-    } catch { /* not JSON after all: fall through and forward */ }
-  }
-  process.stdout.write(text)
-})
-socket.on('close', () => {
-  forward = false
-  // Before open this is a failed connection (diag already on stderr); after
-  // open it is the peer session ending — either way the child exiting is the
-  // session's dead signal.
-  process.exit(opened ? 0 : 1)
-})
-
-function pumpStdin() {
-  process.stdin.setEncoding('utf8')
-  process.stdin.on('data', (chunk) => {
-    if (!opened) return
-    try { socket.send(chunk) } catch { /* closing: the close handler exits us */ }
-  })
-  // The session's kill path tears down the process group; a plain stdin end
-  // (no kill) still means nobody will type more — close politely so the peer
-  // reaps its side.
-  process.stdin.on('end', () => { try { socket.close() } catch { /* already closing */ } })
-  process.stdin.on('error', () => { /* EPIPE on teardown: the close path owns the exit */ })
-}