@deadragdoll/tellymcp 0.0.9 → 0.0.11

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

@@ -0,0 +1,330 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trimTrailingSlashes = trimTrailingSlashes;
+exports.normalizeBasePath = normalizeBasePath;
+exports.joinHttpPath = joinHttpPath;
+exports.resolveWebAppPublicBaseUrl = resolveWebAppPublicBaseUrl;
+exports.resolveGatewayControlBaseUrl = resolveGatewayControlBaseUrl;
+exports.isMenuEntryCommand = isMenuEntryCommand;
+exports.isHelpCommand = isHelpCommand;
+exports.parseAdminAuthCommand = parseAdminAuthCommand;
+exports.readMenuPayloadKey = readMenuPayloadKey;
+exports.buildDatedRelativePath = buildDatedRelativePath;
+exports.buildPrincipalKey = buildPrincipalKey;
+exports.formatTerminalBridgeError = formatTerminalBridgeError;
+exports.splitLongTelegramText = splitLongTelegramText;
+exports.escapeMarkdownV2 = escapeMarkdownV2;
+exports.escapeMarkdownV2CodeBlock = escapeMarkdownV2CodeBlock;
+exports.escapeHtml = escapeHtml;
+exports.splitTitleAndBody = splitTitleAndBody;
+exports.renderMarkdownChunk = renderMarkdownChunk;
+exports.shouldNudge = shouldNudge;
+exports.slugifyFilenamePart = slugifyFilenamePart;
+exports.formatMenuTimestamp = formatMenuTimestamp;
+exports.normalizeGatewayBaseUrl = normalizeGatewayBaseUrl;
+exports.buildLocalHandoffId = buildLocalHandoffId;
+exports.buildLocalNoteContent = buildLocalNoteContent;
+exports.buildAdminClientTitle = buildAdminClientTitle;
+exports.buildAdminClientButtonLabel = buildAdminClientButtonLabel;
+exports.extractCallbackSuffix = extractCallbackSuffix;
+const node_path_1 = __importDefault(require("node:path"));
+const client_1 = require("../terminal/client");
+function trimTrailingSlashes(value) {
+    return value.replace(/\/+$/u, "");
+}
+function normalizeBasePath(value) {
+    const trimmed = trimTrailingSlashes(value.trim());
+    return trimmed.startsWith("/") ? trimmed || "/" : `/${trimmed || ""}`;
+}
+function joinHttpPath(prefix, suffix) {
+    const normalizedPrefix = prefix ? normalizeBasePath(prefix) : "";
+    const normalizedSuffix = normalizeBasePath(suffix);
+    if (!normalizedPrefix || normalizedPrefix === "/") {
+        return normalizedSuffix;
+    }
+    return `${normalizedPrefix}${normalizedSuffix}`.replace(/\/{2,}/gu, "/");
+}
+function resolveWebAppPublicBaseUrl(config) {
+    if (!config.webapp.publicUrl) {
+        return null;
+    }
+    const rootPrefix = normalizeBasePath(process.env.ROOT_PREFIX || "/api");
+    const webAppBasePath = normalizeBasePath(config.webapp.basePath || "/webapp");
+    const expectedPath = trimTrailingSlashes(`${rootPrefix === "/" ? "" : rootPrefix}${webAppBasePath}`) || "/";
+    const url = new URL(config.webapp.publicUrl);
+    const currentPath = normalizeBasePath(url.pathname || "/");
+    if (currentPath === expectedPath) {
+        return trimTrailingSlashes(url.toString());
+    }
+    if (currentPath === webAppBasePath) {
+        url.pathname = expectedPath;
+        return trimTrailingSlashes(url.toString());
+    }
+    if (currentPath.endsWith(webAppBasePath)) {
+        url.pathname = expectedPath;
+        return trimTrailingSlashes(url.toString());
+    }
+    url.pathname = expectedPath;
+    return trimTrailingSlashes(url.toString());
+}
+function resolveGatewayControlBaseUrl(config) {
+    if (config.distributed.mode === "gateway" ||
+        config.distributed.mode === "both") {
+        const runtimePort = Number(process.env.PORT || config.mcp.httpPort);
+        const rootPrefix = normalizeBasePath(process.env.ROOT_PREFIX || "/api");
+        const gatewayPath = joinHttpPath(rootPrefix, "/gateway");
+        return trimTrailingSlashes(`http://127.0.0.1:${runtimePort}${gatewayPath}`);
+    }
+    if (!config.distributed.gatewayPublicUrl) {
+        return null;
+    }
+    const url = new URL(config.distributed.gatewayPublicUrl);
+    url.pathname = url.pathname.replace(/\/+$/u, "");
+    if (!url.pathname.endsWith("/gateway")) {
+        url.pathname = `${url.pathname}/gateway`.replace(/\/{2,}/gu, "/");
+    }
+    return trimTrailingSlashes(url.toString());
+}
+function isMenuEntryCommand(text) {
+    return /^\/(?:menu|start)(?:@\w+)?$/i.test(text.trim());
+}
+function isHelpCommand(text) {
+    return /^\/help(?:@\w+)?$/i.test(text.trim());
+}
+function parseAdminAuthCommand(text) {
+    const match = text.trim().match(/^\/auth(?:@\w+)?(?:\s+(.+))?$/i);
+    return match?.[1]?.trim() || null;
+}
+function readMenuPayloadKey(ctx) {
+    const payload = ctx.match;
+    return typeof payload === "string" && payload.length > 0 ? payload : null;
+}
+function buildDatedRelativePath(fileName, date = new Date()) {
+    const dateSegment = date.toISOString().slice(0, 10);
+    const timeSegment = date.toTimeString().slice(0, 8).replace(/:/gu, "-");
+    return `${dateSegment}/${timeSegment}/${fileName}`;
+}
+function buildPrincipalKey(principal) {
+    return `${principal.telegramChatId}:${principal.telegramUserId}`;
+}
+function formatTerminalBridgeError(_config, error, fallback) {
+    if ((0, client_1.isTerminalUnavailableError)(error)) {
+        return "Terminal runtime is unavailable right now.";
+    }
+    return fallback;
+}
+function splitLongTelegramText(text, maxChars) {
+    const normalized = text.trim();
+    if (normalized.length <= maxChars) {
+        return [normalized];
+    }
+    const paragraphs = normalized.split("\n\n");
+    const chunks = [];
+    let current = "";
+    const flush = () => {
+        const trimmed = current.trim();
+        if (trimmed) {
+            chunks.push(trimmed);
+        }
+        current = "";
+    };
+    const appendSegment = (segment) => {
+        if (!segment) {
+            return;
+        }
+        if (segment.length <= maxChars) {
+            const candidate = current ? `${current}\n\n${segment}` : segment;
+            if (candidate.length <= maxChars) {
+                current = candidate;
+                return;
+            }
+            flush();
+            current = segment;
+            return;
+        }
+        flush();
+        const lines = segment.split("\n");
+        let lineChunk = "";
+        for (const line of lines) {
+            if (line.length > maxChars) {
+                if (lineChunk) {
+                    chunks.push(lineChunk.trim());
+                    lineChunk = "";
+                }
+                for (let index = 0; index < line.length; index += maxChars) {
+                    chunks.push(line.slice(index, index + maxChars).trim());
+                }
+                continue;
+            }
+            const candidate = lineChunk ? `${lineChunk}\n${line}` : line;
+            if (candidate.length <= maxChars) {
+                lineChunk = candidate;
+            }
+            else {
+                chunks.push(lineChunk.trim());
+                lineChunk = line;
+            }
+        }
+        if (lineChunk) {
+            current = lineChunk;
+        }
+    };
+    for (const paragraph of paragraphs) {
+        appendSegment(paragraph);
+    }
+    flush();
+    return chunks.filter((chunk) => chunk.length > 0);
+}
+function escapeMarkdownV2(text) {
+    const specialChars = new Set([
+        "_",
+        "*",
+        "[",
+        "]",
+        "(",
+        ")",
+        "~",
+        "`",
+        ">",
+        "#",
+        "+",
+        "-",
+        "=",
+        "|",
+        "{",
+        "}",
+        ".",
+        "!",
+        "\\",
+    ]);
+    return Array.from(text, (char) => specialChars.has(char) ? `\\${char}` : char).join("");
+}
+function escapeMarkdownV2CodeBlock(text) {
+    return text.replace(/\\/g, "\\\\").replace(/`/g, "\\`");
+}
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+function splitTitleAndBody(text) {
+    const normalized = text.trim();
+    const [firstLine = "", ...rest] = normalized.split("\n");
+    const title = firstLine.trim() || "Codex";
+    const body = rest.join("\n").trim();
+    return {
+        title,
+        body: body || firstLine.trim(),
+    };
+}
+function renderMarkdownChunk(title, body) {
+    return `*${escapeMarkdownV2(title)}*\n\n\`\`\`\n${escapeMarkdownV2CodeBlock(body)}\n\`\`\``;
+}
+function shouldNudge(lastNudgeAt, cooldownSeconds, nowMs) {
+    if (!lastNudgeAt) {
+        return true;
+    }
+    const lastMs = Date.parse(lastNudgeAt);
+    if (Number.isNaN(lastMs)) {
+        return true;
+    }
+    return nowMs - lastMs >= cooldownSeconds * 1000;
+}
+function slugifyFilenamePart(input) {
+    return input
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 48);
+}
+function formatMenuTimestamp(timestamp) {
+    if (!timestamp) {
+        return null;
+    }
+    const date = new Date(timestamp);
+    if (Number.isNaN(date.getTime())) {
+        return null;
+    }
+    const day = String(date.getDate()).padStart(2, "0");
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const year = date.getFullYear();
+    const hours = String(date.getHours()).padStart(2, "0");
+    const minutes = String(date.getMinutes()).padStart(2, "0");
+    return `${day}.${month}.${year} ${hours}:${minutes}`;
+}
+function normalizeGatewayBaseUrl(value) {
+    const url = new URL(value);
+    url.pathname = url.pathname.replace(/\/+$/u, "");
+    if (!url.pathname.endsWith("/gateway")) {
+        url.pathname = `${url.pathname}/gateway`.replace(/\/{2,}/gu, "/");
+    }
+    return url;
+}
+function buildLocalHandoffId(fileName, now) {
+    const timestamp = now.toISOString().replace(/[:.]/gu, "-");
+    return `${timestamp}-${slugifyFilenamePart(fileName) || "file-handoff"}`;
+}
+function buildLocalNoteContent(input) {
+    return [
+        "---",
+        `handoff_id: ${JSON.stringify(input.handoffId)}`,
+        `kind: "local-file"`,
+        `created_at: ${JSON.stringify(input.createdAt)}`,
+        `session_id: ${JSON.stringify(input.sessionId)}`,
+        `session_label: ${JSON.stringify(input.sessionLabel ?? input.sessionId)}`,
+        `artifacts:\n  - ${JSON.stringify(input.filePath)}`,
+        "---",
+        "",
+        "# Summary",
+        `Local file handoff: ${node_path_1.default.basename(input.filePath)}`,
+        "",
+        "# Message",
+        input.description.trim(),
+        "",
+        "# Artifacts",
+        `- ${input.filePath}`,
+        "",
+    ].join("\n");
+}
+function buildAdminClientTitle(client) {
+    const displayName = client.telegram_display_name?.trim() || "";
+    const telegramUsername = client.telegram_username?.trim().replace(/^@/u, "") || "";
+    const botUsername = client.bot_username?.trim().replace(/^@/u, "") || "";
+    const clientLabel = client.client_label?.trim() || "";
+    const namespace = client.namespace?.trim() || "";
+    const nodeId = client.node_id?.trim() || "";
+    const runtimeLabel = [namespace, nodeId].filter(Boolean).join("/") || nodeId || "";
+    const fallback = (clientLabel || runtimeLabel || client.client_uuid).trim();
+    const identityParts = [
+        displayName || null,
+        !displayName && telegramUsername ? `@${telegramUsername}` : null,
+        !displayName && !telegramUsername && clientLabel ? clientLabel : null,
+        !displayName && !telegramUsername && !clientLabel && runtimeLabel
+            ? runtimeLabel
+            : null,
+        botUsername ? `🤖@${botUsername}` : null,
+    ].filter(Boolean);
+    return identityParts.length > 0 ? identityParts.join(" · ") : fallback;
+}
+function buildAdminClientButtonLabel(client) {
+    const markers = [
+        client.is_connected ? "🟢" : null,
+        client.is_registered ? "🗂" : null,
+    ]
+        .filter(Boolean)
+        .join("");
+    const prefix = markers ? `${markers} ` : "";
+    return `${prefix}${buildAdminClientTitle(client)}`.slice(0, 56);
+}
+function extractCallbackSuffix(ctx, prefix) {
+    const data = ctx.callbackQuery?.data;
+    if (!data || !data.startsWith(prefix)) {
+        return null;
+    }
+    return data.slice(prefix.length) || null;
+}

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

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportXchangeState = void 0;
+const relay_1 = require("../../../app/webapp/relay");
+const client_1 = require("../terminal/client");
+class TransportXchangeState {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async resolveSessionStorageAccess(sessionId) {
+        const trimmed = sessionId.trim();
+        if (!trimmed) {
+            return { sessionId: trimmed, mode: "meta" };
+        }
+        const relay = (0, relay_1.parseLiveRelaySessionId)(trimmed);
+        if (relay?.localSessionId) {
+            const localSession = await this.host.sessionStore.getSession(relay.localSessionId);
+            if (localSession?.cwd?.trim()) {
+                return { sessionId: relay.localSessionId, mode: "filesystem" };
+            }
+            return { sessionId: trimmed, mode: "relay" };
+        }
+        const direct = await this.host.sessionStore.getSession(trimmed);
+        if (direct?.cwd?.trim()) {
+            return { sessionId: trimmed, mode: "filesystem" };
+        }
+        return { sessionId: trimmed, mode: "meta" };
+    }
+    async listActiveSessionFiles(sessionId) {
+        const access = await this.resolveSessionStorageAccess(sessionId);
+        const metas = access.mode === "filesystem"
+            ? await this.listReconciledSessionXchangeMetas(access.sessionId, await this.listSessionFilesystemXchangeFiles(access.sessionId))
+            : access.mode === "relay"
+                ? await this.listRelaySessionXchangeFileMetas(access.sessionId, "telegram-upload")
+                : await this.host.xchangeFileMetaStore.listXchangeFileMetas(access.sessionId);
+        const uploadFiles = metas
+            .filter((meta) => meta.source === "telegram-upload")
+            .map((meta) => meta.filePath);
+        return uploadFiles.sort((left, right) => right.localeCompare(left));
+    }
+    async listActiveSessionStorageEntries(sessionId) {
+        const access = await this.resolveSessionStorageAccess(sessionId);
+        if (access.mode === "relay") {
+            const metas = await this.listRelaySessionXchangeFileMetas(access.sessionId);
+            return metas.map((meta) => ({
+                filePath: meta.filePath,
+                meta,
+            }));
+        }
+        if (access.mode === "meta") {
+            const metas = await this.host.xchangeFileMetaStore.listXchangeFileMetas(access.sessionId);
+            return metas.map((meta) => ({
+                filePath: meta.filePath,
+                meta,
+            }));
+        }
+        const filePaths = await this.listSessionFilesystemXchangeFiles(access.sessionId);
+        const metas = await this.listReconciledSessionXchangeMetas(access.sessionId, filePaths);
+        const metaByPath = new Map(metas.map((meta) => [meta.filePath, meta]));
+        return filePaths.map((filePath) => ({
+            filePath,
+            meta: metaByPath.get(filePath) ?? null,
+        }));
+    }
+    async listActiveSessionScreenshots(sessionId) {
+        const access = await this.resolveSessionStorageAccess(sessionId);
+        const metas = access.mode === "filesystem"
+            ? await this.listReconciledSessionXchangeMetas(access.sessionId, await this.listSessionFilesystemXchangeFiles(access.sessionId))
+            : access.mode === "relay"
+                ? await this.listRelaySessionXchangeFileMetas(access.sessionId, "browser-screenshot")
+                : await this.host.xchangeFileMetaStore.listXchangeFileMetas(access.sessionId);
+        const screenshots = metas
+            .filter((meta) => meta.source === "browser-screenshot")
+            .map((meta) => meta.filePath);
+        return screenshots.sort((left, right) => right.localeCompare(left));
+    }
+    async listSessionFilesystemXchangeFiles(sessionId) {
+        const session = await this.host.sessionStore.getSession(sessionId);
+        const resolvedWorkspaceDir = session?.cwd?.trim() || "";
+        if (!resolvedWorkspaceDir) {
+            throw new Error(`Workspace cwd is not registered for console '${sessionId}'.`);
+        }
+        const files = await (0, client_1.listXchangeFiles)(this.host.config.terminal, resolvedWorkspaceDir, this.host.config.exchange.dir);
+        return files.sort((left, right) => right.localeCompare(left));
+    }
+    async listReconciledSessionXchangeMetas(sessionId, existingFiles) {
+        const metas = await this.host.xchangeFileMetaStore.listXchangeFileMetas(sessionId);
+        if (metas.length === 0) {
+            return [];
+        }
+        const existingSet = new Set(existingFiles);
+        const staleMetas = metas.filter((meta) => !existingSet.has(meta.filePath));
+        for (const meta of staleMetas) {
+            await this.host.xchangeFileMetaStore.deleteXchangeFileMeta(sessionId, meta.filePath);
+        }
+        return metas.filter((meta) => existingSet.has(meta.filePath));
+    }
+    async listRelaySessionXchangeFileMetas(sessionId, source) {
+        const output = await this.host.callGatewayJson("/storage/list", {
+            session_id: sessionId,
+            ...(source ? { source } : {}),
+        });
+        return Array.isArray(output.metas) ? output.metas : [];
+    }
+}
+exports.TransportXchangeState = TransportXchangeState;

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)();
+}