termdock 1.3.1 → 1.4.1

package/dist/server/ptyHost.js

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+/**
+ * termdock pty-host daemon — owns shell-mode PTYs outside the server process,
+ * so sessions survive server restarts/crashes/deploys. （架构移植自 tty7 的
+ * persistent daemon，Apache-2.0；单进程多 channel 复用版）
+ *
+ * The server auto-spawns this process detached and talks to it over a
+ * Unix-domain socket (see ptyhost/protocol.ts). One host holds *all* of one
+ * server instance's shell sessions (channels), keeping a bounded replay ring
+ * per channel so a reattaching server rebuilds scrollback + OSC state.
+ *
+ * Standalone entry: keep imports dependency-light (node-pty + protocol only).
+ */
+import net from 'node:net';
+import fs from 'node:fs';
+import path from 'node:path';
+import { FRAME_CONTROL, FRAME_DATA, FRAME_INPUT, FRAME_REPLAY, PTY_HOST_PROTOCOL_VERSION, FrameDecoder, encodeControl, encodeDataFrame, } from './ptyhost/protocol.js';
+/** Bounded per-channel replay ring, in chars. */
+const RING_CAP_CHARS = 256 * 1024;
+const channels = new Map();
+let serverConn = null;
+function socketPathFromArgs() {
+    const idx = process.argv.indexOf('--socket');
+    const p = idx >= 0 ? process.argv[idx + 1] : undefined;
+    if (!p) {
+        console.error('[pty-host] missing --socket <path>');
+        process.exit(2);
+    }
+    return p;
+}
+const SOCKET_PATH = socketPathFromArgs();
+function send(msg) {
+    if (serverConn && !serverConn.destroyed) {
+        serverConn.write(encodeControl(msg));
+    }
+}
+function sendFrame(type, id, data) {
+    if (serverConn && !serverConn.destroyed) {
+        serverConn.write(encodeDataFrame(type, id, data));
+    }
+}
+function channelMeta(ch) {
+    return {
+        id: ch.id,
+        shell: ch.spec.shell,
+        cwd: ch.spec.cwd,
+        cols: ch.spec.cols,
+        rows: ch.spec.rows,
+        pid: ch.pty.pid ?? null,
+        startedAt: ch.startedAt,
+        exited: ch.exited,
+        exitCode: ch.exitCode,
+        offset: ch.offset,
+    };
+}
+function appendToRing(ch, data) {
+    const start = ch.offset;
+    ch.offset += data.length;
+    ch.ring.push({ data, start });
+    ch.ringChars += data.length;
+    while (ch.ringChars > RING_CAP_CHARS && ch.ring.length > 1) {
+        const dropped = ch.ring.shift();
+        if (dropped)
+            ch.ringChars -= dropped.data.length;
+    }
+}
+async function loadNodePty() {
+    return await import('node-pty');
+}
+function spawnChannel(id, spec) {
+    if (channels.has(id)) {
+        send({ op: 'spawned', id, ok: false, error: 'channel id already exists', offset: 0 });
+        return;
+    }
+    void loadNodePty().then((pty) => {
+        let proc;
+        try {
+            proc = pty.spawn(spec.shell, spec.args, {
+                name: spec.termName,
+                cols: spec.cols,
+                rows: spec.rows,
+                cwd: spec.cwd,
+                env: spec.env,
+            });
+        }
+        catch (error) {
+            send({ op: 'spawned', id, ok: false, error: error.message, offset: 0 });
+            return;
+        }
+        const ch = {
+            id,
+            spec,
+            pty: proc,
+            ring: [],
+            ringChars: 0,
+            offset: 0,
+            startedAt: Date.now(),
+            exited: false,
+            exitCode: null,
+            exitSignal: null,
+        };
+        channels.set(id, ch);
+        proc.onData((data) => {
+            appendToRing(ch, data);
+            sendFrame(FRAME_DATA, id, data);
+        });
+        proc.onExit(({ exitCode, signal }) => {
+            ch.exited = true;
+            ch.exitCode = exitCode;
+            ch.exitSignal = signal ?? null;
+            send({ op: 'exit', id, exitCode, signal: signal ?? null, offset: ch.offset });
+            // The channel's ring is the scrollback a reattaching server would want;
+            // without a server there's no one to reattach, so exit the host when
+            // nothing is left running.
+            channels.delete(id);
+            if (channels.size === 0 && !serverConn)
+                shutdown();
+        });
+        send({ op: 'spawned', id, ok: true, pid: proc.pid, offset: 0 });
+    }).catch((error) => {
+        send({ op: 'spawned', id, ok: false, error: error.message, offset: 0 });
+    });
+}
+function attachChannel(id, since) {
+    const ch = channels.get(id);
+    if (!ch) {
+        send({ op: 'attached', id, ok: false, error: 'no such channel' });
+        return;
+    }
+    send({ op: 'attached', id, ok: true });
+    // Replay ring chunks newer than `since` (char offsets, absolute).
+    for (const chunk of ch.ring) {
+        if (chunk.start + chunk.data.length <= since)
+            continue;
+        const sliceStart = Math.max(0, since - chunk.start);
+        sendFrame(FRAME_REPLAY, id, chunk.data.slice(sliceStart));
+    }
+    send({ op: 'replayEnd', id, offset: ch.offset });
+}
+function handleControl(msg) {
+    switch (msg.op) {
+        case 'hello':
+            send({ op: 'helloAck', v: PTY_HOST_PROTOCOL_VERSION, channels: [...channels.values()].map(channelMeta) });
+            return;
+        case 'spawn':
+            spawnChannel(msg.id, msg.spec);
+            return;
+        case 'attach':
+            attachChannel(msg.id, msg.since);
+            return;
+        case 'resize': {
+            const ch = channels.get(msg.id);
+            if (ch && !ch.exited) {
+                ch.spec.cols = msg.cols;
+                ch.spec.rows = msg.rows;
+                try {
+                    ch.pty.resize(msg.cols, msg.rows);
+                }
+                catch { /* pty raced exit */ }
+            }
+            return;
+        }
+        case 'kill': {
+            const ch = channels.get(msg.id);
+            if (ch && !ch.exited) {
+                try {
+                    ch.pty.kill();
+                }
+                catch { /* already gone */ }
+            }
+            return;
+        }
+        case 'pause': {
+            const ch = channels.get(msg.id);
+            if (ch && !ch.exited) {
+                try {
+                    ch.pty.pause?.();
+                }
+                catch { /* optional capability */ }
+            }
+            return;
+        }
+        case 'resume': {
+            const ch = channels.get(msg.id);
+            if (ch && !ch.exited) {
+                try {
+                    ch.pty.resume?.();
+                }
+                catch { /* optional capability */ }
+            }
+            return;
+        }
+        default:
+            // attached/spawned/exit/replayEnd/pong are host→server; ignore here.
+            return;
+    }
+}
+function onServerConnection(conn) {
+    // Single client (the server). A second connection means the server
+    // restarted its socket; drop the old one.
+    if (serverConn && !serverConn.destroyed) {
+        serverConn.destroy();
+    }
+    serverConn = conn;
+    const decoder = new FrameDecoder();
+    conn.on('data', (chunk) => {
+        for (const frame of decoder.feed(chunk)) {
+            try {
+                if (frame.type === FRAME_CONTROL && frame.control) {
+                    handleControl(frame.control);
+                }
+                else if (frame.type === FRAME_INPUT && frame.id && frame.data !== null) {
+                    const ch = channels.get(frame.id);
+                    if (ch && !ch.exited) {
+                        try {
+                            ch.pty.write(frame.data);
+                        }
+                        catch { /* pty raced exit */ }
+                    }
+                }
+            }
+            catch (error) {
+                console.error('[pty-host] frame handling error:', error.message);
+            }
+        }
+    });
+    conn.on('close', () => {
+        if (serverConn === conn)
+            serverConn = null;
+    });
+    conn.on('error', () => { });
+}
+function shutdown() {
+    try {
+        fs.unlinkSync(SOCKET_PATH);
+    }
+    catch { /* already gone */ }
+    process.exit(0);
+}
+function main() {
+    fs.mkdirSync(path.dirname(SOCKET_PATH), { recursive: true, mode: 0o700 });
+    // Stale socket from a crashed host: only our own pid could own it, and we
+    // just started — remove and re-listen.
+    try {
+        fs.unlinkSync(SOCKET_PATH);
+    }
+    catch { /* not present */ }
+    const server = net.createServer(onServerConnection);
+    server.listen(SOCKET_PATH, () => {
+        try {
+            fs.chmodSync(SOCKET_PATH, 0o600);
+        }
+        catch { /* best effort */ }
+        console.log(`[pty-host] listening on ${SOCKET_PATH} (pid ${process.pid})`);
+    });
+    // The host is meant to run forever; a dropped server connection is normal
+    // (server restart) and channels outlive it.
+    process.on('SIGTERM', () => shutdown());
+    process.on('SIGINT', () => shutdown());
+}
+main();

package/dist/server/ptyhost/manager.js

@@ -0,0 +1,396 @@
+/**
+ * Server-side client of the pty-host daemon: connection lifecycle (auto-spawn,
+ * reconnect with delta replay) and `PtyHostClient`, a drop-in `PtyProcess`
+ * whose PTY lives in the host process. （架构移植自 tty7 spawn.rs + remote.rs）
+ *
+ * Shell-mode sessions spawned through this manager survive server restarts:
+ * the host holds the PTYs and a replay ring; on startup the server adopts the
+ * live channels and rebuilds history/OSC state from the ring.
+ */
+import net from 'node:net';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawn } from 'node:child_process';
+import { FRAME_CONTROL, FRAME_DATA, FRAME_INPUT, FRAME_REPLAY, PTY_HOST_PROTOCOL_VERSION, FrameDecoder, encodeControl, encodeDataFrame, } from './protocol.js';
+/** How long to wait for a freshly spawned host to start listening. */
+const HOST_STARTUP_TIMEOUT_MS = 5_000;
+const HOST_STARTUP_POLL_MS = 50;
+const RECONNECT_DELAY_MS = 500;
+function hostSocketDir() {
+    return path.join(os.homedir(), '.termdock', 'pty-hosts');
+}
+/**
+ * One host per server instance: dev and prod servers get separate daemons
+ * (and separate session sets) by keying the socket on the server port.
+ */
+export function ptyHostSocketPath() {
+    const key = process.env.TERMDOCK_PTY_HOST_KEY ?? `port-${process.env.PORT ?? '9834'}`;
+    return path.join(hostSocketDir(), `${key}.sock`);
+}
+/** The built host entry. Under tsx dev only the .ts source exists — spawn it
+ *  through tsx in that case. */
+function resolveHostEntry() {
+    const here = path.dirname(new URL(import.meta.url).pathname);
+    const js = path.resolve(here, '..', 'ptyHost.js');
+    if (fs.existsSync(js)) {
+        return { command: process.execPath, args: [js, '--socket', ptyHostSocketPath()] };
+    }
+    const ts = path.resolve(here, '..', 'ptyHost.ts');
+    // Dev: run through tsx (available as a devDependency).
+    return { command: process.execPath, args: ['--import', 'tsx', ts, '--socket', ptyHostSocketPath()] };
+}
+/**
+ * A `PtyProcess` whose PTY lives in the host. Emits live data via onData;
+ * the *initial* attach's replay is emitted via onReplay (history rebuild),
+ * while reconnect replays (genuinely missed output) go to onData.
+ */
+export class PtyHostClient {
+    pid;
+    /** Char offset of host output seen so far (drives delta re-attach). */
+    seenOffset = 0;
+    manager;
+    channelId;
+    dataHandlers = new Set();
+    replayHandlers = new Set();
+    exitHandlers = new Set();
+    hasAttachedOnce = false;
+    exited = false;
+    constructor(manager, channelId) {
+        this.manager = manager;
+        this.channelId = channelId;
+    }
+    get id() {
+        return this.channelId;
+    }
+    onData(handler) {
+        this.dataHandlers.add(handler);
+        return { dispose: () => this.dataHandlers.delete(handler) };
+    }
+    onReplay(handler) {
+        this.replayHandlers.add(handler);
+        return { dispose: () => this.replayHandlers.delete(handler) };
+    }
+    onExit(handler) {
+        this.exitHandlers.add(handler);
+        return { dispose: () => this.exitHandlers.delete(handler) };
+    }
+    write(data) {
+        if (this.exited)
+            return;
+        this.manager.sendRaw(encodeDataFrame(FRAME_INPUT, this.channelId, data));
+    }
+    resize(cols, rows) {
+        if (this.exited)
+            return;
+        this.manager.send({ op: 'resize', id: this.channelId, cols, rows });
+    }
+    kill() {
+        if (this.exited)
+            return;
+        this.manager.send({ op: 'kill', id: this.channelId });
+    }
+    pause() {
+        if (this.exited)
+            return;
+        this.manager.send({ op: 'pause', id: this.channelId });
+    }
+    resume() {
+        if (this.exited)
+            return;
+        this.manager.send({ op: 'resume', id: this.channelId });
+    }
+    // -- manager-facing frame handlers --
+    handleLiveData(data) {
+        this.seenOffset += data.length;
+        for (const h of this.dataHandlers)
+            h(data);
+    }
+    handleReplayData(data) {
+        this.seenOffset += data.length;
+        if (this.hasAttachedOnce) {
+            // Reconnect delta: genuinely missed output — normal path.
+            for (const h of this.dataHandlers)
+                h(data);
+        }
+        else {
+            // Initial adoption replay: history rebuild only.
+            for (const h of this.replayHandlers)
+                h(data);
+        }
+    }
+    handleReplayEnd(offset) {
+        this.seenOffset = Math.max(this.seenOffset, offset);
+        this.hasAttachedOnce = true;
+    }
+    handleExit(exitCode, signal, offset) {
+        if (this.exited)
+            return;
+        this.exited = true;
+        this.seenOffset = Math.max(this.seenOffset, offset);
+        for (const h of this.exitHandlers)
+            h({ exitCode, signal });
+    }
+    get isExited() {
+        return this.exited;
+    }
+}
+export class PtyHostManager {
+    conn = null;
+    decoder = new FrameDecoder();
+    clients = new Map();
+    connecting = null;
+    helloResolve = null;
+    pendingSpawns = new Map();
+    reconnectTimer = null;
+    stopped = false;
+    /** Resolve when the host is connected + handshaken; returns live channels. */
+    ensureConnected() {
+        if (this.connecting)
+            return this.connecting;
+        this.connecting = this.connectWithSpawnRetry()
+            .finally(() => { this.connecting = null; });
+        return this.connecting;
+    }
+    async connectWithSpawnRetry() {
+        try {
+            return await this.connectOnce();
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT'
+                && error.code !== 'ECONNREFUSED') {
+                throw error;
+            }
+        }
+        this.spawnHostDaemon();
+        const deadline = Date.now() + HOST_STARTUP_TIMEOUT_MS;
+        let lastError = null;
+        while (Date.now() < deadline) {
+            await new Promise((r) => setTimeout(r, HOST_STARTUP_POLL_MS));
+            try {
+                return await this.connectOnce();
+            }
+            catch (error) {
+                lastError = error;
+            }
+        }
+        throw new Error(`pty-host did not start listening in time: ${lastError?.message ?? lastError}`);
+    }
+    spawnHostDaemon() {
+        const { command, args } = resolveHostEntry();
+        fs.mkdirSync(hostSocketDir(), { recursive: true, mode: 0o700 });
+        // Detached + own session + ignored stdio + never waited on: the host
+        // must not die with (or be reaped by) this server.
+        const child = spawn(command, args, {
+            detached: true,
+            stdio: 'ignore',
+            env: process.env,
+        });
+        child.unref();
+        console.log(`[pty-host] spawned host daemon (pid ${child.pid})`);
+    }
+    connectOnce() {
+        return new Promise((resolvePromise, rejectPromise) => {
+            const conn = net.createConnection(ptyHostSocketPath());
+            const onError = (error) => {
+                conn.destroy();
+                rejectPromise(error);
+            };
+            conn.once('error', onError);
+            conn.once('connect', () => {
+                conn.removeListener('error', onError);
+                this.attachConnection(conn);
+                this.helloResolve = resolvePromise;
+                conn.write(encodeControl({ op: 'hello', v: PTY_HOST_PROTOCOL_VERSION }));
+            });
+        });
+    }
+    attachConnection(conn) {
+        if (this.conn && !this.conn.destroyed)
+            this.conn.destroy();
+        this.conn = conn;
+        this.decoder = new FrameDecoder();
+        conn.on('data', (chunk) => {
+            for (const frame of this.decoder.feed(chunk)) {
+                try {
+                    this.handleFrame(frame.type, frame.id, frame.data, frame.control);
+                }
+                catch (error) {
+                    console.warn('[pty-host] frame handling error:', error.message);
+                }
+            }
+        });
+        conn.on('close', () => {
+            if (this.conn !== conn)
+                return;
+            this.conn = null;
+            this.handleDisconnect();
+        });
+        conn.on('error', () => { });
+    }
+    handleFrame(type, id, data, control) {
+        if (type === FRAME_DATA && id && data !== null) {
+            this.clients.get(id)?.handleLiveData(data);
+            return;
+        }
+        if (type === FRAME_REPLAY && id && data !== null) {
+            this.clients.get(id)?.handleReplayData(data);
+            return;
+        }
+        if (type !== FRAME_CONTROL || !control)
+            return;
+        switch (control.op) {
+            case 'helloAck': {
+                if (control.v !== PTY_HOST_PROTOCOL_VERSION) {
+                    console.warn(`[pty-host] protocol mismatch: host v${control.v}, server v${PTY_HOST_PROTOCOL_VERSION} — continuing best-effort`);
+                }
+                this.helloResolve?.(control.channels);
+                this.helloResolve = null;
+                return;
+            }
+            case 'spawned': {
+                const pending = this.pendingSpawns.get(control.id);
+                this.pendingSpawns.delete(control.id);
+                if (!pending)
+                    return;
+                if (control.ok) {
+                    pending.resolve({ pid: control.pid, offset: control.offset });
+                }
+                else {
+                    pending.reject(new Error(control.error ?? 'pty-host spawn failed'));
+                }
+                return;
+            }
+            case 'replayEnd':
+                this.clients.get(control.id)?.handleReplayEnd(control.offset);
+                return;
+            case 'exit': {
+                const client = this.clients.get(control.id);
+                if (client) {
+                    client.handleExit(control.exitCode, control.signal, control.offset);
+                }
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    handleDisconnect() {
+        this.helloResolve?.([]);
+        this.helloResolve = null;
+        for (const pending of this.pendingSpawns.values()) {
+            pending.reject(new Error('pty-host connection dropped'));
+        }
+        this.pendingSpawns.clear();
+        if (this.stopped)
+            return;
+        if (this.clients.size === 0)
+            return; // nothing to lose; reconnect lazily
+        // The host may have died (taking every PTY with it) or be mid-restart
+        // itself. Probe: quick reconnect; if the socket is gone for good, declare
+        // the channels dead so sessions clean up like a PTY exit today.
+        const probe = async () => {
+            try {
+                const channels = await this.ensureConnected();
+                const live = new Set(channels.map((c) => c.id));
+                for (const [id, client] of this.clients) {
+                    if (client.isExited)
+                        continue;
+                    if (live.has(id)) {
+                        // Re-attach with delta replay for the gap.
+                        this.send({ op: 'attach', id, since: client.seenOffset });
+                    }
+                    else {
+                        // Channel vanished with the host: surface as an exit.
+                        client.handleExit(-1, null, client.seenOffset);
+                    }
+                }
+            }
+            catch {
+                // Host is down for good: all live channels died with it.
+                for (const client of this.clients.values()) {
+                    if (!client.isExited)
+                        client.handleExit(-1, null, client.seenOffset);
+                }
+            }
+        };
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = setTimeout(() => { void probe(); }, RECONNECT_DELAY_MS);
+    }
+    send(msg) {
+        if (this.conn && !this.conn.destroyed) {
+            this.conn.write(encodeControl(msg));
+        }
+    }
+    sendRaw(frame) {
+        if (this.conn && !this.conn.destroyed) {
+            this.conn.write(frame);
+        }
+    }
+    /**
+     * Spawn a new channel and return its client (attached, replay complete).
+     * Rejects when the host can't spawn the PTY (bad shell, OOM, …).
+     */
+    async spawnChannel(id, spec) {
+        await this.ensureConnected();
+        const client = new PtyHostClient(this, id);
+        this.clients.set(id, client);
+        const spawned = new Promise((resolvePromise, rejectPromise) => {
+            this.pendingSpawns.set(id, { resolve: resolvePromise, reject: rejectPromise });
+        });
+        this.send({ op: 'spawn', id, spec });
+        try {
+            const { pid, offset } = await spawned;
+            client.pid = pid;
+            client.seenOffset = offset;
+            // Attach from the spawn offset: a fresh channel has nothing to replay,
+            // but the attach registers live delivery on the host side too.
+            this.send({ op: 'attach', id, since: offset });
+            return client;
+        }
+        catch (error) {
+            this.clients.delete(id);
+            throw error;
+        }
+    }
+    /**
+     * Adopt every live channel the host reports (server startup). Returns the
+     * channel metas with attached clients; replay frames arrive right after
+     * (register onReplay handlers synchronously).
+     */
+    async adoptChannels() {
+        // No socket, no survivors — don't spawn an idle host just to learn that.
+        if (!fs.existsSync(ptyHostSocketPath()))
+            return [];
+        let channels;
+        try {
+            channels = await this.ensureConnected();
+        }
+        catch (error) {
+            console.warn('[pty-host] adoption skipped: cannot reach host:', error.message);
+            return [];
+        }
+        const adopted = [];
+        for (const meta of channels) {
+            if (meta.exited)
+                continue;
+            let client = this.clients.get(meta.id);
+            if (!client) {
+                client = new PtyHostClient(this, meta.id);
+                this.clients.set(meta.id, client);
+            }
+            client.pid = meta.pid ?? undefined;
+            adopted.push({ meta, client });
+            this.send({ op: 'attach', id: meta.id, since: client.seenOffset });
+        }
+        return adopted;
+    }
+}
+let managerSingleton = null;
+export function getPtyHostManager() {
+    if (!managerSingleton) {
+        managerSingleton = new PtyHostManager();
+    }
+    return managerSingleton;
+}