@deadragdoll/tellymcp 0.0.10 → 0.0.11

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

@@ -1,363 +0,0 @@
-"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.isTmuxUnavailableError = isTmuxUnavailableError;
-exports.isTmuxTargetInvalidError = isTmuxTargetInvalidError;
-exports.resolveTmuxTargetFromHint = resolveTmuxTargetFromHint;
-exports.getTmuxWindowHeight = getTmuxWindowHeight;
-exports.captureTmuxPaneRange = captureTmuxPaneRange;
-exports.captureVisibleTmuxPane = captureVisibleTmuxPane;
-exports.sendAllowedTmuxAction = sendAllowedTmuxAction;
-exports.sendTmuxLiteralText = sendTmuxLiteralText;
-exports.sendTmuxLiteralLine = sendTmuxLiteralLine;
-const node_child_process_1 = require("node:child_process");
-const promises_1 = require("node:fs/promises");
-const node_path_1 = __importDefault(require("node:path"));
-const ENTER_AFTER_PASTE_DELAY_MS = 75;
-const SUBMIT_LINE_KEY = "C-m";
-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);
-    });
-}
-function execFileAsync(command, args) {
-    return new Promise((resolve, reject) => {
-        (0, node_child_process_1.execFile)(command, args, (error) => {
-            if (error) {
-                reject(error);
-                return;
-            }
-            resolve();
-        });
-    });
-}
-function execFileOutputAsync(command, args) {
-    return new Promise((resolve, reject) => {
-        (0, node_child_process_1.execFile)(command, args, (error, stdout, stderr) => {
-            if (error) {
-                reject(error);
-                return;
-            }
-            resolve({ stdout, stderr });
-        });
-    });
-}
-function buildTmuxArgs(config, args, socketPath) {
-    const resolvedSocketPath = socketPath ?? config.socketPath;
-    return resolvedSocketPath ? ["-S", resolvedSocketPath, ...args] : args;
-}
-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 isTmuxUnavailableError(error) {
-    const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
-    return (message.includes("error connecting to /tmp/tmux-") ||
-        message.includes("No such file or directory") ||
-        message.includes("ENOENT") ||
-        message.includes("tmux is unavailable"));
-}
-function isTmuxTargetInvalidError(error) {
-    const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
-    return (message.includes("can't find pane") ||
-        message.includes("can't find window") ||
-        message.includes("can't find session"));
-}
-async function listTmuxPanes(config) {
-    const { stdout } = await execFileOutputAsync("tmux", buildTmuxArgs(config, [
-        "list-panes",
-        "-a",
-        "-F",
-        "#{session_name}\t#{window_name}\t#{window_index}\t#{pane_id}\t#{pane_index}",
-    ]));
-    return stdout
-        .split("\n")
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0)
-        .map((line) => {
-        const [sessionName = "", windowName = "", windowIndexRaw = "", paneId = "", paneIndexRaw = ""] = line.split("\t");
-        return {
-            sessionName,
-            windowName,
-            windowIndex: Number.parseInt(windowIndexRaw, 10),
-            paneId,
-            paneIndex: Number.parseInt(paneIndexRaw, 10),
-        };
-    })
-        .filter((pane) => pane.sessionName &&
-        pane.paneId &&
-        Number.isFinite(pane.windowIndex) &&
-        Number.isFinite(pane.paneIndex));
-}
-async function resolveTmuxTargetFromHint(config, hint) {
-    const panes = await listTmuxPanes(config);
-    const byPaneId = hint.tmuxPaneId
-        ? panes.find((pane) => pane.paneId === hint.tmuxPaneId)
-        : null;
-    if (byPaneId) {
-        return byPaneId.paneId;
-    }
-    const exactMatch = panes.find((pane) => {
-        if (!hint.tmuxSessionName) {
-            return false;
-        }
-        if (pane.sessionName !== hint.tmuxSessionName) {
-            return false;
-        }
-        if (typeof hint.tmuxWindowIndex === "number" &&
-            pane.windowIndex !== hint.tmuxWindowIndex) {
-            return false;
-        }
-        if (typeof hint.tmuxPaneIndex === "number" &&
-            pane.paneIndex !== hint.tmuxPaneIndex) {
-            return false;
-        }
-        if (hint.tmuxWindowName &&
-            pane.windowName !== hint.tmuxWindowName) {
-            return false;
-        }
-        return true;
-    });
-    if (exactMatch) {
-        return exactMatch.paneId;
-    }
-    const fallbackBySessionAndPane = panes.find((pane) => {
-        if (!hint.tmuxSessionName || typeof hint.tmuxPaneIndex !== "number") {
-            return false;
-        }
-        return (pane.sessionName === hint.tmuxSessionName &&
-            pane.paneIndex === hint.tmuxPaneIndex);
-    });
-    return fallbackBySessionAndPane?.paneId ?? null;
-}
-async function getTmuxWindowHeight(config, target) {
-    const { stdout: heightRaw } = await execFileOutputAsync("tmux", buildTmuxArgs(config, ["display-message", "-p", "-t", target, "#{window_height}"]));
-    const height = Number.parseInt(heightRaw.trim(), 10);
-    return Number.isFinite(height) && height > 0 ? height : null;
-}
-async function captureTmuxPaneRange(config, target, start, includeEscapes) {
-    const args = [
-        "capture-pane",
-        "-p",
-        ...(includeEscapes ? ["-e"] : []),
-        "-t",
-        target,
-        "-S",
-        start,
-    ];
-    const { stdout } = await execFileOutputAsync("tmux", buildTmuxArgs(config, args));
-    return stdout.replaceAll("\u0000", "");
-}
-async function captureVisibleTmuxPane(config, target, fallbackLines, visibleScreens) {
-    const height = await getTmuxWindowHeight(config, target);
-    const baseLines = typeof height === "number" && height > 0 ? height : Math.max(1, fallbackLines);
-    const lines = Math.max(1, baseLines * Math.max(1, visibleScreens));
-    let stdout = "";
-    try {
-        ({ stdout } = await execFileOutputAsync("tmux", buildTmuxArgs(config, [
-            "capture-pane",
-            "-p",
-            "-e",
-            "-a",
-            "-t",
-            target,
-            "-S",
-            `-${lines}`,
-        ])));
-    }
-    catch (error) {
-        const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
-        if (!message.includes("no alternate screen")) {
-            throw error;
-        }
-        ({ stdout } = await execFileOutputAsync("tmux", buildTmuxArgs(config, [
-            "capture-pane",
-            "-p",
-            "-e",
-            "-t",
-            target,
-            "-S",
-            `-${lines}`,
-        ])));
-    }
-    return stdout.replaceAll("\u0000", "");
-}
-async function sendAllowedTmuxAction(config, target, action) {
-    const key = action === "up"
-        ? "Up"
-        : action === "down"
-            ? "Down"
-            : action === "slash"
-                ? "/"
-                : action === "delete"
-                    ? "BSpace"
-                    : action === "tab"
-                        ? "Tab"
-                        : action === "escape"
-                            ? "Escape"
-                            : action === "interrupt"
-                                ? "C-c"
-                                : "Enter";
-    await execFileAsync("tmux", buildTmuxArgs(config, ["send-keys", "-t", target, key]));
-}
-async function sendTmuxLiteralText(config, target, text) {
-    const normalized = text.replace(/\r?\n/g, " ");
-    const bufferName = `telegram-mcp-${Date.now().toString(36)}`;
-    if (normalized.length > 0) {
-        try {
-            await execFileAsync("tmux", buildTmuxArgs(config, ["set-buffer", "-b", bufferName, normalized]));
-            await execFileAsync("tmux", buildTmuxArgs(config, [
-                "paste-buffer",
-                "-d",
-                "-b",
-                bufferName,
-                "-t",
-                target,
-            ]));
-        }
-        finally {
-            await execFileAsync("tmux", buildTmuxArgs(config, ["delete-buffer", "-b", bufferName])).catch(() => undefined);
-        }
-    }
-}
-async function sendTmuxLiteralLine(config, target, text) {
-    await sendTmuxLiteralText(config, target, text);
-    if (text.length > 0) {
-        await delay(ENTER_AFTER_PASTE_DELAY_MS);
-    }
-    await execFileAsync("tmux", buildTmuxArgs(config, ["send-keys", "-t", target, SUBMIT_LINE_KEY]));
-}