@orion-agents/orion-code 0.3.0 → 0.3.2

package/dist/web/terminal-manager.js

@@ -0,0 +1,760 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TerminalManagerV1 = void 0;
+const crypto_1 = require("crypto");
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const errors_1 = require("./errors");
+const MAX_TERMINALS = 4;
+const MAX_WORKSPACE_TERMINALS = 2;
+const MAX_SCROLLBACK_BYTES = 2 * 1024 * 1024;
+const MAX_INPUT_BYTES = 64 * 1024;
+const MAX_OUTPUT_FRAME_CHARS = 8000;
+const OUTPUT_COALESCE_MS = 8;
+const DEFAULT_TICKET_TTL_MS = 15000;
+const DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
+const DEFAULT_FORCE_KILL_DELAY_MS = 1000;
+const DEFAULT_SHUTDOWN_GRACE_MS = 1000;
+const DEFAULT_FORCE_KILL_GRACE_MS = 1000;
+const PROCESS_REAP_POLL_MS = 25;
+/** Owns explicit-user PTYs; terminal bytes never enter Workbench SSE or durable storage. */
+class TerminalManagerV1 {
+    constructor(options) {
+        this.terminals = new Map();
+        this.tickets = new Map();
+        this.closed = false;
+        this.resolveWorkspace = options.resolveWorkspace;
+        this.getActiveContext = options.getActiveContext;
+        this.backend = options.backend;
+        this.now = options.now ?? Date.now;
+        this.ticketTtlMs = boundedPositive(options.ticketTtlMs ?? DEFAULT_TICKET_TTL_MS, 'ticketTtlMs');
+        this.idleTimeoutMs = boundedPositive(options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS, 'idleTimeoutMs');
+        this.forceKillDelayMs = boundedPositive(options.forceKillDelayMs ?? DEFAULT_FORCE_KILL_DELAY_MS, 'forceKillDelayMs');
+        this.shutdownGraceMs = boundedPositive(options.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS, 'shutdownGraceMs');
+        this.forceKillGraceMs = boundedPositive(options.forceKillGraceMs ?? DEFAULT_FORCE_KILL_GRACE_MS, 'forceKillGraceMs');
+        this.onWorkspaceMutationHint = options.onWorkspaceMutationHint;
+    }
+    get available() {
+        if (this.backend)
+            return true;
+        try {
+            loadNodePtyBackend();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    list(workspaceId) {
+        return Object.freeze([...this.terminals.values()]
+            .filter(entry => entry.workspaceId === workspaceId)
+            .sort((left, right) => left.createdAtMs - right.createdAtMs)
+            .map(entry => this.metadata(entry)));
+    }
+    create(input) {
+        this.assertOpen();
+        const active = this.getActiveContext();
+        if (active.workspaceId !== input.workspaceId ||
+            active.contextRevision !== input.expectedContextRevision) {
+            throw new errors_1.WebWorkbenchError(409, 'The active Context changed before terminal creation.', 'context_revision_conflict');
+        }
+        const workspace = this.resolveWorkspace(input.workspaceId);
+        if (!workspace) {
+            throw new errors_1.WebWorkbenchError(404, 'Workspace was not found.', 'workspace_not_found');
+        }
+        const canonicalWorkspace = canonicalDirectory(workspace);
+        const running = [...this.terminals.values()].filter(entry => entry.state === 'running');
+        if (running.length >= MAX_TERMINALS) {
+            throw new errors_1.WebWorkbenchError(409, 'Terminal limit reached.', 'terminal_limit_reached');
+        }
+        if (running.filter(entry => entry.workspaceId === input.workspaceId).length >=
+            MAX_WORKSPACE_TERMINALS) {
+            throw new errors_1.WebWorkbenchError(409, 'Workspace terminal limit reached.', 'terminal_workspace_limit_reached');
+        }
+        const cols = boundedDimension(input.cols ?? 100, 2, 400, 'cols');
+        const rows = boundedDimension(input.rows ?? 30, 1, 200, 'rows');
+        const shell = resolveShell();
+        const backend = this.backend ?? loadNodePtyBackend();
+        let process;
+        try {
+            process = backend.spawn(shell, shellArguments(shell), {
+                name: 'xterm-256color',
+                cols,
+                rows,
+                cwd: canonicalWorkspace,
+                env: terminalEnvironment(shell),
+            });
+        }
+        catch {
+            throw new errors_1.WebWorkbenchError(503, 'The native terminal backend could not start a shell.', 'terminal_backend_unavailable');
+        }
+        const id = (0, crypto_1.randomUUID)();
+        const now = this.now();
+        const entry = {};
+        Object.assign(entry, {
+            id,
+            workspaceId: input.workspaceId,
+            cwd: canonicalWorkspace,
+            shell,
+            title: (0, path_1.basename)(shell),
+            createdAtMs: now,
+            process,
+            state: 'running',
+            cols,
+            rows,
+            lastActiveAtMs: now,
+            nextSequence: 1,
+            frames: [],
+            frameBytes: 0,
+            pendingOutput: '',
+            dataSubscription: process.onData(data => this.appendOutput(entry, data)),
+            exitSubscription: process.onExit(event => this.handleExit(entry, event)),
+            removeAfterExit: false,
+            outputPaused: false,
+            ownedProcesses: new Map(),
+        });
+        rememberProcessTree(entry);
+        this.terminals.set(id, entry);
+        this.scheduleIdle(entry);
+        const ticket = this.issueTicket(id);
+        return Object.freeze({
+            terminal: this.metadata(entry),
+            ticket: ticket.value,
+            ticketExpiresAt: new Date(ticket.expiresAt).toISOString(),
+        });
+    }
+    issueAttachTicket(input) {
+        this.assertActiveContext(input.workspaceId, input.expectedContextRevision);
+        const entry = this.requireTerminal(input.terminalId);
+        if (entry.workspaceId !== input.workspaceId) {
+            throw new errors_1.WebWorkbenchError(404, 'Terminal was not found.', 'terminal_not_found');
+        }
+        if (entry.state !== 'running') {
+            throw new errors_1.WebWorkbenchError(409, 'Terminal is no longer running.', 'terminal_not_running');
+        }
+        const ticket = this.issueTicket(entry.id);
+        return Object.freeze({
+            ticket: ticket.value,
+            ticketExpiresAt: new Date(ticket.expiresAt).toISOString(),
+        });
+    }
+    attach(input) {
+        this.assertOpen();
+        if (!Number.isSafeInteger(input.afterSequence) || input.afterSequence < 0) {
+            throw new errors_1.WebWorkbenchError(400, 'Terminal sequence is invalid.', 'terminal_sequence_invalid');
+        }
+        const entry = this.requireTerminal(input.terminalId);
+        this.consumeTicket(entry.id, input.ticket);
+        this.flushPendingOutput(entry, true);
+        if (entry.outputPaused)
+            this.setProcessOutputPaused(entry, false);
+        entry.subscriber?.onReplaced();
+        const token = (0, crypto_1.randomUUID)();
+        entry.subscriber = {
+            token,
+            onFrame: input.onFrame,
+            onExit: input.onExit,
+            onReplaced: input.onReplaced,
+        };
+        this.touch(entry);
+        const earliest = entry.frames[0]?.sequence ?? entry.nextSequence;
+        const latest = entry.nextSequence - 1;
+        const gap = input.afterSequence < earliest - 1
+            ? Object.freeze({
+                type: 'gap',
+                earliestSequence: earliest,
+                latestSequence: latest,
+            })
+            : undefined;
+        const replay = entry.frames
+            .filter(frame => frame.sequence > input.afterSequence)
+            .map(frame => Object.freeze({ type: 'output', sequence: frame.sequence, data: frame.data }));
+        return Object.freeze({
+            terminal: this.metadata(entry),
+            replay: Object.freeze(replay),
+            ...(gap ? { gap } : {}),
+            write: (data) => {
+                this.assertConnection(entry, token);
+                if (typeof data !== 'string' || Buffer.byteLength(data, 'utf8') > MAX_INPUT_BYTES) {
+                    throw new errors_1.WebWorkbenchError(400, 'Terminal input is too large.', 'terminal_input_invalid');
+                }
+                entry.process.write(data);
+                this.touch(entry);
+                if (/[\r\n]/u.test(data))
+                    this.onWorkspaceMutationHint?.(entry.workspaceId);
+            },
+            resize: (cols, rows) => {
+                this.assertConnection(entry, token);
+                const nextCols = boundedDimension(cols, 2, 400, 'cols');
+                const nextRows = boundedDimension(rows, 1, 200, 'rows');
+                entry.process.resize(nextCols, nextRows);
+                entry.cols = nextCols;
+                entry.rows = nextRows;
+                this.touch(entry);
+            },
+            setOutputPaused: (paused) => {
+                this.assertConnection(entry, token);
+                if (typeof paused !== 'boolean') {
+                    throw new errors_1.WebWorkbenchError(400, 'Terminal output flow state is invalid.', 'terminal_flow_invalid');
+                }
+                this.setProcessOutputPaused(entry, paused);
+            },
+            dispose: () => {
+                if (entry.subscriber?.token !== token)
+                    return;
+                entry.subscriber = undefined;
+                if (entry.outputPaused)
+                    this.setProcessOutputPaused(entry, false);
+            },
+        });
+    }
+    closeTerminal(input) {
+        this.assertActiveContext(input.workspaceId, input.expectedContextRevision);
+        const entry = this.requireTerminal(input.terminalId);
+        if (entry.workspaceId !== input.workspaceId) {
+            throw new errors_1.WebWorkbenchError(404, 'Terminal was not found.', 'terminal_not_found');
+        }
+        entry.removeAfterExit = true;
+        if (entry.state === 'running') {
+            entry.state = 'closing';
+            this.terminateEntry(entry);
+        }
+        else {
+            if (isProcessTreeAlive(entry)) {
+                forceKillProcessTree(entry);
+                this.scheduleReap(entry);
+            }
+            else {
+                this.removeEntry(entry);
+            }
+        }
+        return this.metadata(entry);
+    }
+    closeWorkspace(workspaceId) {
+        for (const entry of [...this.terminals.values()]) {
+            if (entry.workspaceId !== workspaceId)
+                continue;
+            entry.removeAfterExit = true;
+            if (entry.state === 'running') {
+                entry.state = 'closing';
+                this.terminateEntry(entry);
+            }
+            else {
+                if (isProcessTreeAlive(entry)) {
+                    forceKillProcessTree(entry);
+                    this.scheduleReap(entry);
+                }
+                else {
+                    this.removeEntry(entry);
+                }
+            }
+        }
+    }
+    async shutdown() {
+        if (this.shutdownPromise)
+            return this.shutdownPromise;
+        this.closed = true;
+        this.shutdownPromise = this.performShutdown();
+        return this.shutdownPromise;
+    }
+    async performShutdown() {
+        this.tickets.clear();
+        const entries = [...this.terminals.values()];
+        for (const entry of entries) {
+            entry.removeAfterExit = true;
+            if (entry.state === 'running')
+                entry.state = 'closing';
+            if (isProcessTreeAlive(entry))
+                this.terminateEntry(entry);
+            else
+                this.removeEntry(entry);
+        }
+        await this.reapStoppedEntries(entries, this.shutdownGraceMs);
+        const survivors = entries.filter(entry => this.terminals.get(entry.id) === entry && isProcessTreeAlive(entry));
+        for (const entry of survivors)
+            forceKillProcessTree(entry);
+        await this.reapStoppedEntries(survivors, this.forceKillGraceMs);
+        const orphans = survivors.filter(entry => this.terminals.get(entry.id) === entry && isProcessTreeAlive(entry));
+        if (orphans.length > 0) {
+            throw new errors_1.WebWorkbenchError(503, 'One or more terminal process trees survived Host shutdown.', 'terminal_shutdown_incomplete');
+        }
+    }
+    async reapStoppedEntries(entries, timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        for (;;) {
+            let alive = false;
+            for (const entry of entries) {
+                if (this.terminals.get(entry.id) !== entry)
+                    continue;
+                if (isProcessTreeAlive(entry)) {
+                    alive = true;
+                    continue;
+                }
+                this.removeEntry(entry);
+            }
+            if (!alive || Date.now() >= deadline)
+                return;
+            await delay(Math.min(PROCESS_REAP_POLL_MS, Math.max(1, deadline - Date.now())));
+        }
+    }
+    terminateEntry(entry) {
+        terminateProcessTree(entry);
+        if (entry.forceKillTimer)
+            clearTimeout(entry.forceKillTimer);
+        entry.forceKillTimer = setTimeout(() => {
+            entry.forceKillTimer = undefined;
+            if (this.terminals.get(entry.id) !== entry || !isProcessTreeAlive(entry)) {
+                if (entry.removeAfterExit && this.terminals.get(entry.id) === entry) {
+                    this.removeEntry(entry);
+                }
+                return;
+            }
+            forceKillProcessTree(entry);
+            this.scheduleReap(entry);
+        }, this.forceKillDelayMs);
+        entry.forceKillTimer.unref();
+    }
+    scheduleReap(entry) {
+        if (entry.reapTimer || this.terminals.get(entry.id) !== entry)
+            return;
+        const check = () => {
+            entry.reapTimer = undefined;
+            if (this.terminals.get(entry.id) !== entry)
+                return;
+            if (!isProcessTreeAlive(entry)) {
+                if (entry.removeAfterExit)
+                    this.removeEntry(entry);
+                return;
+            }
+            forceKillProcessTree(entry);
+            entry.reapTimer = setTimeout(check, PROCESS_REAP_POLL_MS);
+            entry.reapTimer.unref();
+        };
+        entry.reapTimer = setTimeout(check, PROCESS_REAP_POLL_MS);
+        entry.reapTimer.unref();
+    }
+    setProcessOutputPaused(entry, paused) {
+        if (entry.outputPaused === paused)
+            return;
+        try {
+            if (paused)
+                entry.process.pause();
+            else
+                entry.process.resume();
+            entry.outputPaused = paused;
+        }
+        catch {
+            throw new errors_1.WebWorkbenchError(503, 'Terminal output flow control failed.', 'terminal_flow_failed');
+        }
+    }
+    appendOutput(entry, data) {
+        if (entry.state !== 'running' && entry.state !== 'closing')
+            return;
+        entry.pendingOutput += data;
+        this.flushPendingOutput(entry, data.length >= MAX_OUTPUT_FRAME_CHARS);
+        if (entry.pendingOutput && !entry.outputFlushTimer) {
+            entry.outputFlushTimer = setTimeout(() => {
+                entry.outputFlushTimer = undefined;
+                this.flushPendingOutput(entry, true);
+            }, OUTPUT_COALESCE_MS);
+            entry.outputFlushTimer.unref();
+        }
+    }
+    flushPendingOutput(entry, force) {
+        let emitted = false;
+        while (entry.pendingOutput.length > 0 &&
+            (force || entry.pendingOutput.length >= MAX_OUTPUT_FRAME_CHARS)) {
+            let end = Math.min(entry.pendingOutput.length, MAX_OUTPUT_FRAME_CHARS);
+            if (end < entry.pendingOutput.length &&
+                end > 0 &&
+                isHighSurrogate(entry.pendingOutput.charCodeAt(end - 1)) &&
+                isLowSurrogate(entry.pendingOutput.charCodeAt(end))) {
+                end -= 1;
+            }
+            if (!force &&
+                end === entry.pendingOutput.length &&
+                isHighSurrogate(entry.pendingOutput.charCodeAt(end - 1))) {
+                break;
+            }
+            if (end <= 0)
+                break;
+            const value = entry.pendingOutput.slice(0, end);
+            entry.pendingOutput = entry.pendingOutput.slice(end);
+            const frame = Object.freeze({
+                sequence: entry.nextSequence++,
+                data: value,
+                bytes: Buffer.byteLength(value, 'utf8'),
+            });
+            entry.frames.push(frame);
+            entry.frameBytes += frame.bytes;
+            while (entry.frameBytes > MAX_SCROLLBACK_BYTES && entry.frames.length > 0) {
+                const removed = entry.frames.shift();
+                entry.frameBytes -= removed?.bytes ?? 0;
+            }
+            entry.subscriber?.onFrame(Object.freeze({ type: 'output', sequence: frame.sequence, data: frame.data }));
+            emitted = true;
+        }
+        if (!entry.pendingOutput && entry.outputFlushTimer) {
+            clearTimeout(entry.outputFlushTimer);
+            entry.outputFlushTimer = undefined;
+        }
+        if (emitted)
+            this.touch(entry);
+    }
+    handleExit(entry, event) {
+        if (this.terminals.get(entry.id) !== entry)
+            return;
+        this.flushPendingOutput(entry, true);
+        entry.state = 'exited';
+        entry.exitCode = event.exitCode;
+        entry.signal = event.signal;
+        entry.outputPaused = false;
+        if (entry.idleTimer)
+            clearTimeout(entry.idleTimer);
+        if (entry.forceKillTimer)
+            clearTimeout(entry.forceKillTimer);
+        entry.subscriber?.onExit(Object.freeze({
+            type: 'exit',
+            exitCode: event.exitCode,
+            ...(event.signal !== undefined ? { signal: event.signal } : {}),
+        }));
+        entry.subscriber = undefined;
+        this.onWorkspaceMutationHint?.(entry.workspaceId);
+        if (isProcessTreeAlive(entry)) {
+            forceKillProcessTree(entry);
+            this.scheduleReap(entry);
+        }
+        else if (entry.removeAfterExit) {
+            this.removeEntry(entry);
+        }
+    }
+    issueTicket(terminalId) {
+        for (const [key, record] of this.tickets) {
+            if (record.terminalId === terminalId)
+                this.tickets.delete(key);
+        }
+        const value = (0, crypto_1.randomBytes)(32).toString('base64url');
+        const digest = ticketDigest(value);
+        const expiresAt = this.now() + this.ticketTtlMs;
+        this.tickets.set(terminalId, { terminalId, digest, expiresAt });
+        return Object.freeze({ value, expiresAt });
+    }
+    consumeTicket(terminalId, value) {
+        const record = this.tickets.get(terminalId);
+        const digest = ticketDigest(typeof value === 'string' ? value : '');
+        if (!record ||
+            record.expiresAt < this.now() ||
+            record.digest.length !== digest.length ||
+            !(0, crypto_1.timingSafeEqual)(record.digest, digest)) {
+            throw new errors_1.WebWorkbenchError(403, 'Terminal stream ticket is invalid.', 'terminal_ticket_invalid');
+        }
+        this.tickets.delete(terminalId);
+    }
+    metadata(entry) {
+        return Object.freeze({
+            id: entry.id,
+            workspaceId: entry.workspaceId,
+            title: entry.title,
+            shell: (0, path_1.basename)(entry.shell),
+            state: entry.state,
+            cols: entry.cols,
+            rows: entry.rows,
+            connected: Boolean(entry.subscriber),
+            createdAt: new Date(entry.createdAtMs).toISOString(),
+            lastActiveAt: new Date(entry.lastActiveAtMs).toISOString(),
+            earliestSequence: entry.frames[0]?.sequence ?? entry.nextSequence,
+            lastSequence: entry.nextSequence - 1,
+            ...(entry.exitCode !== undefined ? { exitCode: entry.exitCode } : {}),
+            ...(entry.signal !== undefined ? { signal: entry.signal } : {}),
+        });
+    }
+    assertConnection(entry, token) {
+        if (entry.subscriber?.token !== token) {
+            throw new errors_1.WebWorkbenchError(409, 'Terminal connection was replaced.', 'terminal_replaced');
+        }
+        if (entry.state !== 'running') {
+            throw new errors_1.WebWorkbenchError(409, 'Terminal is no longer running.', 'terminal_not_running');
+        }
+    }
+    assertActiveContext(workspaceId, contextRevision) {
+        this.assertOpen();
+        const active = this.getActiveContext();
+        if (active.workspaceId !== workspaceId || active.contextRevision !== contextRevision) {
+            throw new errors_1.WebWorkbenchError(409, 'The active Context changed before terminal mutation.', 'context_revision_conflict');
+        }
+    }
+    requireTerminal(id) {
+        const entry = this.terminals.get(id);
+        if (!entry)
+            throw new errors_1.WebWorkbenchError(404, 'Terminal was not found.', 'terminal_not_found');
+        return entry;
+    }
+    touch(entry) {
+        entry.lastActiveAtMs = this.now();
+        this.scheduleIdle(entry);
+    }
+    scheduleIdle(entry) {
+        if (entry.idleTimer)
+            clearTimeout(entry.idleTimer);
+        entry.idleTimer = setTimeout(() => {
+            if (entry.state !== 'running')
+                return;
+            if (this.now() - entry.lastActiveAtMs < this.idleTimeoutMs) {
+                this.scheduleIdle(entry);
+                return;
+            }
+            entry.state = 'closing';
+            this.terminateEntry(entry);
+        }, this.idleTimeoutMs);
+        entry.idleTimer.unref();
+    }
+    removeEntry(entry) {
+        if (entry.idleTimer)
+            clearTimeout(entry.idleTimer);
+        if (entry.forceKillTimer)
+            clearTimeout(entry.forceKillTimer);
+        if (entry.reapTimer)
+            clearTimeout(entry.reapTimer);
+        if (entry.outputFlushTimer)
+            clearTimeout(entry.outputFlushTimer);
+        entry.dataSubscription.dispose();
+        entry.exitSubscription.dispose();
+        entry.subscriber = undefined;
+        this.terminals.delete(entry.id);
+        this.tickets.delete(entry.id);
+    }
+    assertOpen() {
+        if (this.closed) {
+            throw new errors_1.WebWorkbenchError(503, 'Terminal manager is closed.', 'terminal_unavailable');
+        }
+    }
+}
+exports.TerminalManagerV1 = TerminalManagerV1;
+function loadNodePtyBackend() {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const nodePty = require('node-pty');
+    return Object.freeze({
+        spawn: (file, args, options) => nodePty.spawn(file, [...args], { ...options, env: { ...options.env } }),
+    });
+}
+function resolveShell() {
+    const configured = process.env.SHELL;
+    const candidates = [
+        configured,
+        process.platform === 'win32' ? process.env.COMSPEC : '/bin/zsh',
+        '/bin/bash',
+    ];
+    for (const candidate of candidates) {
+        if (!candidate || !(0, path_1.isAbsolute)(candidate) || !(0, fs_1.existsSync)(candidate))
+            continue;
+        try {
+            const canonical = (0, fs_1.realpathSync)(candidate);
+            const stat = (0, fs_1.statSync)(canonical);
+            if (stat.isFile() && (stat.mode & 0o111) !== 0)
+                return canonical;
+        }
+        catch {
+            // Try the next bounded shell candidate.
+        }
+    }
+    throw new errors_1.WebWorkbenchError(503, 'No interactive shell is available.', 'terminal_shell_unavailable');
+}
+function shellArguments(shell) {
+    if (process.platform === 'win32')
+        return [];
+    return (0, path_1.basename)(shell) === 'zsh' ? ['-f'] : ['--noprofile', '--norc'];
+}
+function terminalEnvironment(shell) {
+    const env = {
+        TERM: 'xterm-256color',
+        COLORTERM: 'truecolor',
+        SHELL: shell,
+    };
+    for (const key of ['PATH', 'HOME', 'USER', 'LOGNAME', 'LANG', 'LC_ALL', 'LC_CTYPE', 'TMPDIR']) {
+        const value = process.env[key];
+        if (value)
+            env[key] = value;
+    }
+    return env;
+}
+function canonicalDirectory(path) {
+    try {
+        const canonical = (0, fs_1.realpathSync)((0, path_1.resolve)(path));
+        if (!(0, fs_1.statSync)(canonical).isDirectory())
+            throw new Error('not a directory');
+        return canonical;
+    }
+    catch {
+        throw new errors_1.WebWorkbenchError(400, 'Workspace directory is unavailable.');
+    }
+}
+function ticketDigest(ticket) {
+    return (0, crypto_1.createHash)('sha256').update(ticket).digest();
+}
+function boundedPositive(value, name) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw new Error(`${name} must be a positive integer`);
+    }
+    return value;
+}
+function boundedDimension(value, min, max, name) {
+    if (!Number.isSafeInteger(value) || value < min || value > max) {
+        throw new errors_1.WebWorkbenchError(400, `${name} must be an integer from ${min} through ${max}.`);
+    }
+    return value;
+}
+function isHighSurrogate(value) {
+    return value >= 0xd800 && value <= 0xdbff;
+}
+function isLowSurrogate(value) {
+    return value >= 0xdc00 && value <= 0xdfff;
+}
+function terminateProcessTree(entry) {
+    signalProcessTree(entry, 'SIGTERM');
+}
+function forceKillProcessTree(entry) {
+    signalProcessTree(entry, 'SIGKILL');
+}
+function signalProcessTree(entry, signal) {
+    if (process.platform === 'win32') {
+        try {
+            entry.process.kill(signal);
+        }
+        catch {
+            // The process may already have exited.
+        }
+        return;
+    }
+    const rows = rememberProcessTree(entry);
+    let groupSignalled = false;
+    const rootIdentity = entry.ownedProcesses.get(entry.process.pid);
+    if (rootIdentity && rows.get(entry.process.pid)?.identity === rootIdentity) {
+        try {
+            process.kill(-entry.process.pid, signal);
+            groupSignalled = true;
+        }
+        catch {
+            // A PTY child may not remain the process-group leader after shell startup.
+        }
+    }
+    const owned = [...entry.ownedProcesses.entries()]
+        .filter(([pid, identity]) => {
+        const row = rows.get(pid);
+        return row?.identity === identity && !isZombie(row);
+    })
+        .sort(([leftPid], [rightPid]) => {
+        if (leftPid === entry.process.pid)
+            return 1;
+        if (rightPid === entry.process.pid)
+            return -1;
+        return rightPid - leftPid;
+    });
+    for (const [pid] of owned) {
+        try {
+            process.kill(pid, signal);
+        }
+        catch {
+            // The process exited after the bounded ownership snapshot.
+        }
+    }
+    if (!groupSignalled && owned.length === 0) {
+        try {
+            entry.process.kill(signal);
+        }
+        catch {
+            // The process is already gone.
+        }
+    }
+}
+function isProcessTreeAlive(entry) {
+    if (entry.process.isAlive) {
+        try {
+            return entry.process.isAlive();
+        }
+        catch {
+            return true;
+        }
+    }
+    if (process.platform === 'win32') {
+        try {
+            process.kill(entry.process.pid, 0);
+            return true;
+        }
+        catch (error) {
+            return !isMissingProcessError(error);
+        }
+    }
+    const rows = rememberProcessTree(entry);
+    for (const [pid, identity] of entry.ownedProcesses) {
+        const row = rows.get(pid);
+        if (row?.identity === identity && !isZombie(row))
+            return true;
+    }
+    return false;
+}
+function rememberProcessTree(entry) {
+    const rows = readProcessRows();
+    if (rows.size === 0)
+        return rows;
+    const childrenByParent = new Map();
+    for (const row of rows.values()) {
+        const children = childrenByParent.get(row.parentPid) ?? [];
+        children.push(row);
+        childrenByParent.set(row.parentPid, children);
+    }
+    const pending = [entry.process.pid, ...entry.ownedProcesses.keys()];
+    const visited = new Set();
+    while (pending.length > 0) {
+        const pid = pending.pop();
+        if (visited.has(pid))
+            continue;
+        visited.add(pid);
+        const row = rows.get(pid);
+        const existingIdentity = entry.ownedProcesses.get(pid);
+        if (existingIdentity && row?.identity !== existingIdentity)
+            continue;
+        if (row && !existingIdentity)
+            entry.ownedProcesses.set(pid, row.identity);
+        for (const child of childrenByParent.get(pid) ?? [])
+            pending.push(child.pid);
+    }
+    return rows;
+}
+function readProcessRows() {
+    if (process.platform === 'win32')
+        return new Map();
+    try {
+        const output = (0, child_process_1.execFileSync)('/bin/ps', ['-axo', 'pid=,ppid=,stat=,lstart='], {
+            encoding: 'utf8',
+            timeout: 1000,
+            maxBuffer: 1024 * 1024,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const rows = new Map();
+        for (const line of output.split('\n')) {
+            const match = line.match(/^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.+?)\s*$/u);
+            if (!match)
+                continue;
+            const pid = Number(match[1]);
+            const parentPid = Number(match[2]);
+            if (!Number.isSafeInteger(pid) || !Number.isSafeInteger(parentPid))
+                continue;
+            rows.set(pid, Object.freeze({ pid, parentPid, state: match[3], identity: match[4] }));
+        }
+        return rows;
+    }
+    catch {
+        return new Map();
+    }
+}
+function isZombie(row) {
+    return row.state.startsWith('Z');
+}
+function isMissingProcessError(error) {
+    return error?.code === 'ESRCH';
+}
+function delay(milliseconds) {
+    return new Promise(resolvePromise => setTimeout(resolvePromise, milliseconds));
+}
+//# sourceMappingURL=terminal-manager.js.map