@deadragdoll/tellymcp 0.0.9 → 0.0.11

package/dist/services/features/telegram-mcp/src/shared/integrations/terminal/ptyRegistry.js

@@ -0,0 +1,543 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPtyTarget = isPtyTarget;
+exports.buildPtyTarget = buildPtyTarget;
+exports.getPtyShellDisplayName = getPtyShellDisplayName;
+exports.hasPtyTarget = hasPtyTarget;
+exports.listPtyTargets = listPtyTargets;
+exports.ensurePtySession = ensurePtySession;
+exports.getPtyWindowHeight = getPtyWindowHeight;
+exports.getPtyWindowSize = getPtyWindowSize;
+exports.capturePtyRange = capturePtyRange;
+exports.captureVisiblePty = captureVisiblePty;
+exports.renderVisiblePtyHtml = renderVisiblePtyHtml;
+exports.renderVisiblePtyAnsi = renderVisiblePtyAnsi;
+exports.sendPtyAction = sendPtyAction;
+exports.sendPtyText = sendPtyText;
+exports.resizePtyTarget = resizePtyTarget;
+exports.subscribePtyTarget = subscribePtyTarget;
+exports.stopPtyTarget = stopPtyTarget;
+exports.stopAllPtyTargets = stopAllPtyTargets;
+const node_path_1 = __importDefault(require("node:path"));
+const node_pty_1 = require("node-pty");
+const XtermHeadless = __importStar(require("@xterm/headless"));
+const PTY_TARGET_PREFIX = "pty:";
+const sessions = new Map();
+function getShellDisplayName(shell) {
+    const baseName = node_path_1.default.basename(shell.trim());
+    return baseName || shell.trim() || "bash";
+}
+function buildExitLine(record) {
+    const parts = ["[pty exited"];
+    if (typeof record.exitCode === "number") {
+        parts.push(`code=${record.exitCode}`);
+    }
+    if (typeof record.signal === "number") {
+        parts.push(`signal=${record.signal}`);
+    }
+    return `${parts.join(" ")}]`;
+}
+function createHeadlessTerminal(config) {
+    return new XtermHeadless.Terminal({
+        cols: config.cols,
+        rows: config.rows,
+        scrollback: config.scrollbackLines,
+        allowProposedApi: true,
+    });
+}
+function createSessionRecord(config, input) {
+    const target = input.target?.trim() || buildPtyTarget(input.sessionId);
+    const cwd = input.cwd?.trim() || process.cwd();
+    const terminal = createHeadlessTerminal(config);
+    const record = {
+        target,
+        sessionId: input.sessionId.trim(),
+        cwd,
+        shell: config.shell,
+        cols: config.cols,
+        rows: config.rows,
+        scrollbackLines: config.scrollbackLines,
+        terminal,
+        pendingWrite: Promise.resolve(),
+        pty: null,
+        exited: false,
+    };
+    const pty = (0, node_pty_1.spawn)(record.shell, [], {
+        name: "xterm-color",
+        cols: record.cols,
+        rows: record.rows,
+        cwd: record.cwd,
+        env: process.env,
+    });
+    pty.onData((data) => {
+        record.pendingWrite = record.pendingWrite.then(() => new Promise((resolve) => {
+            record.terminal.write(data, resolve);
+        }));
+    });
+    pty.onExit(({ exitCode, signal }) => {
+        record.pty = null;
+        record.exited = true;
+        record.exitCode = exitCode;
+        record.signal = signal;
+        record.pendingWrite = record.pendingWrite.then(() => new Promise((resolve) => {
+            record.terminal.writeln(buildExitLine(record), resolve);
+        }));
+    });
+    record.pty = pty;
+    return record;
+}
+function getSessionRecord(target) {
+    const record = sessions.get(target);
+    if (!record) {
+        throw new Error(`pty target is unavailable: ${target}`);
+    }
+    return record;
+}
+function ensureRunningPty(record) {
+    if (!record.pty || record.exited) {
+        throw new Error(`pty target is unavailable: ${record.target}`);
+    }
+    return record.pty;
+}
+function parseCaptureStart(start) {
+    const parsed = Number.parseInt(start.trim(), 10);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function snapshotTerminalLines(record) {
+    const buffer = record.terminal.buffer.active;
+    const lines = [];
+    for (let index = 0; index < buffer.length; index += 1) {
+        lines.push(buffer.getLine(index)?.translateToString(true) ?? "");
+    }
+    return lines;
+}
+function snapshotTerminalContentLines(record) {
+    const lines = snapshotTerminalLines(record);
+    while (lines.length > 0 && lines[lines.length - 1] === "") {
+        lines.pop();
+    }
+    return lines;
+}
+function escapeHtml(text) {
+    return text
+        .replace(/&/gu, "&amp;")
+        .replace(/</gu, "&lt;")
+        .replace(/>/gu, "&gt;");
+}
+function xtermColor(index) {
+    const base = [
+        "#000000",
+        "#800000",
+        "#008000",
+        "#808000",
+        "#000080",
+        "#800080",
+        "#008080",
+        "#c0c0c0",
+        "#808080",
+        "#ff0000",
+        "#00ff00",
+        "#ffff00",
+        "#0000ff",
+        "#ff00ff",
+        "#00ffff",
+        "#ffffff",
+    ];
+    if (index < 16) {
+        return base[index] ?? null;
+    }
+    if (index >= 16 && index <= 231) {
+        const value = index - 16;
+        const r = Math.floor(value / 36);
+        const g = Math.floor((value % 36) / 6);
+        const b = value % 6;
+        const steps = [0, 95, 135, 175, 215, 255];
+        return `rgb(${steps[r]},${steps[g]},${steps[b]})`;
+    }
+    if (index >= 232 && index <= 255) {
+        const gray = 8 + (index - 232) * 10;
+        return `rgb(${gray},${gray},${gray})`;
+    }
+    return null;
+}
+function rgbColor(value) {
+    const r = (value >> 16) & 0xff;
+    const g = (value >> 8) & 0xff;
+    const b = value & 0xff;
+    return `rgb(${r},${g},${b})`;
+}
+function cellColor(isDefault, isPalette, colorValue) {
+    if (isDefault) {
+        return null;
+    }
+    if (isPalette) {
+        return xtermColor(colorValue);
+    }
+    return rgbColor(colorValue);
+}
+function styleStateEquals(left, right) {
+    return (left.fg === right.fg &&
+        left.bg === right.bg &&
+        left.bold === right.bold &&
+        left.underline === right.underline &&
+        left.italic === right.italic &&
+        left.inverse === right.inverse);
+}
+function styleStateToHtml(state) {
+    const fg = state.inverse ? state.bg : state.fg;
+    const bg = state.inverse ? state.fg : state.bg;
+    const classes = [];
+    const styles = [];
+    if (state.bold) {
+        classes.push("ansi-bold");
+    }
+    if (state.underline) {
+        classes.push("ansi-underline");
+    }
+    if (state.italic) {
+        styles.push("font-style:italic");
+    }
+    if (fg) {
+        styles.push(`color:${fg}`);
+    }
+    if (bg) {
+        styles.push(`background:${bg}`);
+    }
+    if (classes.length === 0 && styles.length === 0) {
+        return "";
+    }
+    const attrs = [];
+    if (classes.length > 0) {
+        attrs.push(`class="${classes.join(" ")}"`);
+    }
+    if (styles.length > 0) {
+        attrs.push(`style="${styles.join(";")}"`);
+    }
+    return attrs.join(" ");
+}
+function getVisibleWindowRange(record, fallbackLines, visibleScreens) {
+    const buffer = record.terminal.buffer.active;
+    const lineCount = Math.max(1, (record.rows > 0 ? record.rows : fallbackLines) * Math.max(1, visibleScreens));
+    const start = Math.max(0, buffer.viewportY + record.rows - lineCount);
+    const end = Math.min(buffer.length, start + lineCount);
+    return { start, end };
+}
+function renderVisiblePtyHtmlFromRecord(record, fallbackLines, visibleScreens) {
+    const buffer = record.terminal.buffer.active;
+    const { start, end } = getVisibleWindowRange(record, fallbackLines, visibleScreens);
+    const lines = [];
+    for (let y = start; y < end; y += 1) {
+        const line = buffer.getLine(y);
+        if (!line) {
+            lines.push("");
+            continue;
+        }
+        const parts = [];
+        let chunk = "";
+        let currentStyle = null;
+        const flushChunk = () => {
+            if (!chunk) {
+                return;
+            }
+            const escaped = escapeHtml(chunk);
+            if (!currentStyle) {
+                parts.push(escaped);
+            }
+            else {
+                const attrs = styleStateToHtml(currentStyle);
+                parts.push(attrs ? `<span ${attrs}>${escaped}</span>` : escaped);
+            }
+            chunk = "";
+        };
+        for (let x = 0; x < record.cols; x += 1) {
+            const cell = line.getCell(x);
+            if (!cell || cell.getWidth() === 0) {
+                continue;
+            }
+            const nextStyle = {
+                fg: cellColor(cell.isFgDefault(), cell.isFgPalette(), cell.getFgColor()),
+                bg: cellColor(cell.isBgDefault(), cell.isBgPalette(), cell.getBgColor()),
+                bold: cell.isBold() > 0,
+                underline: cell.isUnderline() > 0,
+                italic: cell.isItalic() > 0,
+                inverse: cell.isInverse() > 0,
+            };
+            if (!currentStyle || !styleStateEquals(currentStyle, nextStyle)) {
+                flushChunk();
+                currentStyle = nextStyle;
+            }
+            chunk += cell.getChars() || " ";
+        }
+        flushChunk();
+        lines.push(parts.join(""));
+    }
+    return lines.join("\n");
+}
+function styleStateToSgrCodes(state) {
+    const codes = [0];
+    if (state.bold) {
+        codes.push(1);
+    }
+    if (state.italic) {
+        codes.push(3);
+    }
+    if (state.underline) {
+        codes.push(4);
+    }
+    if (state.inverse) {
+        codes.push(7);
+    }
+    const pushColor = (value, isBackground) => {
+        if (!value) {
+            return;
+        }
+        if (value.startsWith("#")) {
+            const normalized = value.slice(1);
+            if (normalized.length === 6) {
+                const numeric = Number.parseInt(normalized, 16);
+                const r = (numeric >> 16) & 0xff;
+                const g = (numeric >> 8) & 0xff;
+                const b = numeric & 0xff;
+                codes.push(isBackground ? 48 : 38, 2, r, g, b);
+            }
+            return;
+        }
+        const match = /^rgb\((\d+),(\d+),(\d+)\)$/u.exec(value);
+        if (!match) {
+            return;
+        }
+        codes.push(isBackground ? 48 : 38, 2, Number(match[1]), Number(match[2]), Number(match[3]));
+    };
+    pushColor(state.fg, false);
+    pushColor(state.bg, true);
+    return codes;
+}
+function renderVisiblePtyAnsiFromRecord(record, fallbackLines, visibleScreens) {
+    const buffer = record.terminal.buffer.active;
+    const { start, end } = getVisibleWindowRange(record, fallbackLines, visibleScreens);
+    const lines = [];
+    for (let y = start; y < end; y += 1) {
+        const line = buffer.getLine(y);
+        if (!line) {
+            lines.push("");
+            continue;
+        }
+        let row = "";
+        let currentStyle = null;
+        for (let x = 0; x < record.cols; x += 1) {
+            const cell = line.getCell(x);
+            if (!cell || cell.getWidth() === 0) {
+                continue;
+            }
+            const nextStyle = {
+                fg: cellColor(cell.isFgDefault(), cell.isFgPalette(), cell.getFgColor()),
+                bg: cellColor(cell.isBgDefault(), cell.isBgPalette(), cell.getBgColor()),
+                bold: cell.isBold() > 0,
+                underline: cell.isUnderline() > 0,
+                italic: cell.isItalic() > 0,
+                inverse: cell.isInverse() > 0,
+            };
+            if (!currentStyle || !styleStateEquals(currentStyle, nextStyle)) {
+                row += `\u001b[${styleStateToSgrCodes(nextStyle).join(";")}m`;
+                currentStyle = nextStyle;
+            }
+            row += cell.getChars() || " ";
+        }
+        if (currentStyle) {
+            row += "\u001b[0m";
+        }
+        lines.push(row.trimEnd());
+    }
+    return lines.join("\n");
+}
+function isPtyTarget(target) {
+    return typeof target === "string" && target.startsWith(PTY_TARGET_PREFIX);
+}
+function buildPtyTarget(sessionId) {
+    return `${PTY_TARGET_PREFIX}${sessionId.trim()}`;
+}
+function getPtyShellDisplayName(config) {
+    return getShellDisplayName(config.shell);
+}
+function hasPtyTarget(target) {
+    return sessions.has(target);
+}
+function listPtyTargets() {
+    return [...sessions.keys()];
+}
+function ensurePtySession(config, input) {
+    const target = input.target?.trim() || buildPtyTarget(input.sessionId);
+    const existing = sessions.get(target);
+    if (existing && existing.pty && !existing.exited) {
+        return target;
+    }
+    if (existing) {
+        existing.terminal.dispose();
+    }
+    const record = createSessionRecord(config, {
+        ...input,
+        target,
+    });
+    sessions.set(target, record);
+    return target;
+}
+function getPtyWindowHeight(target) {
+    const record = getSessionRecord(target);
+    return record.rows;
+}
+function getPtyWindowSize(target) {
+    const record = sessions.get(target);
+    if (!record) {
+        return null;
+    }
+    return {
+        cols: record.cols,
+        rows: record.rows,
+    };
+}
+async function capturePtyRange(target, start) {
+    const record = getSessionRecord(target);
+    await record.pendingWrite;
+    const captureStart = parseCaptureStart(start);
+    const lines = snapshotTerminalContentLines(record);
+    if (lines.length === 0) {
+        return "";
+    }
+    if (captureStart === null) {
+        return lines.join("\n");
+    }
+    if (captureStart < 0) {
+        return lines.slice(Math.max(0, lines.length + captureStart)).join("\n");
+    }
+    return lines.slice(captureStart).join("\n");
+}
+async function captureVisiblePty(target, fallbackLines, visibleScreens) {
+    const record = getSessionRecord(target);
+    await record.pendingWrite;
+    const buffer = record.terminal.buffer.active;
+    const lineCount = Math.max(1, (record.rows > 0 ? record.rows : fallbackLines) * Math.max(1, visibleScreens));
+    const start = Math.max(0, buffer.viewportY + record.rows - lineCount);
+    const end = Math.min(buffer.length, start + lineCount);
+    const lines = [];
+    for (let index = start; index < end; index += 1) {
+        lines.push(buffer.getLine(index)?.translateToString(true) ?? "");
+    }
+    return lines.join("\r\n");
+}
+async function renderVisiblePtyHtml(target, fallbackLines, visibleScreens) {
+    const record = getSessionRecord(target);
+    await record.pendingWrite;
+    return renderVisiblePtyHtmlFromRecord(record, fallbackLines, visibleScreens);
+}
+async function renderVisiblePtyAnsi(target, fallbackLines, visibleScreens) {
+    const record = getSessionRecord(target);
+    await record.pendingWrite;
+    return renderVisiblePtyAnsiFromRecord(record, fallbackLines, visibleScreens);
+}
+function sendPtyAction(target, action) {
+    const pty = ensureRunningPty(getSessionRecord(target));
+    const input = action === "up"
+        ? "\u001b[A"
+        : action === "down"
+            ? "\u001b[B"
+            : action === "enter"
+                ? "\r"
+                : action === "slash"
+                    ? "/"
+                    : action === "delete"
+                        ? "\u007f"
+                        : action === "tab"
+                            ? "\t"
+                            : action === "escape"
+                                ? "\u001b"
+                                : "\u0003";
+    pty.write(input);
+}
+function sendPtyText(target, text) {
+    const pty = ensureRunningPty(getSessionRecord(target));
+    pty.write(text);
+}
+function resizePtyTarget(target, cols, rows) {
+    const record = getSessionRecord(target);
+    const pty = ensureRunningPty(record);
+    record.cols = cols;
+    record.rows = rows;
+    record.terminal.resize(cols, rows);
+    pty.resize(cols, rows);
+}
+function subscribePtyTarget(target, input) {
+    const record = getSessionRecord(target);
+    const pty = ensureRunningPty(record);
+    const disposers = [];
+    if (input.onData) {
+        const disposable = pty.onData(input.onData);
+        disposers.push(() => {
+            disposable.dispose();
+        });
+    }
+    if (input.onExit) {
+        const disposable = pty.onExit(({ exitCode, signal, }) => {
+            input.onExit?.({ exitCode, signal });
+        });
+        disposers.push(() => {
+            disposable.dispose();
+        });
+    }
+    return () => {
+        for (const dispose of disposers) {
+            dispose();
+        }
+    };
+}
+function stopPtyTarget(target) {
+    const record = sessions.get(target);
+    if (!record) {
+        return false;
+    }
+    record.pty?.kill();
+    record.pty = null;
+    record.exited = true;
+    record.terminal.dispose();
+    return true;
+}
+function stopAllPtyTargets() {
+    for (const target of listPtyTargets()) {
+        stopPtyTarget(target);
+    }
+}