@deadragdoll/tellymcp 0.0.9 → 0.0.11

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

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatStorageDetail = formatStorageDetail;
+exports.formatFileDetail = formatFileDetail;
+exports.formatScreenshotDetail = formatScreenshotDetail;
+exports.extractIncomingText = extractIncomingText;
+exports.collectIncomingAttachments = collectIncomingAttachments;
+const node_path_1 = __importDefault(require("node:path"));
+const transportFormatting_1 = require("./transportFormatting");
+function formatStorageDetail(sessionId, filePath, meta) {
+    return [
+        "📦 Storage entry",
+        "",
+        `Session: ${sessionId}`,
+        `File: ${(0, transportFormatting_1.formatFilePreviewLabel)(filePath, meta)}`,
+        ...(meta?.source ? [`Source: ${meta.source}`] : []),
+        ...(meta?.uploadedAt ? [`Saved: ${meta.uploadedAt}`] : []),
+        ...(meta?.relativePath ? [`Relative: ${meta.relativePath}`] : []),
+        ...(meta?.mimeType ? [`MIME: ${meta.mimeType}`] : []),
+        ...(typeof meta?.sizeBytes === "number"
+            ? [`Size: ${meta.sizeBytes} bytes`]
+            : []),
+        `Path: ${filePath}`,
+        ...(meta?.caption ? ["", "Caption:", meta.caption] : []),
+    ].join("\n");
+}
+function formatFileDetail(sessionId, filePath, meta) {
+    const displayName = meta?.originalName ||
+        (meta?.relativePath ? node_path_1.default.basename(meta.relativePath) : undefined) ||
+        node_path_1.default.basename(filePath);
+    return [
+        "Session file",
+        "",
+        `Session: ${sessionId}`,
+        `File: ${displayName}`,
+        ...(meta?.uploadedAt ? [`Uploaded: ${meta.uploadedAt}`] : []),
+        `Path: ${filePath}`,
+        ...(meta?.caption ? ["", "Description:", meta.caption] : []),
+    ].join("\n");
+}
+function formatScreenshotDetail(sessionId, filePath, meta) {
+    return [
+        "Browser screenshot",
+        "",
+        `Session: ${sessionId}`,
+        `File: ${node_path_1.default.basename(filePath)}`,
+        ...(meta?.uploadedAt ? [`Created: ${meta.uploadedAt}`] : []),
+        `Path: ${filePath}`,
+        ...(meta?.caption ? ["", "Caption:", meta.caption] : []),
+    ].join("\n");
+}
+function extractIncomingText(message) {
+    const text = message?.text?.trim() || message?.caption?.trim();
+    return text && text.length > 0 ? text : null;
+}
+function collectIncomingAttachments(message) {
+    if (!message) {
+        return [];
+    }
+    const attachments = [];
+    if (Array.isArray(message.photo) && message.photo.length > 0) {
+        const largestPhoto = [...message.photo].sort((left, right) => right.width * right.height - left.width * left.height)[0];
+        if (largestPhoto?.file_id) {
+            attachments.push({
+                fileId: largestPhoto.file_id,
+                preferredName: `photo-${message.message_id}.jpg`,
+                mimeType: "image/jpeg",
+            });
+        }
+    }
+    if (message.document?.file_id) {
+        attachments.push({
+            fileId: message.document.file_id,
+            preferredName: message.document.file_name || `document-${message.message_id}.bin`,
+            ...(message.document.mime_type
+                ? { mimeType: message.document.mime_type }
+                : {}),
+        });
+    }
+    return attachments;
+}

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportContext = void 0;
+const i18n_1 = require("../../i18n");
+class TransportContext {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    getPrincipalFromContext(ctx) {
+        const chatId = ctx.chat?.id;
+        const userId = ctx.from?.id;
+        if (!chatId || !userId) {
+            return null;
+        }
+        return {
+            telegramChatId: chatId,
+            telegramUserId: userId,
+        };
+    }
+    async resolveLocaleForContext(ctx) {
+        if (this.host.config?.telegram?.debugLanguage) {
+            return (0, i18n_1.normalizeLocale)(this.host.config.telegram.debugLanguage);
+        }
+        const telegramUserId = ctx.from?.id;
+        const telegramLanguageCode = ctx.from?.language_code;
+        if (!telegramUserId) {
+            return (0, i18n_1.normalizeLocale)(telegramLanguageCode);
+        }
+        const storedLocale = await this.host.localeStore?.getUserLocale?.(telegramUserId);
+        if (storedLocale) {
+            return (0, i18n_1.normalizeLocale)(storedLocale);
+        }
+        const detectedLocale = (0, i18n_1.normalizeLocale)(telegramLanguageCode);
+        await this.host.localeStore?.setUserLocale?.(telegramUserId, detectedLocale);
+        return detectedLocale;
+    }
+    async resolveLocaleForTelegramUserId(telegramUserId, telegramLanguageCode) {
+        if (this.host.config?.telegram?.debugLanguage) {
+            return (0, i18n_1.normalizeLocale)(this.host.config.telegram.debugLanguage);
+        }
+        if (!telegramUserId) {
+            return (0, i18n_1.normalizeLocale)(telegramLanguageCode);
+        }
+        const storedLocale = await this.host.localeStore?.getUserLocale?.(telegramUserId);
+        if (storedLocale) {
+            return (0, i18n_1.normalizeLocale)(storedLocale);
+        }
+        const detectedLocale = (0, i18n_1.normalizeLocale)(telegramLanguageCode);
+        await this.host.localeStore?.setUserLocale?.(telegramUserId, detectedLocale);
+        return detectedLocale;
+    }
+    async tForContext(ctx, key, options) {
+        return this.t(await this.resolveLocaleForContext(ctx), key, options);
+    }
+    async tForTelegramUserId(telegramUserId, key, options) {
+        return this.t(await this.resolveLocaleForTelegramUserId(telegramUserId), key, options);
+    }
+    t(locale, key, options) {
+        return (0, i18n_1.translate)(locale, key, options);
+    }
+    getGatewayActorFromContext(ctx) {
+        const firstName = ctx.from?.first_name?.trim();
+        const lastName = ctx.from?.last_name?.trim();
+        const username = ctx.from?.username?.trim();
+        const displayName = [firstName, lastName].filter(Boolean).join(" ").trim();
+        if (!firstName && !lastName && !username) {
+            return undefined;
+        }
+        return {
+            ...(username ? { telegramUsername: username } : {}),
+            ...(firstName ? { telegramFirstName: firstName } : {}),
+            ...(lastName ? { telegramLastName: lastName } : {}),
+            ...(displayName ? { telegramDisplayName: displayName } : {}),
+        };
+    }
+}
+exports.TransportContext = TransportContext;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportDocumentActions = void 0;
+const grammy_1 = require("grammy");
+class TransportDocumentActions {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async replyDocumentWithRetry(ctx, document, options = {}, meta) {
+        let attempt = 0;
+        while (true) {
+            attempt += 1;
+            try {
+                await ctx.replyWithDocument(document, options);
+                return;
+            }
+            catch (error) {
+                if (!(error instanceof grammy_1.GrammyError) || error.error_code !== 429) {
+                    throw error;
+                }
+                const retryAfterSeconds = Math.max(1, error.parameters.retry_after ?? 1);
+                this.host.logger.warn("Telegram rate limit hit while sending document, cooling down", {
+                    kind: meta.kind,
+                    sessionId: meta.sessionId,
+                    requestId: meta.requestId,
+                    attempt,
+                    retryAfterSeconds,
+                    description: error.description,
+                });
+                await new Promise((resolve) => setTimeout(resolve, retryAfterSeconds * 1000));
+            }
+        }
+    }
+}
+exports.TransportDocumentActions = TransportDocumentActions;

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

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportEventActions = void 0;
+const grammy_1 = require("grammy");
+const relay_1 = require("../../../app/webapp/relay");
+const projectIdentity_1 = require("../../lib/project-identity/projectIdentity");
+const telegramXchangeRecords_1 = require("../../lib/telegramXchangeRecords");
+class TransportEventActions {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async handleToolsUpdatedEvent(input) {
+        const session = await this.host.sessionStore.getSession(input.local_session_id);
+        if (!session) {
+            this.host.logger.warn("Skipping tools update event because local session is unavailable", {
+                sessionId: input.local_session_id,
+                reason: input.reason,
+            });
+            return;
+        }
+        this.host.logger.info("TOOLS.md update event received for console", {
+            sessionId: session.sessionId,
+            sessionLabel: session.label ?? input.session_label ?? session.sessionId,
+            reason: input.reason,
+            gatewayToolsHash: input.gateway_tools_hash,
+            clientToolsHash: input.client_tools_hash,
+        });
+        const binding = await this.host.bindingStore.getBinding(session.sessionId);
+        if (!binding) {
+            return;
+        }
+        await this.host.sendNotification({
+            sessionId: session.sessionId,
+            ...(session.label ? { sessionLabel: session.label } : {}),
+            recipient: {
+                telegramChatId: binding.telegramChatId,
+                telegramUserId: binding.telegramUserId,
+            },
+            message: [
+                await this.host.tForTelegramUserId(binding.telegramUserId, "menu:notices.tools.changed"),
+                await this.host.tForTelegramUserId(binding.telegramUserId, "menu:notices.tools.session", {
+                    sessionName: session.label ?? input.session_label ?? session.sessionId,
+                }),
+                await this.host.tForTelegramUserId(binding.telegramUserId, "menu:notices.tools.action_required"),
+            ].join("\n"),
+        });
+        await this.host.sessionStore.setSession({
+            ...session,
+            lastNotifiedToolsHash: input.gateway_tools_hash,
+            updatedAt: new Date().toISOString(),
+        });
+        if (session.cwd?.trim()) {
+            (0, projectIdentity_1.writeSessionMarkerState)({
+                cwd: session.cwd,
+                localSessionId: session.sessionId,
+                lastSeenToolsHash: session.lastSeenToolsHash,
+                lastNotifiedToolsHash: input.gateway_tools_hash,
+                logger: this.host.logger,
+            });
+        }
+    }
+    async handleGatewayVersionCompatibilityEvent(input) {
+        const session = await this.host.sessionStore.getSession(input.local_session_id);
+        if (!session) {
+            this.host.logger.warn("Skipping gateway version compatibility event because local session is unavailable", {
+                sessionId: input.local_session_id,
+                compatibility: input.compatibility,
+            });
+            return;
+        }
+        const title = input.compatibility === "reject"
+            ? "Gateway/client protocol mismatch blocks transport."
+            : "Gateway/client version mismatch detected.";
+        await (0, telegramXchangeRecords_1.writeLocalTaskXchangeRecord)({
+            config: this.host.config,
+            session,
+            sessionId: session.sessionId,
+            summary: title,
+            kind: input.compatibility,
+            text: [
+                title,
+                `Session: ${session.label ?? input.session_label ?? session.sessionId}`,
+                `Compatibility: ${input.compatibility}`,
+                `Client package: ${input.client_package_version}`,
+                `Client protocol: ${input.client_protocol_version}`,
+                `Gateway package: ${input.gateway_package_version}`,
+                `Gateway protocol: ${input.gateway_protocol_version}`,
+                `Client capabilities: ${input.client_capabilities.join(", ") || "none"}`,
+                `Gateway capabilities: ${input.gateway_capabilities.join(", ") || "none"}`,
+                ...(input.reasons.length > 0
+                    ? ["", "# Reasons", ...input.reasons.map((reason) => `- ${reason}`)]
+                    : []),
+                "",
+                "# Action Required",
+                input.instruction,
+                ...(input.compatibility === "reject"
+                    ? [
+                        "Do not continue collaboration, delivery, or live relay work until this client is upgraded.",
+                    ]
+                    : [
+                        "Upgrade the older side soon and verify the updated tools content before continuing sensitive work.",
+                    ]),
+            ].join("\n"),
+            createdAt: new Date().toISOString(),
+            actionDesc: "Read the compatibility details, stop sensitive work on this console if required, then upgrade the incompatible side before continuing.",
+            tools: ["get_xchange_record", "mark_xchange_record_read", "refresh_tools_markdown"],
+            tags: ["system", "version", input.compatibility],
+        });
+        await this.host.nudgeSessionInbox(session.sessionId);
+        const binding = await this.host.bindingStore.getBinding(session.sessionId);
+        if (!binding) {
+            return;
+        }
+        await this.host.sendNotification({
+            sessionId: session.sessionId,
+            ...(session.label ? { sessionLabel: session.label } : {}),
+            recipient: {
+                telegramChatId: binding.telegramChatId,
+                telegramUserId: binding.telegramUserId,
+            },
+            message: [
+                await this.host.tForTelegramUserId(binding.telegramUserId, input.compatibility === "reject"
+                    ? "menu:notices.version.reject"
+                    : "menu:notices.version.warn"),
+                await this.host.tForTelegramUserId(binding.telegramUserId, "menu:notices.version.session", {
+                    sessionName: session.label ?? input.session_label ?? session.sessionId,
+                }),
+                await this.host.tForTelegramUserId(binding.telegramUserId, "menu:notices.version.client", {
+                    packageVersion: input.client_package_version,
+                    protocolVersion: input.client_protocol_version,
+                }),
+                await this.host.tForTelegramUserId(binding.telegramUserId, "menu:notices.version.gateway", {
+                    packageVersion: input.gateway_package_version,
+                    protocolVersion: input.gateway_protocol_version,
+                }),
+                input.instruction,
+            ].join("\n"),
+        });
+    }
+    async handleLiveViewApprovalRequestEvent(input) {
+        const targetSession = (await this.host.sessionStore.getSession(input.target_local_session_id)) ??
+            (await this.host.sessionStore.getSession((0, relay_1.buildLiveRelaySessionId)(input.target_client_uuid, input.target_local_session_id)));
+        if (!targetSession) {
+            this.host.logger.warn("Skipping live approval request because target session is unavailable", {
+                targetLocalSessionId: input.target_local_session_id,
+                sourceLocalSessionId: input.source_local_session_id,
+            });
+            return;
+        }
+        const binding = await this.host.bindingStore.getBinding(targetSession.sessionId);
+        if (!binding) {
+            this.host.logger.warn("Skipping live approval request because target session has no active Telegram route", {
+                sessionId: targetSession.sessionId,
+                sourceLocalSessionId: input.source_local_session_id,
+            });
+            return;
+        }
+        const locale = await this.host.resolveLocaleForTelegramUserId(binding.telegramUserId);
+        const payloadKey = await this.host.createLiveApprovalMenuPayload({
+            sessionId: targetSession.sessionId,
+            sourceSessionId: input.source_session_id,
+            sourceSessionLabel: input.source_session_label,
+            sourceClientUuid: input.source_client_uuid,
+            sourceLocalSessionId: input.source_local_session_id,
+            targetSessionId: input.target_session_id,
+            targetSessionLabel: input.target_session_label,
+            targetClientUuid: input.target_client_uuid,
+            targetLocalSessionId: input.target_local_session_id,
+            ...(input.project_uuid ? { projectUuid: input.project_uuid } : {}),
+            ...(input.project_name ? { projectName: input.project_name } : {}),
+        });
+        const sent = await this.host.sendChatMessage(binding.telegramChatId, [
+            this.host.t(locale, "menu:live.approval.request_title"),
+            "",
+            ...(input.project_name
+                ? [
+                    this.host.t(locale, "menu:live.approval.project", {
+                        projectName: input.project_name,
+                    }),
+                ]
+                : []),
+            this.host.t(locale, "menu:live.approval.route", {
+                sourceSessionName: input.source_session_label,
+                targetSessionName: input.target_session_label,
+            }),
+            "",
+            this.host.t(locale, "menu:live.approval.request_message", {
+                sourceSessionName: input.source_session_label,
+            }),
+        ].join("\n"), {
+            reply_markup: new grammy_1.InlineKeyboard()
+                .text(`✅ ${this.host.t(locale, "menu:live.approval.approve")}`, `live-approval:approve:${payloadKey}`)
+                .text(`❌ ${this.host.t(locale, "menu:live.approval.deny")}`, `live-approval:deny:${payloadKey}`),
+        }, {
+            kind: "notification",
+            sessionId: targetSession.sessionId,
+        });
+        this.host.logger.info("Telegram live approval request delivered", {
+            sessionId: targetSession.sessionId,
+            telegramChatId: binding.telegramChatId,
+            telegramUserId: binding.telegramUserId,
+            messageId: sent.message_id,
+            sourceLocalSessionId: input.source_local_session_id,
+        });
+    }
+    async handleLiveViewApprovalResolvedEvent(input) {
+        const sourceSession = (await this.host.sessionStore.getSession(input.source_local_session_id)) ??
+            (await this.host.sessionStore.getSession((0, relay_1.buildLiveRelaySessionId)(input.source_client_uuid, input.source_local_session_id)));
+        if (!sourceSession) {
+            this.host.logger.warn("Skipping live approval resolution because source session is unavailable", {
+                sourceLocalSessionId: input.source_local_session_id,
+                targetLocalSessionId: input.target_local_session_id,
+            });
+            return;
+        }
+        const binding = await this.host.bindingStore.getBinding(sourceSession.sessionId);
+        if (!binding) {
+            this.host.logger.warn("Skipping live approval resolution because source session has no active Telegram route", {
+                sessionId: sourceSession.sessionId,
+                targetLocalSessionId: input.target_local_session_id,
+            });
+            return;
+        }
+        const locale = await this.host.resolveLocaleForTelegramUserId(binding.telegramUserId);
+        if (!input.approved) {
+            await this.host.sendNotification({
+                sessionId: sourceSession.sessionId,
+                ...(sourceSession.label ? { sessionLabel: sourceSession.label } : {}),
+                recipient: {
+                    telegramChatId: binding.telegramChatId,
+                    telegramUserId: binding.telegramUserId,
+                },
+                message: [
+                    this.host.t(locale, "menu:live.approval.denied"),
+                    ...(input.project_name
+                        ? [
+                            this.host.t(locale, "menu:live.approval.project", {
+                                projectName: input.project_name,
+                            }),
+                        ]
+                        : []),
+                    this.host.t(locale, "menu:live.approval.route", {
+                        sourceSessionName: input.source_session_label,
+                        targetSessionName: input.target_session_label,
+                    }),
+                ].join("\n"),
+            });
+            return;
+        }
+        const liveViewUrl = this.host.buildLiveViewUrl({
+            targetSessionId: input.target_session_id,
+            targetClientUuid: input.target_client_uuid,
+            targetLocalSessionId: input.target_local_session_id,
+        });
+        if (!liveViewUrl) {
+            throw new Error("Unable to build Live View URL for approved request.");
+        }
+        const sent = await this.host.sendChatMessage(binding.telegramChatId, [
+            this.host.t(locale, "menu:live.approval.approved"),
+            "",
+            ...(input.project_name
+                ? [
+                    this.host.t(locale, "menu:live.approval.project", {
+                        projectName: input.project_name,
+                    }),
+                ]
+                : []),
+            this.host.t(locale, "menu:live.approval.route", {
+                sourceSessionName: input.source_session_label,
+                targetSessionName: input.target_session_label,
+            }),
+            "",
+            this.host.t(locale, "menu:live.actions.choose_mode"),
+        ].join("\n"), {
+            reply_markup: this.host.buildLiveViewKeyboard((mode) => this.host.buildLiveViewUrl({
+                targetSessionId: input.target_session_id,
+                targetClientUuid: input.target_client_uuid,
+                targetLocalSessionId: input.target_local_session_id,
+                launchMode: mode,
+            }), locale),
+        }, {
+            kind: "notification",
+            sessionId: sourceSession.sessionId,
+        });
+        this.host.webAppLaunchRegistry.set(binding.telegramUserId, sourceSession.sessionId, this.host.config.webapp.initDataTtlSeconds, {
+            telegramChatId: binding.telegramChatId,
+            telegramMessageId: sent.message_id,
+        });
+    }
+}
+exports.TransportEventActions = TransportEventActions;