@deadragdoll/tellymcp 0.0.9 → 0.0.11

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canRenderLiveView = canRenderLiveView;
+exports.buildLiveViewUrlForSessionTarget = buildLiveViewUrlForSessionTarget;
+exports.buildLiveViewLaunchKeyboard = buildLiveViewLaunchKeyboard;
+exports.buildLiveLauncherText = buildLiveLauncherText;
+const grammy_1 = require("grammy");
+const relay_1 = require("../../../app/webapp/relay");
+const transportUtils_1 = require("./transportUtils");
+function canRenderLiveView(config) {
+    return Boolean(config.webapp.enabled &&
+        (config.webapp.publicUrl || config.distributed.gatewayPublicUrl));
+}
+function buildLiveViewUrlForSessionTarget(input) {
+    const { config } = input;
+    if (!canRenderLiveView(config)) {
+        return null;
+    }
+    const canUseRelay = Boolean(input.targetClientUuid) &&
+        Boolean(input.targetLocalSessionId) &&
+        Boolean(config.distributed.gatewayPublicUrl);
+    const baseUrl = canUseRelay
+        ? (0, relay_1.resolveGatewayWebAppBaseUrl)(config.distributed.gatewayPublicUrl, config.webapp.basePath)
+        : (0, transportUtils_1.resolveWebAppPublicBaseUrl)(config);
+    if (!baseUrl) {
+        return null;
+    }
+    const liveSessionId = canUseRelay
+        ? (0, relay_1.buildLiveRelaySessionId)(input.targetClientUuid, input.targetLocalSessionId, input.sourceClientUuid)
+        : (input.targetLocalSessionId ?? input.targetSessionId);
+    const url = new URL(`${baseUrl}/live/${encodeURIComponent(liveSessionId)}`);
+    url.searchParams.set("launchMode", input.launchMode ?? config.webapp.launchMode);
+    return url.toString();
+}
+function buildLiveViewLaunchKeyboard(input) {
+    const keyboard = new grammy_1.InlineKeyboard();
+    const modes = [
+        { mode: "fullscreen", label: input.labels.fullscreen },
+        { mode: "expand", label: input.labels.expand },
+        { mode: "default", label: input.labels.default },
+    ];
+    for (const [index, { mode, label }] of modes.entries()) {
+        const url = input.getUrl(mode);
+        if (!url) {
+            continue;
+        }
+        keyboard.webApp(label, url);
+        if (index === 1) {
+            keyboard.row();
+        }
+    }
+    return keyboard;
+}
+function buildLiveLauncherText(input) {
+    return [input.title, "", input.chooseMode].join("\n");
+}

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportLiveActions = void 0;
+const node_url_1 = require("node:url");
+const relay_1 = require("../../../app/webapp/relay");
+const transportLive_1 = require("./transportLive");
+const transportUtils_1 = require("./transportUtils");
+class TransportLiveActions {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    canRender() {
+        return (0, transportLive_1.canRenderLiveView)(this.host.config);
+    }
+    buildUrl(input) {
+        return (0, transportLive_1.buildLiveViewUrlForSessionTarget)({
+            config: this.host.config,
+            ...input,
+        });
+    }
+    buildKeyboard(getUrl, locale = "en") {
+        return (0, transportLive_1.buildLiveViewLaunchKeyboard)({
+            getUrl,
+            labels: {
+                fullscreen: this.host.t(locale, "menu:live.buttons.fullscreen"),
+                expand: this.host.t(locale, "menu:live.buttons.expand"),
+                default: this.host.t(locale, "menu:live.buttons.default"),
+            },
+        });
+    }
+    async sendLauncherMessage(input) {
+        if (!(0, transportLive_1.canRenderLiveView)(this.host.config)) {
+            return null;
+        }
+        const useGatewayRelay = this.host.config.distributed.mode === "client" &&
+            Boolean(this.host.config.distributed.gatewayPublicUrl);
+        const clientUuid = useGatewayRelay
+            ? await this.host.ensureGatewayClientUuid(input.principal, input.actor)
+            : null;
+        const baseUrl = useGatewayRelay
+            ? (0, relay_1.resolveGatewayWebAppBaseUrl)(this.host.config.distributed.gatewayPublicUrl, this.host.config.webapp.basePath)
+            : (0, transportUtils_1.resolveWebAppPublicBaseUrl)(this.host.config);
+        if (!baseUrl) {
+            return null;
+        }
+        const relayTarget = (0, relay_1.parseLiveRelaySessionId)(input.sessionId);
+        const allowForeignBinding = input.allowForeignBinding === true || Boolean(relayTarget);
+        const resolvedLiveSessionId = useGatewayRelay && clientUuid && !input.sessionId.startsWith("relay~")
+            ? (0, relay_1.buildLiveRelaySessionId)(clientUuid, input.sessionId)
+            : input.sessionId;
+        const url = new node_url_1.URL(`${baseUrl}/live/${encodeURIComponent(resolvedLiveSessionId)}`);
+        url.searchParams.set("launchMode", this.host.config.webapp.launchMode);
+        const sent = await this.host.sendChatMessage(input.principal.telegramChatId, (0, transportLive_1.buildLiveLauncherText)({
+            title: this.host.t(input.locale, "menu:live.screen.launcher_title", {
+                sessionName: input.sessionName,
+            }),
+            chooseMode: this.host.t(input.locale, "menu:live.actions.choose_mode"),
+        }), {
+            reply_markup: this.buildKeyboard((mode) => {
+                const modeUrl = new node_url_1.URL(url.toString());
+                modeUrl.searchParams.set("launchMode", mode);
+                return modeUrl.toString();
+            }, input.locale),
+        }, {
+            kind: "notification",
+            sessionId: input.sessionId,
+        });
+        this.host.webAppLaunchRegistry.set(input.principal.telegramUserId, input.sessionId, this.host.config.webapp.initDataTtlSeconds, {
+            telegramChatId: input.principal.telegramChatId,
+            ...(allowForeignBinding ? { allowForeignBinding: true } : {}),
+            telegramMessageId: sent.message_id,
+        });
+        return sent;
+    }
+}
+exports.TransportLiveActions = TransportLiveActions;

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

@@ -0,0 +1,254 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportMenuCallbacks = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const relay_1 = require("../../../app/webapp/relay");
+class TransportMenuCallbacks {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async handleScreenshotOpen(ctx, payloadKey) {
+        const payload = await this.requireFileEntryPayload(ctx, payloadKey, "Screenshot");
+        if (!payload)
+            return;
+        const meta = await this.getXchangeFileMeta(payload.sessionId, payload.filePath);
+        await ctx.answerCallbackQuery({ text: "Screenshot opened." });
+        await this.host.editText(ctx, this.host.formatScreenshotDetail(payload.sessionId, payload.filePath, meta), { kind: "menu", sessionId: payload.sessionId }, { reply_markup: this.host.screenshotMessageMenu });
+    }
+    async handleScreenshotGet(ctx, payloadKey) {
+        const payload = await this.requireFileEntryPayload(ctx, payloadKey, "Screenshot");
+        if (!payload)
+            return;
+        const chatId = ctx.chat?.id;
+        if (!chatId) {
+            await ctx.answerCallbackQuery({ text: "Telegram chat is unavailable.", show_alert: true });
+            return;
+        }
+        if (this.isRelaySessionId(payload.sessionId)) {
+            await this.host.callGatewayJson("/transport/send-file", {
+                session_id: payload.sessionId,
+                file_path: payload.filePath,
+                caption: `Screenshot: ${node_path_1.default.basename(payload.filePath)}`,
+            });
+            await ctx.answerCallbackQuery({ text: "Screenshot sent." });
+            await this.host.showScreenshotsMenu(ctx, "Screenshot sent to Telegram.");
+            return;
+        }
+        const ensured = await this.host.ensureStoredXchangeFile(payload.sessionId, payload.filePath, "browser-screenshot");
+        await this.host.sendDocumentToChat(chatId, ensured.filePath, `Screenshot: ${node_path_1.default.basename(ensured.filePath)}`);
+        await ctx.answerCallbackQuery({ text: "Screenshot sent." });
+        await this.host.showScreenshotsMenu(ctx, "Screenshot sent to Telegram.");
+    }
+    async handleScreenshotDelete(ctx, payloadKey) {
+        const payload = await this.requireFileEntryPayload(ctx, payloadKey, "Screenshot");
+        if (!payload)
+            return;
+        const meta = await this.getXchangeFileMeta(payload.sessionId, payload.filePath);
+        if (this.isRelaySessionId(payload.sessionId)) {
+            await this.deleteXchangeFileMeta(payload.sessionId, payload.filePath);
+            await ctx.answerCallbackQuery({
+                text: meta ? "Screenshot deleted." : "Screenshot already absent.",
+            });
+            await this.host.showScreenshotsMenu(ctx, meta ? "Screenshot deleted." : "Screenshot was already removed.");
+            return;
+        }
+        await this.host.objectStore.deleteStoredFile({
+            ...(meta?.storageRef ? { storageRef: meta.storageRef } : {}),
+            ...(typeof meta?.vfsNodeId === "number" ? { vfsNodeId: meta.vfsNodeId } : {}),
+        });
+        await this.host.xchangeFileMetaStore.deleteXchangeFileMeta(payload.sessionId, payload.filePath);
+        await ctx.answerCallbackQuery({
+            text: meta ? "Screenshot deleted." : "Screenshot already absent.",
+        });
+        await this.host.showScreenshotsMenu(ctx, meta ? "Screenshot deleted." : "Screenshot was already removed.");
+    }
+    async handleStorageOpen(ctx, payloadKey) {
+        const payload = await this.requireFileEntryPayload(ctx, payloadKey, "Storage");
+        if (!payload)
+            return;
+        const meta = await this.getXchangeFileMeta(payload.sessionId, payload.filePath);
+        await ctx.answerCallbackQuery({ text: "Storage entry opened." });
+        await this.host.editText(ctx, this.host.formatStorageDetail(payload.sessionId, payload.filePath, meta), { kind: "menu", sessionId: payload.sessionId }, { reply_markup: this.host.storageMessageMenu });
+    }
+    async handleStorageGet(ctx, payloadKey) {
+        const payload = await this.requireFileEntryPayload(ctx, payloadKey, "Storage");
+        if (!payload)
+            return;
+        const chatId = ctx.chat?.id;
+        if (!chatId) {
+            await ctx.answerCallbackQuery({ text: "Telegram chat is unavailable.", show_alert: true });
+            return;
+        }
+        const meta = await this.getXchangeFileMeta(payload.sessionId, payload.filePath);
+        if (this.isRelaySessionId(payload.sessionId)) {
+            await this.host.callGatewayJson("/transport/send-file", {
+                session_id: payload.sessionId,
+                file_path: payload.filePath,
+                caption: `Storage: ${this.host.formatFilePreviewLabel(payload.filePath, meta)}`,
+            });
+            await ctx.answerCallbackQuery({ text: "Storage file sent." });
+            await this.host.showStorageMenu(ctx, "Storage file sent to Telegram.");
+            return;
+        }
+        let ensured;
+        try {
+            ensured = await this.host.ensureStoredXchangeFile(payload.sessionId, payload.filePath, meta?.source ?? "telegram-upload");
+        }
+        catch (error) {
+            await ctx.answerCallbackQuery({
+                text: error instanceof Error ? error.message : "Storage file is not available locally.",
+                show_alert: true,
+            });
+            await this.host.showStorageMenu(ctx, "Storage entry is stale or missing locally. You can delete it from Storage.");
+            return;
+        }
+        await this.host.sendDocumentToChat(chatId, ensured.filePath, `Storage: ${this.host.formatFilePreviewLabel(ensured.filePath, meta)}`);
+        await ctx.answerCallbackQuery({ text: "Storage file sent." });
+        await this.host.showStorageMenu(ctx, "Storage file sent to Telegram.");
+    }
+    async handleStorageDelete(ctx, payloadKey) {
+        const payload = await this.requireFileEntryPayload(ctx, payloadKey, "Storage");
+        if (!payload)
+            return;
+        const meta = await this.getXchangeFileMeta(payload.sessionId, payload.filePath);
+        if (this.isRelaySessionId(payload.sessionId)) {
+            await this.deleteXchangeFileMeta(payload.sessionId, payload.filePath);
+            await ctx.answerCallbackQuery({
+                text: "Storage metadata deleted.",
+            });
+            await this.host.showStorageMenu(ctx, "Stale storage metadata deleted.");
+            return;
+        }
+        await this.host.objectStore.deleteStoredFile({
+            ...(meta?.storageRef ? { storageRef: meta.storageRef } : {}),
+            ...(typeof meta?.vfsNodeId === "number" ? { vfsNodeId: meta.vfsNodeId } : {}),
+        });
+        await this.host.xchangeFileMetaStore.deleteXchangeFileMeta(payload.sessionId, payload.filePath);
+        await ctx.answerCallbackQuery({
+            text: "Storage metadata deleted.",
+        });
+        await this.host.showStorageMenu(ctx, "Stale storage metadata deleted.");
+    }
+    async handleSessionSelection(ctx, payloadKey) {
+        if (!payloadKey) {
+            await ctx.answerCallbackQuery({ text: "Session payload is missing.", show_alert: true });
+            return;
+        }
+        const payload = await this.host.getMenuPayloadByKey(payloadKey);
+        if (!payload || payload.kind !== "active-session") {
+            await ctx.answerCallbackQuery({ text: "Session payload is invalid or expired.", show_alert: true });
+            return;
+        }
+        const principal = this.host.getPrincipalFromContext(ctx);
+        if (!principal) {
+            await ctx.answerCallbackQuery({ text: "Telegram user or chat is missing.", show_alert: true });
+            return;
+        }
+        const sessionIds = await this.host.bindingStore.listBoundSessionIdsForPrincipal(principal);
+        if (!sessionIds.includes(String(payload.sessionId))) {
+            await ctx.answerCallbackQuery({
+                text: "This session is not linked to your Telegram identity.",
+                show_alert: true,
+            });
+            return;
+        }
+        await this.host.bindingStore.setActiveSessionIdForPrincipal(principal, String(payload.sessionId));
+        const session = await this.host.sessionStore.getSession(String(payload.sessionId));
+        this.host.logger.info("Telegram active session changed", {
+            sessionId: payload.sessionId,
+            chatId: ctx.chat?.id,
+            userId: ctx.from?.id,
+        });
+        await this.host.maybeNotifyToolsMismatchForSession(String(payload.sessionId));
+        await ctx.answerCallbackQuery({
+            text: session?.label ? `Active session: ${session.label}` : `Active session: ${String(payload.sessionId)}`,
+        });
+        await this.host.showMainMenu(ctx);
+    }
+    async handleSessionGroupSelection(ctx, payloadKey) {
+        if (!payloadKey) {
+            await ctx.answerCallbackQuery({ text: "Session group payload is missing.", show_alert: true });
+            return;
+        }
+        const payload = await this.host.getMenuPayloadByKey(payloadKey);
+        this.host.logger.info("Telegram session group payload lookup", {
+            payloadKey,
+            payload,
+            chatId: ctx.chat?.id,
+            userId: ctx.from?.id,
+        });
+        if (!payload || payload.kind !== "session-group") {
+            await ctx.answerCallbackQuery({ text: "Session group payload is invalid or expired.", show_alert: true });
+            return;
+        }
+        await ctx.answerCallbackQuery({
+            text: typeof payload.ownerLabel === "string" && payload.ownerLabel.trim()
+                ? payload.ownerLabel
+                : "Sessions",
+        });
+        await this.host.showSessionsMenu(ctx);
+    }
+    async requireFileEntryPayload(ctx, payloadKey, kindLabel) {
+        if (!payloadKey) {
+            await ctx.answerCallbackQuery({ text: `${kindLabel} payload is missing.`, show_alert: true });
+            return null;
+        }
+        const payload = await this.host.getMenuPayloadByKey(payloadKey);
+        if (!payload || payload.kind !== "file-entry" || !payload.filePath) {
+            await ctx.answerCallbackQuery({
+                text: `${kindLabel} payload is invalid or expired.`,
+                show_alert: true,
+            });
+            return null;
+        }
+        const sessionId = String(payload.sessionId ?? "").trim();
+        const filePath = String(payload.filePath).trim();
+        if (!sessionId) {
+            await ctx.answerCallbackQuery({
+                text: `${kindLabel} session is missing in payload.`,
+                show_alert: true,
+            });
+            return null;
+        }
+        const relay = (0, relay_1.parseLiveRelaySessionId)(sessionId);
+        if (!relay?.localSessionId) {
+            return { sessionId, filePath };
+        }
+        const localSession = await this.host.sessionStore.getSession(relay.localSessionId);
+        if (!localSession) {
+            return { sessionId, filePath };
+        }
+        return {
+            sessionId: relay.localSessionId,
+            filePath,
+        };
+    }
+    isRelaySessionId(sessionId) {
+        return Boolean((0, relay_1.parseLiveRelaySessionId)(sessionId));
+    }
+    async getXchangeFileMeta(sessionId, filePath) {
+        if (this.isRelaySessionId(sessionId)) {
+            const output = await this.host.callGatewayJson("/storage/meta", {
+                session_id: sessionId,
+                file_path: filePath,
+            });
+            return output.meta ?? null;
+        }
+        return this.host.xchangeFileMetaStore.getXchangeFileMeta(sessionId, filePath);
+    }
+    async deleteXchangeFileMeta(sessionId, filePath) {
+        if (this.isRelaySessionId(sessionId)) {
+            const output = await this.host.callGatewayJson("/storage/delete-meta", {
+                session_id: sessionId,
+                file_path: filePath,
+            });
+            return output.deleted === true;
+        }
+        return this.host.xchangeFileMetaStore.deleteXchangeFileMeta(sessionId, filePath);
+    }
+}
+exports.TransportMenuCallbacks = TransportMenuCallbacks;