@deadragdoll/tellymcp 0.0.10 → 0.0.12

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

@@ -0,0 +1,255 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureXchangeDir = ensureXchangeDir;
+exports.writeXchangeFile = writeXchangeFile;
+exports.writeXchangeRelativeFile = writeXchangeRelativeFile;
+exports.listXchangeFiles = listXchangeFiles;
+exports.deleteXchangeFile = deleteXchangeFile;
+exports.readWorkspaceFile = readWorkspaceFile;
+exports.isTerminalUnavailableError = isTerminalUnavailableError;
+exports.isTerminalTargetInvalidError = isTerminalTargetInvalidError;
+exports.getConfiguredTerminalShell = getConfiguredTerminalShell;
+exports.getConfiguredTerminalShellDisplayName = getConfiguredTerminalShellDisplayName;
+exports.isStreamableTerminalTarget = isStreamableTerminalTarget;
+exports.ensureTerminalTargetForSession = ensureTerminalTargetForSession;
+exports.resolveTerminalTargetFromHint = resolveTerminalTargetFromHint;
+exports.getTerminalWindowHeight = getTerminalWindowHeight;
+exports.getTerminalWindowSize = getTerminalWindowSize;
+exports.captureTerminalPaneRange = captureTerminalPaneRange;
+exports.captureVisibleTerminal = captureVisibleTerminal;
+exports.captureVisibleTerminalHtml = captureVisibleTerminalHtml;
+exports.captureVisibleTerminalAnsi = captureVisibleTerminalAnsi;
+exports.sendAllowedTerminalAction = sendAllowedTerminalAction;
+exports.sendTerminalLiteralText = sendTerminalLiteralText;
+exports.sendTerminalLiteralLine = sendTerminalLiteralLine;
+exports.resizeForegroundTerminal = resizeForegroundTerminal;
+exports.sendForegroundTerminalInput = sendForegroundTerminalInput;
+exports.subscribeForegroundTerminal = subscribeForegroundTerminal;
+exports.stopAllForegroundTerminals = stopAllForegroundTerminals;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const ptyRegistry_1 = require("../terminal/ptyRegistry");
+const ENTER_AFTER_PASTE_DELAY_MS = 75;
+function toPtyConfig(config) {
+    return {
+        shell: config.shell?.trim() || process.env.SHELL || "bash",
+        cols: config.cols ?? 120,
+        rows: config.rows ?? 40,
+        scrollbackLines: config.scrollbackLines ?? 4000,
+    };
+}
+function sanitizeFileName(fileName) {
+    const baseName = node_path_1.default.basename(fileName).trim();
+    const withoutControlChars = Array.from(baseName)
+        .map((char) => (char.charCodeAt(0) < 32 ? "-" : char))
+        .join("");
+    const normalized = withoutControlChars
+        .replace(/[/\\]/g, "-")
+        .replace(/[<>:"|?*]/g, "-")
+        .replace(/\s+/g, " ")
+        .trim();
+    return normalized || "file.bin";
+}
+function sanitizeRelativeXchangePath(relativePath) {
+    const normalized = relativePath
+        .split(/[/\\]+/u)
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0 && segment !== "." && segment !== "..")
+        .join("/");
+    if (!normalized) {
+        throw new Error("Relative exchange path is required.");
+    }
+    return normalized;
+}
+function resolvePathInsideRoot(rootDir, relativePath) {
+    const safeRelativePath = sanitizeRelativeXchangePath(relativePath);
+    const resolvedPath = node_path_1.default.resolve(rootDir, safeRelativePath);
+    const relative = node_path_1.default.relative(rootDir, resolvedPath);
+    if (relative.startsWith("..") ||
+        node_path_1.default.isAbsolute(relative) ||
+        relative.trim() === "") {
+        throw new Error("Resolved path is outside the exchange directory.");
+    }
+    return resolvedPath;
+}
+function resolvePathInsideWorkspace(workspaceDir, filePath) {
+    const resolvedWorkspaceDir = node_path_1.default.resolve(workspaceDir);
+    const resolvedFilePath = node_path_1.default.isAbsolute(filePath)
+        ? node_path_1.default.resolve(filePath)
+        : node_path_1.default.resolve(resolvedWorkspaceDir, filePath);
+    const relative = node_path_1.default.relative(resolvedWorkspaceDir, resolvedFilePath);
+    if (relative.startsWith("..") ||
+        node_path_1.default.isAbsolute(relative) ||
+        relative.trim() === "") {
+        throw new Error("File path is outside the workspace directory.");
+    }
+    return resolvedFilePath;
+}
+async function allocateAvailableFilePath(dir, fileName) {
+    const safeFileName = sanitizeFileName(fileName);
+    const extension = node_path_1.default.extname(safeFileName);
+    const baseName = node_path_1.default.basename(safeFileName, extension);
+    for (let attempt = 0; attempt < 1000; attempt += 1) {
+        const candidateName = attempt === 0
+            ? safeFileName
+            : `${baseName}--${attempt}${extension}`;
+        const candidatePath = node_path_1.default.join(dir, candidateName);
+        try {
+            await (0, promises_1.access)(candidatePath);
+        }
+        catch {
+            return candidatePath;
+        }
+    }
+    throw new Error("Could not allocate a unique file name in exchange directory.");
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+async function ensureXchangeDir(config, workspaceDir, exchangeDirName) {
+    const resolvedDir = node_path_1.default.resolve(workspaceDir, exchangeDirName);
+    await (0, promises_1.mkdir)(resolvedDir, { recursive: true });
+    return resolvedDir;
+}
+async function writeXchangeFile(config, workspaceDir, exchangeDirName, fileName, content) {
+    const dir = await ensureXchangeDir(config, workspaceDir, exchangeDirName);
+    const outputPath = await allocateAvailableFilePath(dir, fileName);
+    await (0, promises_1.writeFile)(outputPath, content);
+    return outputPath;
+}
+async function writeXchangeRelativeFile(config, workspaceDir, exchangeDirName, relativePath, content, options) {
+    const dir = await ensureXchangeDir(config, workspaceDir, exchangeDirName);
+    const outputPath = resolvePathInsideRoot(dir, relativePath);
+    await (0, promises_1.mkdir)(node_path_1.default.dirname(outputPath), { recursive: true });
+    if (options?.append) {
+        await (0, promises_1.appendFile)(outputPath, content);
+    }
+    else {
+        await (0, promises_1.writeFile)(outputPath, content);
+    }
+    return outputPath;
+}
+async function listXchangeFiles(config, workspaceDir, exchangeDirName) {
+    const dir = await ensureXchangeDir(config, workspaceDir, exchangeDirName);
+    return listFilesRecursively(dir);
+}
+async function listFilesRecursively(rootDir) {
+    const files = [];
+    const stack = [rootDir];
+    while (stack.length > 0) {
+        const currentDir = stack.pop();
+        if (!currentDir) {
+            continue;
+        }
+        const entries = await (0, promises_1.readdir)(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = node_path_1.default.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+                continue;
+            }
+            if (entry.isFile()) {
+                files.push(fullPath);
+            }
+        }
+    }
+    return files.sort((left, right) => right.localeCompare(left));
+}
+async function deleteXchangeFile(config, workspaceDir, exchangeDirName, filePath) {
+    const dir = await ensureXchangeDir(config, workspaceDir, exchangeDirName);
+    const resolvedFilePath = node_path_1.default.resolve(filePath);
+    const relative = node_path_1.default.relative(dir, resolvedFilePath);
+    if (relative.startsWith("..") ||
+        node_path_1.default.isAbsolute(relative) ||
+        relative.trim() === "") {
+        throw new Error("File path is outside the exchange directory.");
+    }
+    await (0, promises_1.rm)(resolvedFilePath, { force: true });
+    return true;
+}
+async function readWorkspaceFile(config, workspaceDir, filePath) {
+    const resolvedFilePath = resolvePathInsideWorkspace(workspaceDir, filePath);
+    return (0, promises_1.readFile)(resolvedFilePath);
+}
+function isTerminalUnavailableError(error) {
+    const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+    return message.includes("pty target is unavailable");
+}
+function isTerminalTargetInvalidError(error) {
+    const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+    return message.includes("unknown pty target");
+}
+function getConfiguredTerminalShell(config) {
+    return toPtyConfig(config).shell;
+}
+function getConfiguredTerminalShellDisplayName(config) {
+    return (0, ptyRegistry_1.getPtyShellDisplayName)(toPtyConfig(config));
+}
+function isStreamableTerminalTarget(target) {
+    return (0, ptyRegistry_1.isPtyTarget)(target);
+}
+function ensureTerminalTargetForSession(config, input) {
+    return (0, ptyRegistry_1.ensurePtySession)(toPtyConfig(config), {
+        sessionId: input.sessionId,
+        ...(input.cwd ? { cwd: input.cwd } : {}),
+        ...((0, ptyRegistry_1.isPtyTarget)(input.target) ? { target: input.target } : {}),
+    });
+}
+async function resolveTerminalTargetFromHint(config, hint) {
+    const target = hint.terminalTarget?.trim() || (0, ptyRegistry_1.buildPtyTarget)("default");
+    return (0, ptyRegistry_1.hasPtyTarget)(target) ? target : hint.terminalTarget?.trim() ?? null;
+}
+async function getTerminalWindowHeight(config, target) {
+    return (0, ptyRegistry_1.getPtyWindowHeight)(target);
+}
+async function getTerminalWindowSize(config, target) {
+    return (0, ptyRegistry_1.getPtyWindowSize)(target);
+}
+async function captureTerminalPaneRange(config, target, start, includeEscapes) {
+    void includeEscapes;
+    return await (0, ptyRegistry_1.capturePtyRange)(target, start);
+}
+async function captureVisibleTerminal(config, target, fallbackLines, visibleScreens) {
+    return await (0, ptyRegistry_1.captureVisiblePty)(target, fallbackLines, visibleScreens);
+}
+async function captureVisibleTerminalHtml(config, target, fallbackLines, visibleScreens) {
+    return await (0, ptyRegistry_1.renderVisiblePtyHtml)(target, fallbackLines, visibleScreens);
+}
+async function captureVisibleTerminalAnsi(config, target, fallbackLines, visibleScreens) {
+    return await (0, ptyRegistry_1.renderVisiblePtyAnsi)(target, fallbackLines, visibleScreens);
+}
+async function sendAllowedTerminalAction(config, target, action) {
+    void config;
+    (0, ptyRegistry_1.sendPtyAction)(target, action);
+}
+async function sendTerminalLiteralText(config, target, text) {
+    void config;
+    const normalized = text.replace(/\r?\n/g, " ");
+    if (normalized.length > 0) {
+        (0, ptyRegistry_1.sendPtyText)(target, normalized);
+    }
+}
+async function sendTerminalLiteralLine(config, target, text) {
+    await sendTerminalLiteralText(config, target, text);
+    if (text.replace(/\r?\n/g, " ").length > 0) {
+        await delay(ENTER_AFTER_PASTE_DELAY_MS);
+    }
+    (0, ptyRegistry_1.sendPtyAction)(target, "enter");
+}
+function resizeForegroundTerminal(target, cols, rows) {
+    (0, ptyRegistry_1.resizePtyTarget)(target, cols, rows);
+}
+function sendForegroundTerminalInput(target, data) {
+    (0, ptyRegistry_1.sendPtyText)(target, data);
+}
+function subscribeForegroundTerminal(target, input) {
+    return (0, ptyRegistry_1.subscribePtyTarget)(target, input);
+}
+function stopAllForegroundTerminals() {
+    (0, ptyRegistry_1.stopAllPtyTargets)();
+}