@bbigbang/agent-node 0.1.0

package/dist/terminalManager.js

@@ -0,0 +1,254 @@
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { resolveWorkspacePath } from '@bbigbang/runtime-acp';
+const DEFAULT_COLS = 120;
+const DEFAULT_ROWS = 32;
+const MAX_BUFFER_CHARS = 512_000;
+const MAX_STARTUP_COMMAND_CHARS = 512;
+const TERMINAL_BACKEND_UNAVAILABLE_MESSAGE = 'Persistent terminal backend is unavailable on this node.';
+const require = createRequire(import.meta.url);
+export class TerminalManagerError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+export class TerminalManager {
+    sessions = new Map();
+    outputListeners = new Set();
+    exitListeners = new Set();
+    injectedBackend;
+    backendState = null;
+    constructor(options) {
+        this.injectedBackend = options?.backend ?? null;
+    }
+    isBackendAvailable() {
+        return this.getBackendState().available;
+    }
+    getBackendUnavailableReason() {
+        const backend = this.getBackendState();
+        return backend.available ? null : backend.reason;
+    }
+    list(workspaceRoot) {
+        this.requireBackend();
+        return Array.from(this.sessions.values())
+            .filter((session) => session.info.workspaceRoot === workspaceRoot)
+            .map((session) => ({ ...session.info }))
+            .sort((left, right) => left.createdAt - right.createdAt);
+    }
+    create(params) {
+        const nodePty = this.requireBackend();
+        const workspaceRoot = resolveExistingRoot(params.workspaceRoot);
+        const cwd = resolveTerminalCwd(workspaceRoot, params.cwd);
+        const startupCommand = normalizeStartupCommand(params.startupCommand);
+        const closeOnStartupCommand = params.closeOnStartupCommand === true;
+        if (closeOnStartupCommand && !startupCommand) {
+            throw new TerminalManagerError('invalid_request', 'Terminal closeOnStartupCommand requires a startup command.');
+        }
+        const cols = normalizeDimension(params.cols, DEFAULT_COLS);
+        const rows = normalizeDimension(params.rows, DEFAULT_ROWS);
+        const now = Date.now();
+        const info = {
+            terminalId: params.terminalId,
+            workspaceRoot,
+            cwd,
+            name: params.name?.trim() || `Terminal ${this.list(workspaceRoot).length + 1}`,
+            cols,
+            rows,
+            createdAt: now,
+            lastActivityAt: now,
+            exited: false,
+            exitCode: null,
+            signal: null,
+        };
+        const shell = process.env.SHELL || '/bin/bash';
+        const pty = nodePty.spawn(closeOnStartupCommand ? resolveOneShotShell(shell) : shell, closeOnStartupCommand ? ['-lc', startupCommand] : ['-i'], {
+            name: 'xterm-256color',
+            cols,
+            rows,
+            cwd,
+            env: {
+                ...process.env,
+                TERM: 'xterm-256color',
+                COLORTERM: 'truecolor',
+            },
+        });
+        const session = {
+            pty,
+            info,
+            buffer: '',
+        };
+        pty.onData((data) => {
+            session.info.lastActivityAt = Date.now();
+            session.buffer = appendBuffer(session.buffer, data);
+            for (const listener of this.outputListeners) {
+                listener({ terminalId: info.terminalId, data });
+            }
+        });
+        pty.onExit((event) => {
+            const signal = normalizeExitSignal(event.signal);
+            session.info.exited = true;
+            session.info.exitCode = event.exitCode;
+            session.info.signal = signal;
+            session.info.lastActivityAt = Date.now();
+            for (const listener of this.exitListeners) {
+                listener({
+                    terminalId: info.terminalId,
+                    exitCode: event.exitCode,
+                    signal,
+                });
+            }
+        });
+        this.sessions.set(info.terminalId, session);
+        if (startupCommand && !closeOnStartupCommand) {
+            pty.write(`${startupCommand}\n`);
+        }
+        return { ...info };
+    }
+    snapshot(terminalId) {
+        const session = this.requireSession(terminalId);
+        return {
+            terminal: { ...session.info },
+            buffer: session.buffer,
+        };
+    }
+    input(terminalId, data) {
+        const session = this.requireSession(terminalId);
+        if (session.info.exited) {
+            throw new TerminalManagerError('io_error', 'Terminal has already exited.');
+        }
+        session.info.lastActivityAt = Date.now();
+        session.pty.write(data);
+    }
+    resize(terminalId, cols, rows) {
+        const session = this.requireSession(terminalId);
+        const normalizedCols = normalizeDimension(cols, DEFAULT_COLS);
+        const normalizedRows = normalizeDimension(rows, DEFAULT_ROWS);
+        session.info.cols = normalizedCols;
+        session.info.rows = normalizedRows;
+        session.info.lastActivityAt = Date.now();
+        session.pty.resize(normalizedCols, normalizedRows);
+    }
+    close(terminalId) {
+        const session = this.requireSession(terminalId);
+        if (!session.info.exited) {
+            session.pty.kill();
+        }
+        this.sessions.delete(terminalId);
+    }
+    onOutput(listener) {
+        this.outputListeners.add(listener);
+        return () => {
+            this.outputListeners.delete(listener);
+        };
+    }
+    onExit(listener) {
+        this.exitListeners.add(listener);
+        return () => {
+            this.exitListeners.delete(listener);
+        };
+    }
+    requireSession(terminalId) {
+        const session = this.sessions.get(terminalId);
+        if (!session) {
+            throw new TerminalManagerError('not_found', 'Terminal not found.');
+        }
+        return session;
+    }
+    requireBackend() {
+        const backend = this.getBackendState();
+        if (!backend.available) {
+            throw new TerminalManagerError('io_error', backend.reason);
+        }
+        return backend.module;
+    }
+    getBackendState() {
+        if (this.backendState)
+            return this.backendState;
+        if (this.injectedBackend) {
+            this.backendState = { available: true, module: this.injectedBackend };
+            return this.backendState;
+        }
+        try {
+            const module = require('node-pty');
+            this.backendState = { available: true, module };
+        }
+        catch (error) {
+            const detail = String(error?.message ?? error);
+            this.backendState = {
+                available: false,
+                reason: `${TERMINAL_BACKEND_UNAVAILABLE_MESSAGE} ${detail}`.trim(),
+            };
+        }
+        return this.backendState;
+    }
+}
+function normalizeStartupCommand(value) {
+    if (value == null)
+        return null;
+    if (typeof value !== 'string') {
+        throw new TerminalManagerError('invalid_request', 'Terminal startup command must be a string.');
+    }
+    const trimmed = value.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.length > MAX_STARTUP_COMMAND_CHARS) {
+        throw new TerminalManagerError('invalid_request', `Terminal startup command is too long; maximum is ${MAX_STARTUP_COMMAND_CHARS} characters.`);
+    }
+    if (/[\r\n]/.test(trimmed)) {
+        throw new TerminalManagerError('invalid_request', 'Terminal startup command must be a single line.');
+    }
+    return trimmed;
+}
+function resolveExistingRoot(workspaceRoot) {
+    const resolved = path.resolve(workspaceRoot);
+    const stat = fs.statSync(resolved, { throwIfNoEntry: false });
+    if (!stat) {
+        throw new TerminalManagerError('not_found', 'Workspace root not found.');
+    }
+    if (!stat.isDirectory()) {
+        throw new TerminalManagerError('not_directory', 'Workspace root is not a directory.');
+    }
+    return resolved;
+}
+function resolveTerminalCwd(workspaceRoot, cwd) {
+    if (!cwd)
+        return workspaceRoot;
+    const absoluteRequested = path.isAbsolute(cwd)
+        ? path.resolve(cwd)
+        : path.resolve(workspaceRoot, cwd);
+    try {
+        return resolveWorkspacePath(workspaceRoot, absoluteRequested);
+    }
+    catch {
+        throw new TerminalManagerError('path_outside_workspace', 'Terminal path escapes workspace root.');
+    }
+}
+function normalizeDimension(value, fallback) {
+    if (!Number.isFinite(value))
+        return fallback;
+    const normalized = Math.floor(value);
+    if (normalized < 20)
+        return 20;
+    return normalized;
+}
+function resolveOneShotShell(shell) {
+    if (path.basename(shell) === 'fish' && fs.existsSync('/bin/bash')) {
+        return '/bin/bash';
+    }
+    return shell;
+}
+function normalizeExitSignal(signal) {
+    if (signal == null || signal === 0 || signal === '0') {
+        return null;
+    }
+    return String(signal);
+}
+function appendBuffer(existing, next) {
+    const combined = `${existing}${next}`;
+    if (combined.length <= MAX_BUFFER_CHARS)
+        return combined;
+    return combined.slice(combined.length - MAX_BUFFER_CHARS);
+}