@deadragdoll/tellymcp 0.0.10 → 0.0.12

package/dist/services/features/telegram-mcp/src/features/pair-session/model/generatePairCode.js

@@ -1,202 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PairSessionService = void 0;
-const ids_1 = require("../../../shared/lib/ids/ids");
-class PairSessionService {
-    config;
-    sessionStore;
-    bindingStore;
-    maintenanceStore;
-    logger;
-    projectIdentityResolver;
-    static MAX_PAIR_CODE_ATTEMPTS = 20;
-    constructor(config, sessionStore, bindingStore, maintenanceStore, logger, projectIdentityResolver) {
-        this.config = config;
-        this.sessionStore = sessionStore;
-        this.bindingStore = bindingStore;
-        this.maintenanceStore = maintenanceStore;
-        this.logger = logger;
-        this.projectIdentityResolver = projectIdentityResolver;
-    }
-    async unregisterGatewaySession(localSessionId) {
-        if (!this.config.distributed.gatewayPublicUrl) {
-            return;
-        }
-        const clientUuid = await this.maintenanceStore.getGatewayClientUuid();
-        if (!clientUuid) {
-            return;
-        }
-        const url = new URL(this.config.distributed.gatewayPublicUrl);
-        url.pathname = url.pathname.replace(/\/+$/u, "");
-        if (!url.pathname.endsWith("/gateway")) {
-            url.pathname = `${url.pathname}/gateway`.replace(/\/{2,}/gu, "/");
-        }
-        url.pathname = `${url.pathname}/sessions/unregister`.replace(/\/{2,}/gu, "/");
-        const response = await fetch(url, {
-            method: "POST",
-            headers: {
-                "content-type": "application/json",
-                ...(this.config.distributed.gatewayAuthToken
-                    ? { authorization: `Bearer ${this.config.distributed.gatewayAuthToken}` }
-                    : {}),
-            },
-            body: JSON.stringify({
-                client_uuid: clientUuid,
-                local_session_id: localSessionId,
-            }),
-        });
-        if (!response.ok) {
-            const text = await response.text();
-            throw new Error(`Gateway session unregister failed with status ${response.status}: ${text || response.statusText}`);
-        }
-    }
-    async createPairCode(input) {
-        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
-        const now = new Date();
-        const ttlSeconds = input.expires_in_seconds ?? this.config.pairCodeTtlSeconds;
-        const expiresAt = new Date(now.getTime() + ttlSeconds * 1000).toISOString();
-        let code = null;
-        const existingSession = await this.sessionStore.getSession(resolved.sessionId);
-        await this.sessionStore.setSession({
-            sessionId: resolved.sessionId,
-            ...(input.session_label
-                ? { label: input.session_label }
-                : resolved.sessionLabel
-                    ? { label: resolved.sessionLabel }
-                    : existingSession?.label
-                        ? { label: existingSession.label }
-                        : {}),
-            ...(input.cwd
-                ? { cwd: resolved.cwd }
-                : existingSession?.cwd
-                    ? { cwd: existingSession.cwd }
-                    : { cwd: resolved.cwd }),
-            ...(existingSession?.linkedSessionId
-                ? { linkedSessionId: existingSession.linkedSessionId }
-                : {}),
-            ...(existingSession?.activeProjectUuid
-                ? { activeProjectUuid: existingSession.activeProjectUuid }
-                : {}),
-            ...(existingSession?.activeProjectName
-                ? { activeProjectName: existingSession.activeProjectName }
-                : {}),
-            ...(existingSession?.task ? { task: existingSession.task } : {}),
-            ...(existingSession?.summary ? { summary: existingSession.summary } : {}),
-            ...(existingSession?.files ? { files: existingSession.files } : {}),
-            ...(existingSession?.decisions
-                ? { decisions: existingSession.decisions }
-                : {}),
-            ...(existingSession?.risks ? { risks: existingSession.risks } : {}),
-            ...(input.tmux_session_name
-                ? { tmuxSessionName: input.tmux_session_name }
-                : existingSession?.tmuxSessionName
-                    ? { tmuxSessionName: existingSession.tmuxSessionName }
-                    : {}),
-            ...(input.tmux_window_name
-                ? { tmuxWindowName: input.tmux_window_name }
-                : existingSession?.tmuxWindowName
-                    ? { tmuxWindowName: existingSession.tmuxWindowName }
-                    : {}),
-            ...(typeof input.tmux_window_index === "number"
-                ? { tmuxWindowIndex: input.tmux_window_index }
-                : typeof existingSession?.tmuxWindowIndex === "number"
-                    ? { tmuxWindowIndex: existingSession.tmuxWindowIndex }
-                    : {}),
-            ...(input.tmux_pane_id
-                ? { tmuxPaneId: input.tmux_pane_id, tmuxTarget: input.tmux_pane_id }
-                : existingSession?.tmuxPaneId
-                    ? {
-                        tmuxPaneId: existingSession.tmuxPaneId,
-                        ...(existingSession.tmuxTarget
-                            ? { tmuxTarget: existingSession.tmuxTarget }
-                            : {}),
-                    }
-                    : existingSession?.tmuxTarget
-                        ? { tmuxTarget: existingSession.tmuxTarget }
-                        : {}),
-            ...(typeof input.tmux_pane_index === "number"
-                ? { tmuxPaneIndex: input.tmux_pane_index }
-                : typeof existingSession?.tmuxPaneIndex === "number"
-                    ? { tmuxPaneIndex: existingSession.tmuxPaneIndex }
-                    : {}),
-            ...(existingSession?.lastTmuxNudgeAt
-                ? { lastTmuxNudgeAt: existingSession.lastTmuxNudgeAt }
-                : {}),
-            updatedAt: now.toISOString(),
-        });
-        this.projectIdentityResolver.persistSessionMarker({
-            cwd: resolved.cwd,
-            sessionId: resolved.sessionId,
-            sessionLabel: input.session_label?.trim() || resolved.sessionLabel,
-        });
-        for (let attempt = 0; attempt < PairSessionService.MAX_PAIR_CODE_ATTEMPTS; attempt += 1) {
-            const candidate = (0, ids_1.createPairCode)();
-            const record = {
-                code: candidate,
-                sessionId: resolved.sessionId,
-                ...(resolved.sessionLabel
-                    ? { sessionLabel: resolved.sessionLabel }
-                    : {}),
-                createdAt: now.toISOString(),
-                expiresAt,
-            };
-            const reserved = await this.bindingStore.createPairCode(record, ttlSeconds);
-            if (reserved) {
-                code = candidate;
-                break;
-            }
-        }
-        if (!code) {
-            throw new Error("Failed to reserve a unique 3-digit pairing code. Try again in a moment.");
-        }
-        this.logger.info("Session pair code created", {
-            sessionId: resolved.sessionId,
-            sessionLabel: resolved.sessionLabel,
-            sessionIdDerived: resolved.sessionIdDerived,
-            sessionLabelDerived: resolved.sessionLabelDerived,
-            cwd: input.cwd?.trim(),
-            tmuxSessionName: input.tmux_session_name,
-            tmuxWindowName: input.tmux_window_name,
-            tmuxWindowIndex: input.tmux_window_index,
-            tmuxPaneId: input.tmux_pane_id,
-            tmuxPaneIndex: input.tmux_pane_index,
-            expiresAt,
-            ttlSeconds,
-        });
-        return {
-            session_id: resolved.sessionId,
-            code,
-            expires_at: expiresAt,
-            status: "pending",
-            status_message: "Pairing code created. Send it to the Telegram bot and then use get_session_context to confirm that pairing is active.",
-            ...(this.config.telegram.botUsername
-                ? {
-                    telegram_link_hint: `https://t.me/${this.config.telegram.botUsername}?start=${encodeURIComponent(code)}`,
-                }
-                : {}),
-        };
-    }
-    async clearPairing(input) {
-        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
-        const existingSession = await this.sessionStore.getSession(resolved.sessionId);
-        if (existingSession) {
-            await this.unregisterGatewaySession(resolved.sessionId);
-            await this.sessionStore.setSession({
-                ...existingSession,
-                activeProjectUuid: undefined,
-                activeProjectName: undefined,
-                updatedAt: new Date().toISOString(),
-            });
-        }
-        await this.bindingStore.clearBinding(resolved.sessionId);
-        this.logger.info("Session pairing cleared", {
-            sessionId: resolved.sessionId,
-            sessionIdDerived: resolved.sessionIdDerived,
-        });
-        return {
-            cleared: true,
-            session_id: resolved.sessionId,
-        };
-    }
-}
-exports.PairSessionService = PairSessionService;

package/dist/services/features/telegram-mcp/src/features/session-context/model/getTmuxTargetTool.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetTmuxTargetTool = void 0;
-const schema_1 = require("../../../entities/request/model/schema");
-function createContent(output) {
-    return [
-        {
-            type: "text",
-            text: JSON.stringify(output, null, 2),
-        },
-    ];
-}
-class GetTmuxTargetTool {
-    sessionContextService;
-    constructor(sessionContextService) {
-        this.sessionContextService = sessionContextService;
-    }
-    register(server) {
-        server.registerTool("get_tmux_target", {
-            title: "Get tmux Target",
-            description: "Debug/setup tool. Return the stored tmux pane target for a session, including the last time the service nudged that tmux pane. Do not call this in the normal inbox-processing path after a tmux nudge.",
-            inputSchema: schema_1.getTmuxTargetInputSchema,
-            outputSchema: schema_1.getTmuxTargetOutputSchema,
-        }, async (args) => {
-            const output = await this.sessionContextService.getTmuxTarget(args);
-            return {
-                content: createContent(output),
-                structuredContent: output,
-            };
-        });
-    }
-}
-exports.GetTmuxTargetTool = GetTmuxTargetTool;

package/dist/services/features/telegram-mcp/src/features/session-context/model/setTmuxTargetTool.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetTmuxTargetTool = void 0;
-const schema_1 = require("../../../entities/request/model/schema");
-function createContent(output) {
-    return [
-        {
-            type: "text",
-            text: JSON.stringify(output, null, 2),
-        },
-    ];
-}
-class SetTmuxTargetTool {
-    sessionContextService;
-    constructor(sessionContextService) {
-        this.sessionContextService = sessionContextService;
-    }
-    register(server) {
-        server.registerTool("set_tmux_target", {
-            title: "Set tmux Target",
-            description: "Use this to repair or complete Telegram session setup after pairing, or when tmux pane/session changed. Store the tmux pane target for a session so the long-running MCP service can nudge the agent to check Telegram inbox when new ordinary Telegram messages arrive.",
-            inputSchema: schema_1.setTmuxTargetInputSchema,
-            outputSchema: schema_1.setTmuxTargetOutputSchema,
-        }, async (args) => {
-            const output = await this.sessionContextService.setTmuxTarget(args);
-            return {
-                content: createContent(output),
-                structuredContent: output,
-            };
-        });
-    }
-}
-exports.SetTmuxTargetTool = SetTmuxTargetTool;

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]));
-}