@deadragdoll/tellymcp 0.0.12 → 0.0.14

package/dist/services/features/telegram-mcp/src/features/file-content/model/getFileService.js

@@ -0,0 +1,327 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetFileService = void 0;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const node_stream_1 = require("node:stream");
+const client_1 = require("../../../shared/integrations/terminal/client");
+const bodyLimits_1 = require("../../../shared/lib/bodyLimits");
+const temporaryFileLinkStore_1 = require("./temporaryFileLinkStore");
+const workspaceFilePolicy_1 = require("./workspaceFilePolicy");
+const MAX_NATIVE_IMAGE_SOURCE_SIZE_BYTES = 11 * 1024 * 1024;
+const MAX_TEXT_SOURCE_SIZE_BYTES = 7 * 1024 * 1024;
+function normalizeWorkspaceRelativePath(workspaceDir, filePath) {
+    const trimmed = filePath.trim();
+    const resolvedWorkspaceDir = node_path_1.default.resolve(workspaceDir);
+    const resolvedFilePath = node_path_1.default.isAbsolute(trimmed)
+        ? node_path_1.default.resolve(trimmed)
+        : node_path_1.default.resolve(resolvedWorkspaceDir, trimmed);
+    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 relative.split(node_path_1.default.sep).join("/");
+}
+class GetFileService {
+    config;
+    sessionStore;
+    maintenanceStore;
+    xchangeFileMetaStore;
+    logger;
+    projectIdentityResolver;
+    remoteConsoleInvoker;
+    temporaryFileLinkStore;
+    constructor(config, sessionStore, maintenanceStore, xchangeFileMetaStore, logger, projectIdentityResolver, remoteConsoleInvoker, temporaryFileLinkStore) {
+        this.config = config;
+        this.sessionStore = sessionStore;
+        this.maintenanceStore = maintenanceStore;
+        this.xchangeFileMetaStore = xchangeFileMetaStore;
+        this.logger = logger;
+        this.projectIdentityResolver = projectIdentityResolver;
+        this.remoteConsoleInvoker = remoteConsoleInvoker;
+        this.temporaryFileLinkStore = temporaryFileLinkStore;
+    }
+    async get(input) {
+        if (input.file_path?.trim()) {
+            (0, workspaceFilePolicy_1.assertWorkspaceFilePathAllowed)(input.file_path.trim());
+        }
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const sessionId = await this.normalizeSessionIdForWorkspace(resolved.sessionId);
+        const responseType = input.type ?? "url";
+        const cacheKey = this.createCacheKey(sessionId, input);
+        if (this.config.distributed.mode !== "client") {
+            if (responseType === "url" || responseType === "image") {
+                if (!this.temporaryFileLinkStore) {
+                    throw new Error("URL file delivery requires gateway mode with GATEWAY_PUBLIC_URL.");
+                }
+                const ticket = this.temporaryFileLinkStore.createTicket(cacheKey);
+                try {
+                    if (!this.remoteConsoleInvoker) {
+                        throw new Error("Gateway remote console routing is unavailable.");
+                    }
+                    await this.remoteConsoleInvoker.invokeForRelaySession(sessionId, "telegramMcp.fileContent.uploadFileRemote", {
+                        ...input,
+                        type: "url",
+                        session_id: sessionId,
+                        upload_url: ticket.upload_url,
+                    });
+                    const link = this.temporaryFileLinkStore.getReadyLink(ticket.download_token);
+                    const output = {
+                        type: "url",
+                        data: link.url,
+                        filename: link.filename,
+                        mimetype: link.mimetype,
+                        size_bytes: link.size_bytes,
+                        expires_at: link.expires_at,
+                    };
+                    if (responseType === "image") {
+                        if (!link.mimetype.toLowerCase().startsWith("image/")) {
+                            throw new Error(`type='image' requires an image MIME type, received '${link.mimetype}'.`);
+                        }
+                        const nativeImage = await this.temporaryFileLinkStore.readCachedBase64(cacheKey, MAX_NATIVE_IMAGE_SOURCE_SIZE_BYTES);
+                        if (!nativeImage) {
+                            throw new Error("Image is too large for native MCP image content; retry with type='url'.");
+                        }
+                        if (!nativeImage.data || nativeImage.data === "[image]") {
+                            throw new Error("Native MCP image base64 payload is empty.");
+                        }
+                        const decodedImageBytes = Buffer.from(nativeImage.data, "base64").byteLength;
+                        if (decodedImageBytes !== link.size_bytes) {
+                            throw new Error(`Native MCP image payload size mismatch: expected ${link.size_bytes} bytes, decoded ${decodedImageBytes} bytes.`);
+                        }
+                        const imageOutput = {
+                            ...output,
+                            type: "image",
+                            native_image_data: nativeImage.data,
+                        };
+                        (0, bodyLimits_1.assertSerializedBodySize)(imageOutput);
+                        this.logger.info("Native MCP image content prepared", {
+                            sessionId,
+                            filename: link.filename,
+                            mimetype: link.mimetype,
+                            sizeBytes: link.size_bytes,
+                            base64Chars: nativeImage.data.length,
+                            decodedBytes: decodedImageBytes,
+                        });
+                        return imageOutput;
+                    }
+                    (0, bodyLimits_1.assertSerializedBodySize)(output);
+                    return output;
+                }
+                catch (error) {
+                    await this.temporaryFileLinkStore.discard(ticket.download_token);
+                    throw error;
+                }
+            }
+            if (responseType === "base64") {
+                const cached = await this.temporaryFileLinkStore?.readCachedBase64(cacheKey, bodyLimits_1.MAX_BASE64_SOURCE_SIZE_BYTES);
+                if (cached) {
+                    const output = {
+                        type: "base64",
+                        data: cached.data,
+                        filename: cached.filename,
+                        mimetype: cached.mimetype,
+                        size_bytes: cached.size_bytes,
+                    };
+                    (0, bodyLimits_1.assertSerializedBodySize)(output);
+                    return output;
+                }
+            }
+            const remote = await this.remoteConsoleInvoker?.invokeForRelaySession(sessionId, "telegramMcp.fileContent.getFileRemote", {
+                ...input,
+                type: responseType,
+                session_id: sessionId,
+            });
+            if (remote) {
+                (0, bodyLimits_1.assertSerializedBodySize)(remote);
+                return remote;
+            }
+        }
+        if (responseType === "url" || responseType === "image") {
+            throw new Error("URL and native image delivery must be initiated through the gateway MCP.");
+        }
+        const session = await this.sessionStore.getSession(sessionId);
+        const workspaceDir = node_path_1.default.resolve(session?.cwd?.trim() || resolved.cwd);
+        const requestedFilePath = await this.resolveRequestedFilePath(sessionId, input);
+        const relativeFilePath = normalizeWorkspaceRelativePath(workspaceDir, requestedFilePath);
+        (0, workspaceFilePolicy_1.assertWorkspaceFilePathAllowed)(relativeFilePath);
+        const resolvedFile = await (0, client_1.resolveWorkspaceFileForRead)(this.config.terminal, workspaceDir, relativeFilePath, responseType === "text"
+            ? MAX_TEXT_SOURCE_SIZE_BYTES
+            : bodyLimits_1.MAX_BASE64_SOURCE_SIZE_BYTES);
+        const resolvedRelativeFilePath = normalizeWorkspaceRelativePath(workspaceDir, resolvedFile.filePath);
+        (0, workspaceFilePolicy_1.assertWorkspaceFilePathAllowed)(resolvedRelativeFilePath);
+        const fileContent = await (0, promises_1.readFile)(resolvedFile.filePath);
+        const filename = node_path_1.default.basename(relativeFilePath);
+        const mimetype = (0, workspaceFilePolicy_1.resolveWorkspaceFileMimeType)(filename);
+        const output = {
+            type: responseType,
+            data: responseType === "text"
+                ? (0, workspaceFilePolicy_1.decodeWorkspaceTextContent)(fileContent)
+                : Buffer.from(fileContent).toString("base64"),
+            mimetype,
+            filename,
+            size_bytes: fileContent.byteLength,
+        };
+        (0, bodyLimits_1.assertSerializedBodySize)(output);
+        this.logger.info("Workspace file content retrieved", {
+            sessionId,
+            filename,
+            sizeBytes: fileContent.byteLength,
+            mimetype: output.mimetype,
+        });
+        return output;
+    }
+    async upload(input) {
+        if (this.config.distributed.mode !== "client") {
+            throw new Error("Temporary file uploads can only run on a client console.");
+        }
+        this.assertAllowedUploadUrl(input.upload_url);
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const sessionId = await this.normalizeSessionIdForWorkspace(resolved.sessionId);
+        const session = await this.sessionStore.getSession(sessionId);
+        const workspaceDir = node_path_1.default.resolve(session?.cwd?.trim() || resolved.cwd);
+        const requestedFilePath = await this.resolveRequestedFilePath(sessionId, input);
+        const relativeFilePath = normalizeWorkspaceRelativePath(workspaceDir, requestedFilePath);
+        (0, workspaceFilePolicy_1.assertWorkspaceFilePathAllowed)(relativeFilePath);
+        const resolvedFile = await (0, client_1.resolveWorkspaceFileForRead)(this.config.terminal, workspaceDir, relativeFilePath, temporaryFileLinkStore_1.TEMPORARY_FILE_LINK_MAX_BYTES);
+        const resolvedRelativeFilePath = normalizeWorkspaceRelativePath(workspaceDir, resolvedFile.filePath);
+        (0, workspaceFilePolicy_1.assertWorkspaceFilePathAllowed)(resolvedRelativeFilePath);
+        const filename = node_path_1.default.basename(relativeFilePath);
+        const mimetype = (0, workspaceFilePolicy_1.resolveWorkspaceFileMimeType)(filename);
+        const body = node_stream_1.Readable.toWeb((0, node_fs_1.createReadStream)(resolvedFile.filePath));
+        const response = await fetch(input.upload_url, {
+            method: "PUT",
+            headers: {
+                "content-type": mimetype,
+                "content-length": String(resolvedFile.sizeBytes),
+                "x-telly-filename": encodeURIComponent(filename),
+            },
+            body,
+            duplex: "half",
+        });
+        if (!response.ok) {
+            const message = await response.text();
+            throw new Error(`Gateway temporary file upload failed with status ${response.status}: ${message || response.statusText}`);
+        }
+        return {
+            uploaded: true,
+            filename,
+            mimetype,
+            size_bytes: resolvedFile.sizeBytes,
+        };
+    }
+    async list(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const sessionId = await this.normalizeSessionIdForWorkspace(resolved.sessionId);
+        if (this.config.distributed.mode !== "client") {
+            const remote = await this.remoteConsoleInvoker?.invokeForRelaySession(sessionId, "telegramMcp.fileContent.listFilesRemote", {
+                ...input,
+                session_id: sessionId,
+            });
+            if (remote) {
+                (0, bodyLimits_1.assertSerializedBodySize)(remote);
+                return remote;
+            }
+        }
+        const metas = await this.xchangeFileMetaStore.listXchangeFileMetas(sessionId);
+        const filtered = metas
+            .filter((item) => !input.source || item.source === input.source)
+            .sort((left, right) => right.uploadedAt.localeCompare(left.uploadedAt));
+        const limit = input.limit ?? 50;
+        const output = {
+            total: filtered.length,
+            files: filtered.slice(0, limit).map((item) => {
+                const filename = item.originalName ||
+                    node_path_1.default.basename(item.relativePath?.trim() || item.filePath);
+                return {
+                    file_path: item.filePath,
+                    filename,
+                    mimetype: item.mimeType || (0, workspaceFilePolicy_1.resolveWorkspaceFileMimeType)(filename),
+                    source: item.source,
+                    ...(typeof item.sizeBytes === "number"
+                        ? { size_bytes: item.sizeBytes }
+                        : {}),
+                    created_at: item.uploadedAt,
+                };
+            }),
+        };
+        (0, bodyLimits_1.assertSerializedBodySize)(output);
+        this.logger.info("Workspace file list retrieved", {
+            sessionId,
+            source: input.source ?? "all",
+            total: output.total,
+            returned: output.files.length,
+        });
+        return output;
+    }
+    async resolveRequestedFilePath(sessionId, input) {
+        if (input.file_path?.trim()) {
+            if (input.selector) {
+                throw new Error("Provide exactly one of file_path or selector.");
+            }
+            return input.file_path.trim();
+        }
+        if (input.selector !== "latest_screenshot") {
+            throw new Error("Provide exactly one of file_path or selector.");
+        }
+        const screenshots = (await this.xchangeFileMetaStore.listXchangeFileMetas(sessionId))
+            .filter((item) => item.source === "browser-screenshot")
+            .sort((left, right) => right.uploadedAt.localeCompare(left.uploadedAt));
+        const latest = screenshots[0];
+        if (!latest) {
+            throw new Error("No browser screenshots were found for this session.");
+        }
+        return latest.filePath;
+    }
+    async normalizeSessionIdForWorkspace(sessionId) {
+        const trimmed = sessionId.trim();
+        if (!trimmed) {
+            return trimmed;
+        }
+        const direct = await this.sessionStore.getSession(trimmed);
+        if (direct) {
+            return trimmed;
+        }
+        const separatorIndex = trimmed.indexOf(":");
+        if (separatorIndex <= 0) {
+            return trimmed;
+        }
+        const localClientUuid = await this.maintenanceStore.getGatewayClientUuid();
+        const clientUuid = trimmed.slice(0, separatorIndex).trim();
+        const localSessionId = trimmed.slice(separatorIndex + 1).trim();
+        if (!localClientUuid || clientUuid !== localClientUuid || !localSessionId) {
+            return trimmed;
+        }
+        const localSession = await this.sessionStore.getSession(localSessionId);
+        return localSession ? localSessionId : trimmed;
+    }
+    createCacheKey(sessionId, input) {
+        return JSON.stringify({
+            session_id: sessionId,
+            ...(input.file_path?.trim() ? { file_path: input.file_path.trim() } : {}),
+            ...(input.selector ? { selector: input.selector } : {}),
+        });
+    }
+    assertAllowedUploadUrl(uploadUrl) {
+        const expectedBaseUrl = (0, temporaryFileLinkStore_1.resolvePublicFilesBaseUrl)(this.config.distributed.gatewayPublicUrl);
+        const candidateUrl = new URL(uploadUrl);
+        const uploadPathPrefix = `${expectedBaseUrl.pathname.replace(/\/+$/u, "")}/upload/`;
+        const uploadToken = candidateUrl.pathname.slice(uploadPathPrefix.length);
+        if (candidateUrl.origin !== expectedBaseUrl.origin ||
+            candidateUrl.username ||
+            candidateUrl.password ||
+            candidateUrl.search ||
+            candidateUrl.hash ||
+            !candidateUrl.pathname.startsWith(uploadPathPrefix) ||
+            !/^[A-Za-z0-9_-]+$/u.test(uploadToken)) {
+            throw new Error("Temporary file upload URL does not belong to the configured gateway.");
+        }
+    }
+}
+exports.GetFileService = GetFileService;

package/dist/services/features/telegram-mcp/src/features/file-content/model/getFileTool.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetFileTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+const bodyLimits_1 = require("../../../shared/lib/bodyLimits");
+function createStructuredOutput(output) {
+    return {
+        type: output.type,
+        data: output.data,
+        mimetype: output.mimetype,
+        filename: output.filename,
+        size_bytes: output.size_bytes,
+        ...(output.expires_at ? { expires_at: output.expires_at } : {}),
+    };
+}
+function assertNativeImagePayload(data, sizeBytes) {
+    if (!data ||
+        data === "[image]" ||
+        Buffer.from(data, "base64").byteLength !== sizeBytes) {
+        throw new Error("Native MCP image payload failed final tool-result validation.");
+    }
+}
+class GetFileTool {
+    getFileService;
+    constructor(getFileService) {
+        this.getFileService = getFileService;
+    }
+    register(server) {
+        server.registerTool("get_file", {
+            title: "Get File",
+            description: "Retrieve a file from the workspace of a selected live console. type='url' is the default and returns only a short-lived HTTPS download link. type='image' returns a native MCP image plus its URL. type='text' returns UTF-8 project files such as Markdown or source code directly as MCP text. type='base64' is the host-independent fallback and returns the complete JSON payload, including data, in an MCP text block. Provide an exact workspace-relative or absolute file_path, or selector='latest_screenshot'. Sensitive paths such as environment files, credential stores, and private keys are blocked. In gateway mode, pass session_id exactly as returned by list_gateway_sessions.",
+            inputSchema: schema_1.getFileInputSchema,
+            outputSchema: schema_1.getFileOutputSchema,
+        }, async (args) => {
+            const output = await this.getFileService.get(args);
+            if (output.native_image_data !== undefined) {
+                assertNativeImagePayload(output.native_image_data, output.size_bytes);
+                const structuredOutput = createStructuredOutput(output);
+                return {
+                    content: [
+                        {
+                            type: "image",
+                            data: output.native_image_data,
+                            mimeType: output.mimetype,
+                        },
+                        {
+                            type: "text",
+                            text: `${output.filename}\nDownload URL: ${output.data}`,
+                        },
+                    ],
+                    structuredContent: structuredOutput,
+                };
+            }
+            if (output.type === "text") {
+                const result = {
+                    content: [
+                        {
+                            type: "text",
+                            text: output.data,
+                        },
+                    ],
+                    structuredContent: output,
+                };
+                (0, bodyLimits_1.assertSerializedBodySize)(result);
+                return result;
+            }
+            const result = {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(output, null, 2),
+                    },
+                ],
+                structuredContent: output,
+            };
+            (0, bodyLimits_1.assertSerializedBodySize)(result);
+            return result;
+        });
+    }
+}
+exports.GetFileTool = GetFileTool;