@deadragdoll/tellymcp 0.0.10 → 0.0.12

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

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportRequestFlow = void 0;
+const messageFormat_1 = require("./messageFormat");
+class TransportRequestFlow {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async sendAdminGatewayRegistrationNotifications(input) {
+        if (!this.host.isTelegramEnabled()) {
+            return;
+        }
+        const ownerRoute = await this.host.callGatewayJson("/user/route", {
+            client_uuid: input.clientUuid,
+            ...(input.gatewayUserUuid ? { gateway_user_uuid: input.gatewayUserUuid } : {}),
+        });
+        if (typeof ownerRoute.telegram_user_id !== "number" ||
+            typeof ownerRoute.telegram_chat_id !== "number") {
+            this.host.logger.debug("Skipping gateway registration notification because owner Telegram route is unavailable", {
+                clientUuid: input.clientUuid,
+                gatewayUserUuid: input.gatewayUserUuid ?? null,
+            });
+            return;
+        }
+        const principal = {
+            telegramChatId: ownerRoute.telegram_chat_id,
+            telegramUserId: ownerRoute.telegram_user_id,
+        };
+        const locale = await this.host.resolveLocaleForTelegramUserId(principal.telegramUserId);
+        const lines = [
+            this.host.t(locale, input.isNewClient
+                ? "menu:notices.admin.gateway_client_registered_title"
+                : "menu:notices.admin.gateway_session_registered_title"),
+            this.host.t(locale, "menu:notices.admin.gateway_client_uuid", {
+                value: input.clientUuid,
+            }),
+            ...(input.nodeId
+                ? [
+                    this.host.t(locale, "menu:notices.admin.gateway_node_id", {
+                        value: input.nodeId,
+                    }),
+                ]
+                : []),
+            ...(input.packageVersion
+                ? [
+                    this.host.t(locale, "menu:notices.admin.gateway_package_version", {
+                        value: input.packageVersion,
+                    }),
+                ]
+                : []),
+            this.host.t(locale, "menu:notices.admin.gateway_session_count", {
+                count: input.totalSessions,
+            }),
+            ...(input.newSessions.length > 0
+                ? [
+                    "",
+                    this.host.t(locale, "menu:notices.admin.gateway_new_sessions"),
+                    ...input.newSessions.map((session) => this.host.t(locale, "menu:notices.admin.gateway_session_item", {
+                        label: session.session_label?.trim() || session.local_session_id,
+                        localSessionId: session.local_session_id,
+                    })),
+                ]
+                : []),
+        ];
+        try {
+            await this.sendNotification({
+                sessionId: `gateway-owner:${input.clientUuid}`,
+                sessionLabel: "Gateway",
+                recipient: principal,
+                message: lines.join("\n"),
+            });
+        }
+        catch (error) {
+            this.host.logger.warn("Failed to deliver gateway registration owner notification", {
+                telegramChatId: principal.telegramChatId,
+                telegramUserId: principal.telegramUserId,
+                clientUuid: input.clientUuid,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async sendRequest(input) {
+        if (!this.host.isTelegramEnabled()) {
+            return this.sendRequestViaGateway(input);
+        }
+        const text = (0, messageFormat_1.formatTelegramMessage)(input, {
+            maxQuestionChars: this.host.config.telegram.maxQuestionChars,
+            maxContextChars: this.host.config.telegram.maxContextChars,
+            maxMessageChars: this.host.config.telegram.maxMessageChars,
+        });
+        const sentChunks = await this.host.sendTextChunks(input.recipient.telegramChatId, text, {
+            sessionId: input.sessionId,
+            requestId: input.requestId,
+            kind: "request",
+        });
+        const response = sentChunks.at(-1);
+        if (!response) {
+            throw new Error("Telegram request send produced no message chunks");
+        }
+        this.host.waiters.set(input.requestId, {
+            requestId: input.requestId,
+            telegramChatId: input.recipient.telegramChatId,
+            telegramUserId: input.recipient.telegramUserId,
+            telegramMessageId: response.messageId,
+            sentAtMs: Date.now(),
+        });
+        return { externalMessageId: response.messageId };
+    }
+    async sendRequestForGatewayBoundSession(input) {
+        const result = await this.sendRequest(input);
+        const waiter = this.host.waiters.get(input.requestId);
+        if (waiter) {
+            waiter.sourceClientUuid = input.sourceClientUuid;
+        }
+        return result;
+    }
+    async sendNotification(input) {
+        if (!this.host.isTelegramEnabled()) {
+            return this.sendNotificationViaGateway(input);
+        }
+        const text = (0, messageFormat_1.formatTelegramNotification)(input, {
+            maxQuestionChars: this.host.config.telegram.maxQuestionChars,
+            maxContextChars: this.host.config.telegram.maxContextChars,
+            maxMessageChars: this.host.config.telegram.maxMessageChars,
+        });
+        const sentChunks = await this.host.sendTextChunks(input.recipient.telegramChatId, text, {
+            sessionId: input.sessionId,
+            kind: "notification",
+        });
+        const response = sentChunks.at(-1);
+        if (!response) {
+            throw new Error("Telegram notification send produced no message chunks");
+        }
+        this.host.logger.info("Telegram notification delivered", {
+            sessionId: input.sessionId,
+            telegramChatId: input.recipient.telegramChatId,
+            telegramUserId: input.recipient.telegramUserId,
+            messageId: response.messageId,
+            chunks: sentChunks.length,
+        });
+        return { externalMessageId: response.messageId };
+    }
+    async waitForReply(requestId, timeoutSeconds) {
+        const waiter = this.host.waiters.get(requestId);
+        if (!waiter) {
+            throw new Error(`Transport waiter not found for request ${requestId}`);
+        }
+        if (waiter.reply) {
+            this.clearWaiter(requestId);
+            return waiter.reply;
+        }
+        return new Promise((resolve) => {
+            waiter.resolve = (reply) => {
+                if (waiter.timeout) {
+                    clearTimeout(waiter.timeout);
+                }
+                this.clearWaiter(requestId);
+                resolve(reply);
+            };
+            waiter.timeout = setTimeout(() => {
+                waiter.resolve?.(null);
+            }, timeoutSeconds * 1000);
+        });
+    }
+    async handleGatewayTransportReplyEvent(input) {
+        const waiter = this.host.waiters.get(input.request_id);
+        if (!waiter) {
+            this.host.logger.debug("Gateway transport reply ignored because waiter was not found", {
+                requestId: input.request_id,
+            });
+            return;
+        }
+        const reply = {
+            requestId: input.request_id,
+            answer: input.answer,
+            receivedAt: input.received_at,
+        };
+        this.host.logger.info("Gateway transport reply received", {
+            requestId: input.request_id,
+            telegramChatId: waiter.telegramChatId,
+            telegramUserId: waiter.telegramUserId,
+        });
+        if (waiter.resolve) {
+            waiter.resolve(reply);
+            return;
+        }
+        waiter.reply = reply;
+    }
+    clearWaiter(requestId) {
+        const waiter = this.host.waiters.get(requestId);
+        if (waiter?.timeout) {
+            clearTimeout(waiter.timeout);
+        }
+        this.host.waiters.delete(requestId);
+    }
+    async sendRequestViaGateway(input) {
+        if (!this.host.config.distributed.gatewayPublicUrl) {
+            throw new Error("Gateway is not configured for Telegram request proxying.");
+        }
+        const clientUuid = await this.host.maintenanceStore.getGatewayClientUuid();
+        if (!clientUuid) {
+            throw new Error("Gateway client UUID is unavailable for Telegram request proxying.");
+        }
+        this.host.waiters.set(input.requestId, {
+            requestId: input.requestId,
+            telegramChatId: input.recipient.telegramChatId,
+            telegramUserId: input.recipient.telegramUserId,
+            telegramMessageId: 0,
+            sentAtMs: Date.now(),
+        });
+        try {
+            const response = await this.host.callGatewayJson("/transport/request", {
+                client_uuid: clientUuid,
+                local_session_id: input.sessionId,
+                request_id: input.requestId,
+                ...(input.sessionLabel ? { session_label: input.sessionLabel } : {}),
+                telegram_chat_id: input.recipient.telegramChatId,
+                telegram_user_id: input.recipient.telegramUserId,
+                question: input.question,
+                ...(input.task ? { task: input.task } : {}),
+                ...(input.context ? { context: input.context } : {}),
+                ...(input.affectedFiles ? { affected_files: input.affectedFiles } : {}),
+                ...(input.options ? { options: input.options } : {}),
+                ...(input.recommendedOption
+                    ? { recommended_option: input.recommendedOption }
+                    : {}),
+                ...(input.riskLevel ? { risk_level: input.riskLevel } : {}),
+                ...(input.fallbackIfTimeout
+                    ? { fallback_if_timeout: input.fallbackIfTimeout }
+                    : {}),
+            });
+            const waiter = this.host.waiters.get(input.requestId);
+            if (waiter && typeof response.message_id === "number") {
+                waiter.telegramMessageId = response.message_id;
+            }
+            return typeof response.message_id === "undefined"
+                ? {}
+                : { externalMessageId: response.message_id };
+        }
+        catch (error) {
+            this.clearWaiter(input.requestId);
+            throw error;
+        }
+    }
+    async sendNotificationViaGateway(input) {
+        if (!this.host.config.distributed.gatewayPublicUrl) {
+            throw new Error("Gateway is not configured for Telegram notification proxying.");
+        }
+        const clientUuid = await this.host.maintenanceStore.getGatewayClientUuid();
+        if (!clientUuid) {
+            throw new Error("Gateway client UUID is unavailable for Telegram notification proxying.");
+        }
+        const response = await this.host.callGatewayJson("/transport/notify", {
+            client_uuid: clientUuid,
+            local_session_id: input.sessionId,
+            ...(input.sessionLabel ? { session_label: input.sessionLabel } : {}),
+            telegram_chat_id: input.recipient.telegramChatId,
+            telegram_user_id: input.recipient.telegramUserId,
+            message: input.message,
+            ...(input.task ? { task: input.task } : {}),
+            ...(input.context ? { context: input.context } : {}),
+            ...(input.riskLevel ? { risk_level: input.riskLevel } : {}),
+        });
+        this.host.logger.info("Gateway transport notification delivered", {
+            sessionId: input.sessionId,
+            telegramChatId: input.recipient.telegramChatId,
+            telegramUserId: input.recipient.telegramUserId,
+            ...(typeof response.message_id !== "undefined"
+                ? { messageId: response.message_id }
+                : {}),
+        });
+        return typeof response.message_id === "undefined"
+            ? {}
+            : { externalMessageId: response.message_id };
+    }
+}
+exports.TransportRequestFlow = TransportRequestFlow;

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

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportSessionActions = void 0;
+const transportUtils_1 = require("./transportUtils");
+const redactSecrets_1 = require("../../lib/redact-secrets/redactSecrets");
+class TransportSessionActions {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async unpairActiveSession(ctx) {
+        const locale = await this.host.resolveLocaleForContext(ctx);
+        const principal = this.host.getPrincipalFromContext(ctx);
+        if (!principal) {
+            await ctx.answerCallbackQuery({
+                text: this.host.t(locale, "common:errors.no_telegram_identity"),
+                show_alert: true,
+            });
+            return;
+        }
+        const sessionId = await this.host.bindingStore.getActiveSessionIdForPrincipal(principal);
+        if (!sessionId) {
+            await ctx.answerCallbackQuery({
+                text: this.host.t(locale, "common:errors.no_active_session"),
+                show_alert: true,
+            });
+            return;
+        }
+        const session = await this.host.sessionStore.getSession(sessionId);
+        if (session && this.host.config.distributed.gatewayPublicUrl) {
+            await this.host.sessionStore.setSession({
+                ...session,
+                activeProjectUuid: undefined,
+                activeProjectName: undefined,
+                updatedAt: new Date().toISOString(),
+            });
+        }
+        await this.host.bindingStore.clearBinding(sessionId);
+        this.host.logger.info("Telegram active session route cleared from menu", {
+            sessionId,
+            chatId: ctx.chat?.id,
+            userId: ctx.from?.id,
+        });
+        this.host.clearPendingInteractionsForContext(ctx);
+        await ctx.answerCallbackQuery({
+            text: this.host.t(locale, "menu:unpair.done", {
+                sessionName: session?.label ?? sessionId,
+            }),
+        });
+        await this.host.showSessionsMenu(ctx, this.host.t(locale, "menu:unpair.shown", {
+            sessionName: session?.label ?? sessionId,
+        }));
+    }
+    async beginRenameActiveSession(ctx) {
+        const locale = await this.host.resolveLocaleForContext(ctx);
+        const principal = this.host.getPrincipalFromContext(ctx);
+        if (!principal) {
+            await ctx.answerCallbackQuery({
+                text: this.host.t(locale, "common:errors.no_telegram_identity"),
+                show_alert: true,
+            });
+            return;
+        }
+        const sessionId = await this.host.bindingStore.getActiveSessionIdForPrincipal(principal);
+        if (!sessionId) {
+            await ctx.answerCallbackQuery({
+                text: this.host.t(locale, "common:errors.no_active_session"),
+                show_alert: true,
+            });
+            return;
+        }
+        const principalKey = (0, transportUtils_1.buildPrincipalKey)(principal);
+        this.host.pendingBroadcasts.delete(principalKey);
+        this.host.pendingRenames.set(principalKey, { sessionId });
+        await ctx.answerCallbackQuery({
+            text: this.host.t(locale, "menu:settings.actions.rename_prompt"),
+        });
+        await this.host.replyText(ctx, ["✏ Rename session", "", this.host.t(locale, "menu:settings.actions.rename_body")].join("\n"), { kind: "menu", sessionId });
+    }
+    async pruneAllSessions(ctx) {
+        await ctx.answerCallbackQuery({ text: "Pruning all state..." });
+        let prunedGateway = false;
+        if (this.host.config.distributed.gatewayPublicUrl) {
+            try {
+                await this.host.callGatewayJson("/admin/prune-state", {});
+                prunedGateway = true;
+            }
+            catch (error) {
+                this.host.logger.warn("Gateway DB prune failed", {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        const result = await this.host.maintenanceStore.pruneAll();
+        this.host.clearPendingInteractionsForContext(ctx);
+        this.host.clearTerminalNudgeDebounceTimers();
+        await this.host.showSessionsMenu(ctx, `Prune complete. Deleted ${result.deletedKeys} Redis keys.${prunedGateway ? " Gateway DB cleared." : ""}`);
+    }
+    async handlePendingRename(ctx, text) {
+        const principal = this.host.getPrincipalFromContext(ctx);
+        if (!principal) {
+            return false;
+        }
+        const pending = this.host.pendingRenames.get((0, transportUtils_1.buildPrincipalKey)(principal));
+        if (!pending) {
+            return false;
+        }
+        if (text.startsWith("/")) {
+            this.host.pendingRenames.delete((0, transportUtils_1.buildPrincipalKey)(principal));
+            return false;
+        }
+        const session = await this.host.sessionStore.getSession(pending.sessionId);
+        const updatedAt = new Date().toISOString();
+        const label = (0, redactSecrets_1.redactSecrets)(text);
+        await this.host.sessionStore.setSession({
+            sessionId: pending.sessionId,
+            label,
+            ...(session?.cwd ? { cwd: session.cwd } : {}),
+            ...(session?.task ? { task: session.task } : {}),
+            ...(session?.summary ? { summary: session.summary } : {}),
+            ...(session?.files ? { files: session.files } : {}),
+            ...(session?.decisions ? { decisions: session.decisions } : {}),
+            ...(session?.risks ? { risks: session.risks } : {}),
+            ...(session?.terminalTarget ? { terminalTarget: session.terminalTarget } : {}),
+            ...(session?.lastTerminalNudgeAt
+                ? { lastTerminalNudgeAt: session.lastTerminalNudgeAt }
+                : {}),
+            updatedAt,
+        });
+        this.host.pendingRenames.delete((0, transportUtils_1.buildPrincipalKey)(principal));
+        this.host.logger.info("Telegram session renamed from menu", {
+            sessionId: pending.sessionId,
+            sessionLabel: label,
+            chatId: ctx.chat?.id,
+            userId: ctx.from?.id,
+        });
+        await this.host.replyText(ctx, `Session renamed: ${label}`, { kind: "menu", sessionId: pending.sessionId }, {
+            reply_markup: this.host.getMainMenu(),
+        });
+        return true;
+    }
+}
+exports.TransportSessionActions = TransportSessionActions;