@deadragdoll/tellymcp 0.0.9 → 0.0.11

package/dist/services/features/telegram-mcp/src/app/http.js

@@ -1,18 +1,30 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMcpHttpHandler = createMcpHttpHandler;
 const node_crypto_1 = require("node:crypto");
 const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const ws_1 = __importDefault(require("ws"));
 const auth_1 = require("./webapp/auth");
 const relay_1 = require("./webapp/relay");
 const assets_1 = require("./webapp/assets");
-const tmux_1 = require("./webapp/tmux");
-function formatTmuxHttpError(error, fallback) {
-    if ((0, tmux_1.isTmuxUnavailableError)(error)) {
-        return "tmux is unavailable";
+const client_1 = require("../shared/integrations/terminal/client");
+const terminal_1 = require("./webapp/terminal");
+function formatTerminalHttpError(error, fallback) {
+    if ((0, terminal_1.isTerminalUnavailableError)(error)) {
+        return "terminal runtime is unavailable";
     }
     return fallback;
 }
+function requireTelegramBotToken(runtime, purpose) {
+    const token = runtime.config.telegram.botToken?.trim();
+    if (!token) {
+        throw new Error(`Telegram bot token is unavailable on this node; cannot ${purpose}.`);
+    }
+    return token;
+}
 function isInitializeRequest(body) {
     if (!body || typeof body !== "object") {
         return false;
@@ -117,22 +129,233 @@ function normalizeBasePath(value) {
     }
     return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
 }
-function isRelayTmuxUnavailableMessage(error) {
+function readWebhookSecretHeader(req) {
+    const value = req.headers["x-telegram-bot-api-secret-token"];
+    if (Array.isArray(value)) {
+        return value[0];
+    }
+    return value;
+}
+function isRelayTerminalUnavailableMessage(error) {
     const text = error instanceof Error ? error.message : String(error);
-    return text.includes("tmux is unavailable");
+    return text.includes("terminal runtime is unavailable");
 }
 function createMcpHttpHandler(runtime, input) {
     const transports = new Map();
     const webAppSessions = new auth_1.WebAppSessionRegistry();
+    const liveWsServer = new WebSocketServer({ noServer: true });
     const webAppBasePath = runtime.config.webapp.basePath.replace(/\/+$/u, "") || "/webapp";
     const rootPrefix = normalizeBasePath(process.env.ROOT_PREFIX || "/api");
     const publicWebAppBasePath = rootPrefix === "/"
         ? webAppBasePath
         : `${rootPrefix}${normalizeBasePath(webAppBasePath)}`;
+    const publicLiveWsPath = rootPrefix === "/" ? "/gateway/live/ws" : `${rootPrefix}/gateway/live/ws`;
     const webAppLivePrefix = `${webAppBasePath}/live/`;
+    const telegramWebhookPath = runtime.config.telegram.webhook.path.replace(/\/+$/u, "") ||
+        "/telegram/webhook";
     const closeSessionEntry = async (entry) => {
         await entry.close();
     };
+    const resolveAuthorizedWebAppSession = async (token) => {
+        const webAppSession = token ? webAppSessions.get(token) : null;
+        if (!webAppSession) {
+            return null;
+        }
+        const relayTarget = (0, relay_1.parseLiveRelaySessionId)(webAppSession.sessionId);
+        if (relayTarget) {
+            return {
+                webAppSession,
+                relayTarget,
+                session: null,
+            };
+        }
+        const binding = await runtime.bindingStore.getBinding(webAppSession.sessionId);
+        if (!binding || binding.telegramUserId !== webAppSession.telegramUserId) {
+            return null;
+        }
+        const session = await runtime.sessionStore.getSession(webAppSession.sessionId);
+        if (!session?.terminalTarget) {
+            return null;
+        }
+        return {
+            webAppSession,
+            relayTarget: null,
+            session,
+        };
+    };
+    liveWsServer.on("connection", (socket, req) => {
+        const requestUrl = new URL(req.url ?? "/", "http://gateway.local");
+        const token = requestUrl.searchParams.get("token")?.trim() ?? "";
+        void (async () => {
+            const resolved = await resolveAuthorizedWebAppSession(token);
+            if (!resolved) {
+                socket.close(1008, "Unauthorized");
+                return;
+            }
+            let closed = false;
+            let relayStreamClose = null;
+            let localUnsubscribe = null;
+            const cleanup = async () => {
+                if (closed) {
+                    return;
+                }
+                closed = true;
+                try {
+                    localUnsubscribe?.();
+                }
+                catch {
+                    // ignore cleanup errors during socket shutdown
+                }
+                localUnsubscribe = null;
+                if (relayStreamClose) {
+                    await relayStreamClose().catch(() => undefined);
+                    relayStreamClose = null;
+                }
+            };
+            const sendJson = (payload) => {
+                if (socket.readyState === 1) {
+                    socket.send(JSON.stringify(payload));
+                }
+            };
+            socket.on("close", () => {
+                void cleanup();
+            });
+            socket.on("message", (raw) => {
+                void (async () => {
+                    const parsed = raw && typeof raw === "string"
+                        ? JSON.parse(raw)
+                        : JSON.parse(String(raw));
+                    const type = parsed && typeof parsed === "object" && typeof parsed.type === "string"
+                        ? parsed.type
+                        : "";
+                    if (type === "input") {
+                        const data = typeof parsed.data === "string" ? parsed.data : "";
+                        if (!data) {
+                            return;
+                        }
+                        if (resolved.relayTarget) {
+                            const gatewaySocketService = input.getGatewaySocketService?.();
+                            await gatewaySocketService?.requestLiveRelay?.({
+                                clientUuid: resolved.relayTarget.clientUuid,
+                                localSessionId: resolved.relayTarget.localSessionId,
+                                requestType: "action",
+                                payload: {
+                                    action: "text",
+                                    text: data,
+                                },
+                            });
+                            return;
+                        }
+                        if (resolved.session?.terminalTarget && (0, client_1.isStreamableTerminalTarget)(resolved.session.terminalTarget)) {
+                            (0, client_1.sendForegroundTerminalInput)(resolved.session.terminalTarget, data);
+                        }
+                        return;
+                    }
+                    if (type === "action") {
+                        const action = typeof parsed.action === "string" ? parsed.action : "";
+                        if (![
+                            "up",
+                            "down",
+                            "enter",
+                            "slash",
+                            "delete",
+                            "tab",
+                            "escape",
+                            "interrupt",
+                        ].includes(action)) {
+                            return;
+                        }
+                        if (resolved.relayTarget) {
+                            const gatewaySocketService = input.getGatewaySocketService?.();
+                            await gatewaySocketService?.requestLiveRelay?.({
+                                clientUuid: resolved.relayTarget.clientUuid,
+                                localSessionId: resolved.relayTarget.localSessionId,
+                                requestType: "action",
+                                payload: { action },
+                            });
+                            return;
+                        }
+                        if (resolved.session?.terminalTarget) {
+                            await (0, terminal_1.sendAllowedTerminalAction)(runtime.config.terminal, resolved.session.terminalTarget, action);
+                        }
+                        return;
+                    }
+                    if (type === "resize") {
+                        const cols = typeof parsed.cols === "number" ? parsed.cols : NaN;
+                        const rows = typeof parsed.rows === "number" ? parsed.rows : NaN;
+                        if (!Number.isFinite(cols) || !Number.isFinite(rows)) {
+                            return;
+                        }
+                        if (resolved.session?.terminalTarget && (0, client_1.isStreamableTerminalTarget)(resolved.session.terminalTarget)) {
+                            (0, client_1.resizeForegroundTerminal)(resolved.session.terminalTarget, Math.max(20, Math.min(400, Math.round(cols))), Math.max(5, Math.min(200, Math.round(rows))));
+                        }
+                    }
+                })().catch((error) => {
+                    runtime.logger.warn("Telegram WebApp live WS message handling failed", {
+                        error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                    });
+                });
+            });
+            if (resolved.relayTarget) {
+                const gatewaySocketService = input.getGatewaySocketService?.();
+                if (!gatewaySocketService?.openLiveRelayStream) {
+                    socket.close(1011, "Relay live stream is unavailable");
+                    return;
+                }
+                const relayStream = await gatewaySocketService.openLiveRelayStream({
+                    clientUuid: resolved.relayTarget.clientUuid,
+                    localSessionId: resolved.relayTarget.localSessionId,
+                    onEvent: (event) => {
+                        sendJson({
+                            type: event.event,
+                            ...event.payload,
+                        });
+                    },
+                });
+                relayStreamClose = relayStream.close;
+                sendJson({ type: "ready", mode: "stream" });
+                return;
+            }
+            if (!resolved.session?.terminalTarget ||
+                !(0, client_1.isStreamableTerminalTarget)(resolved.session.terminalTarget)) {
+                socket.close(1011, "Local live stream is not supported for this terminal");
+                return;
+            }
+            const terminalSize = await (0, terminal_1.getTerminalWindowSize)(runtime.config.terminal, resolved.session.terminalTarget);
+            const content = await (0, terminal_1.captureVisibleTerminal)(runtime.config.terminal, resolved.session.terminalTarget, runtime.config.terminal.captureLines, runtime.config.webapp.visibleScreens);
+            const ansi = await (0, terminal_1.captureVisibleTerminalAnsi)(runtime.config.terminal, resolved.session.terminalTarget, runtime.config.terminal.captureLines, runtime.config.webapp.visibleScreens);
+            sendJson({
+                type: "snapshot",
+                session_id: resolved.session.sessionId,
+                session_label: resolved.session.label ?? null,
+                captured_at: new Date().toISOString(),
+                content,
+                ansi,
+                ...(terminalSize ? terminalSize : {}),
+            });
+            localUnsubscribe = (0, client_1.subscribeForegroundTerminal)(resolved.session.terminalTarget, {
+                onData: (data) => {
+                    sendJson({
+                        type: "data",
+                        data,
+                    });
+                },
+                onExit: (info) => {
+                    sendJson({
+                        type: "exit",
+                        exitCode: typeof info.exitCode === "number" ? info.exitCode : null,
+                        signal: typeof info.signal === "number" ? info.signal : null,
+                    });
+                },
+            });
+            sendJson({ type: "ready", mode: "stream" });
+        })().catch((error) => {
+            runtime.logger.warn("Telegram WebApp live WS bootstrap failed", {
+                error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+            });
+            socket.close(1011, "Live stream bootstrap failed");
+        });
+    });
     const handleRequest = async (req, res, pathname) => {
         const method = req.method ?? "GET";
         const normalizedPathname = normalizePrefixedPathname(pathname);
@@ -146,6 +369,49 @@ function createMcpHttpHandler(runtime, input) {
             });
             return;
         }
+        if (runtime.config.telegram.webhook.enabled &&
+            requestUrl.pathname === telegramWebhookPath) {
+            if (method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return;
+            }
+            const expectedSecret = runtime.config.telegram.webhook.secret?.trim();
+            const receivedSecret = readWebhookSecretHeader(req)?.trim();
+            if (!expectedSecret || receivedSecret !== expectedSecret) {
+                writeText(res, 401, "Unauthorized");
+                return;
+            }
+            const body = await readJsonBody(req);
+            if (!body || typeof body !== "object") {
+                writeText(res, 400, "Telegram update body is required");
+                return;
+            }
+            if (runtime.config.telegram.webhook.trace) {
+                runtime.logger.warn("Telegram webhook update received", {
+                    path: requestUrl.pathname,
+                    body,
+                });
+            }
+            else {
+                runtime.logger.info("Telegram webhook update received", {
+                    path: requestUrl.pathname,
+                    method,
+                });
+            }
+            try {
+                await runtime.telegramTransport.handleWebhookUpdate(body);
+                writeText(res, 200, "OK");
+            }
+            catch (error) {
+                runtime.logger.error("Telegram webhook update handling failed", {
+                    error: error instanceof Error
+                        ? (error.stack ?? error.message)
+                        : String(error),
+                });
+                writeText(res, 500, error instanceof Error ? error.message : "Webhook handling failed");
+            }
+            return;
+        }
         if (await runtime.gatewayHttpService.handleRequest(req, res, requestUrl.pathname)) {
             return;
         }
@@ -161,6 +427,7 @@ function createMcpHttpHandler(runtime, input) {
                     runtime.config.webapp.launchMode;
                 writeHtml(res, 200, (0, assets_1.renderWebAppHtml)({
                     basePath: publicWebAppBasePath,
+                    liveWsPath: publicLiveWsPath,
                     launchMode,
                 }));
                 return;
@@ -215,6 +482,7 @@ function createMcpHttpHandler(runtime, input) {
                 if (relayTarget) {
                     try {
                         let trustedTelegramUserId = null;
+                        let launchRecord = null;
                         if (relayTarget.sourceClientUuid &&
                             relayTarget.sourceClientUuid !== relayTarget.clientUuid) {
                             const validation = await runtime.gatewayHttpService.requestLiveRelayBootstrapValidation({
@@ -226,9 +494,9 @@ function createMcpHttpHandler(runtime, input) {
                         }
                         else {
                             try {
-                                const validated = (0, auth_1.validateTelegramWebAppInitData)(initDataRaw, initDataUnsafe, runtime.config.telegram.botToken, runtime.config.webapp.initDataTtlSeconds);
+                                const validated = (0, auth_1.validateTelegramWebAppInitData)(initDataRaw, initDataUnsafe, requireTelegramBotToken(runtime, "validate local Telegram WebApp bootstrap"), runtime.config.webapp.initDataTtlSeconds);
                                 trustedTelegramUserId = validated.user.id;
-                                runtime.webAppLaunchRegistry.deleteByUserId(validated.user.id);
+                                launchRecord = runtime.webAppLaunchRegistry.getByUserId(validated.user.id);
                             }
                             catch {
                                 trustedTelegramUserId = null;
@@ -240,22 +508,51 @@ function createMcpHttpHandler(runtime, input) {
                             ...(trustedTelegramUserId !== null
                                 ? { telegramUserId: trustedTelegramUserId }
                                 : {}),
-                            ...(relayTarget.sourceClientUuid &&
-                                relayTarget.sourceClientUuid !== relayTarget.clientUuid
-                                ? { allowForeignBinding: true }
-                                : {}),
+                            // Relay sessions are already gateway-bound to a Telegram principal.
+                            // Do not rely on the per-user launch registry here because it can be
+                            // overwritten by other menu interactions before the WebApp opens.
+                            allowForeignBinding: true,
                             initDataRaw,
                             initDataUnsafe,
                         });
+                        runtime.logger.info("Telegram WebApp relay bootstrap forwarded", {
+                            sessionId,
+                            clientUuid: relayTarget.clientUuid,
+                            localSessionId: relayTarget.localSessionId,
+                            trustedTelegramUserId,
+                            hasLaunchRecord: launchRecord !== null,
+                            launchRecordAllowForeignBinding: launchRecord?.allowForeignBinding === true,
+                        });
                         const record = webAppSessions.create(sessionId, relayBootstrap.telegram_user_id, runtime.config.webapp.sessionTtlSeconds);
                         writeJson(res, 200, {
                             token: record.token,
                             session_id: relayBootstrap.session_id,
                             session_label: relayBootstrap.session_label,
-                            tmux_target: relayBootstrap.tmux_target,
+                            terminal_target: relayBootstrap.terminal_target,
                             poll_interval_ms: relayBootstrap.poll_interval_ms,
                             expires_at: new Date(record.expiresAtMs).toISOString(),
                         });
+                        if (trustedTelegramUserId !== null) {
+                            runtime.webAppLaunchRegistry.deleteByUserId(trustedTelegramUserId);
+                        }
+                        if (launchRecord?.telegramChatId !== undefined &&
+                            launchRecord?.telegramMessageId !== undefined) {
+                            void runtime.telegramTransport
+                                .deleteMessage(launchRecord.telegramChatId, launchRecord.telegramMessageId)
+                                .catch((deleteError) => {
+                                runtime.logger.warn("Telegram WebApp relay launcher message deletion failed", {
+                                    sessionId,
+                                    clientUuid: relayTarget.clientUuid,
+                                    localSessionId: relayTarget.localSessionId,
+                                    telegramUserId: trustedTelegramUserId,
+                                    telegramChatId: launchRecord.telegramChatId,
+                                    telegramMessageId: launchRecord.telegramMessageId,
+                                    error: deleteError instanceof Error
+                                        ? (deleteError.stack ?? deleteError.message)
+                                        : String(deleteError),
+                                });
+                            });
+                        }
                     }
                     catch (error) {
                         runtime.logger.warn("Telegram WebApp relay bootstrap rejected", {
@@ -271,7 +568,7 @@ function createMcpHttpHandler(runtime, input) {
                     return;
                 }
                 try {
-                    const validated = (0, auth_1.validateTelegramWebAppInitData)(initDataRaw, initDataUnsafe, runtime.config.telegram.botToken, runtime.config.webapp.initDataTtlSeconds);
+                    const validated = (0, auth_1.validateTelegramWebAppInitData)(initDataRaw, initDataUnsafe, requireTelegramBotToken(runtime, "validate Telegram WebApp bootstrap"), runtime.config.webapp.initDataTtlSeconds);
                     runtime.logger.info("Telegram WebApp initData validation debug", {
                         sessionId: sessionId || null,
                         telegramUserId: validated.user.id,
@@ -310,14 +607,14 @@ function createMcpHttpHandler(runtime, input) {
                     runtime.logger.info("Telegram WebApp session bootstrapped", {
                         sessionId,
                         telegramUserId: validated.user.id,
-                        hasTmuxTarget: Boolean(session?.tmuxTarget),
+                        hasTerminalTarget: Boolean(session?.terminalTarget),
                     });
                     runtime.webAppLaunchRegistry.deleteByUserId(validated.user.id);
                     writeJson(res, 200, {
                         token: record.token,
                         session_id: sessionId,
                         session_label: session?.label ?? null,
-                        tmux_target: Boolean(session?.tmuxTarget),
+                        terminal_target: Boolean(session?.terminalTarget),
                         poll_interval_ms: runtime.config.webapp.pollIntervalMs,
                         expires_at: new Date(record.expiresAtMs).toISOString(),
                     });
@@ -383,7 +680,7 @@ function createMcpHttpHandler(runtime, input) {
                                 ? (error.stack ?? error.message)
                                 : String(error),
                         });
-                        writeText(res, isRelayTmuxUnavailableMessage(error) ? 503 : 500, error instanceof Error ? error.message : "Failed to capture relay tmux pane");
+                        writeText(res, isRelayTerminalUnavailableMessage(error) ? 503 : 500, error instanceof Error ? error.message : "Failed to capture relay terminal buffer");
                     }
                     return;
                 }
@@ -394,17 +691,21 @@ function createMcpHttpHandler(runtime, input) {
                     return;
                 }
                 const session = await runtime.sessionStore.getSession(webAppSession.sessionId);
-                if (!session?.tmuxTarget) {
-                    writeText(res, 409, "tmux target is not configured for this session");
+                if (!session?.terminalTarget) {
+                    writeText(res, 409, "terminal target is not configured for this session");
                     return;
                 }
                 try {
-                    const content = await (0, tmux_1.captureVisibleTmuxPane)(runtime.config.tmux, session.tmuxTarget, runtime.config.tmux.captureLines, runtime.config.webapp.visibleScreens);
+                    const terminalSize = await (0, terminal_1.getTerminalWindowSize)(runtime.config.terminal, session.terminalTarget);
+                    const content = await (0, terminal_1.captureVisibleTerminal)(runtime.config.terminal, session.terminalTarget, runtime.config.terminal.captureLines, runtime.config.webapp.visibleScreens);
+                    const ansi = await (0, terminal_1.captureVisibleTerminalAnsi)(runtime.config.terminal, session.terminalTarget, runtime.config.terminal.captureLines, runtime.config.webapp.visibleScreens);
                     writeJson(res, 200, {
                         session_id: session.sessionId,
                         session_label: session.label ?? null,
                         captured_at: new Date().toISOString(),
                         content,
+                        ansi,
+                        ...(terminalSize ? terminalSize : {}),
                     });
                 }
                 catch (error) {
@@ -414,7 +715,7 @@ function createMcpHttpHandler(runtime, input) {
                             ? (error.stack ?? error.message)
                             : String(error),
                     });
-                    writeText(res, (0, tmux_1.isTmuxUnavailableError)(error) ? 503 : 500, formatTmuxHttpError(error, "Failed to capture visible tmux pane"));
+                    writeText(res, (0, terminal_1.isTerminalUnavailableError)(error) ? 503 : 500, formatTerminalHttpError(error, "Failed to capture visible terminal buffer"));
                 }
                 return;
             }
@@ -478,7 +779,7 @@ function createMcpHttpHandler(runtime, input) {
                                 ? (error.stack ?? error.message)
                                 : String(error),
                         });
-                        writeText(res, isRelayTmuxUnavailableMessage(error) ? 503 : 500, error instanceof Error ? error.message : "Failed to send relay tmux action");
+                        writeText(res, isRelayTerminalUnavailableMessage(error) ? 503 : 500, error instanceof Error ? error.message : "Failed to send relay terminal action");
                     }
                     return;
                 }
@@ -489,19 +790,19 @@ function createMcpHttpHandler(runtime, input) {
                     return;
                 }
                 const session = await runtime.sessionStore.getSession(webAppSession.sessionId);
-                if (!session?.tmuxTarget) {
-                    writeText(res, 409, "tmux target is not configured for this session");
+                if (!session?.terminalTarget) {
+                    writeText(res, 409, "terminal target is not configured for this session");
                     return;
                 }
                 try {
                     if (action === "text") {
-                        await (0, tmux_1.sendTmuxLiteralText)(runtime.config.tmux, session.tmuxTarget, text);
+                        await (0, terminal_1.sendTerminalLiteralText)(runtime.config.terminal, session.terminalTarget, text);
                     }
                     else {
-                        await (0, tmux_1.sendAllowedTmuxAction)(runtime.config.tmux, session.tmuxTarget, action);
+                        await (0, terminal_1.sendAllowedTerminalAction)(runtime.config.terminal, session.terminalTarget, action);
                     }
                     webAppSessions.touchAction(webAppSession.token, nowMs);
-                    runtime.logger.info("Telegram WebApp action sent to tmux", {
+                    runtime.logger.info("Telegram WebApp action sent to terminal", {
                         sessionId: webAppSession.sessionId,
                         telegramUserId: webAppSession.telegramUserId,
                         action,
@@ -520,7 +821,7 @@ function createMcpHttpHandler(runtime, input) {
                             ? (error.stack ?? error.message)
                             : String(error),
                     });
-                    writeText(res, (0, tmux_1.isTmuxUnavailableError)(error) ? 503 : 500, formatTmuxHttpError(error, "Failed to send tmux action"));
+                    writeText(res, (0, terminal_1.isTerminalUnavailableError)(error) ? 503 : 500, formatTerminalHttpError(error, "Failed to send terminal action"));
                 }
                 return;
             }
@@ -548,12 +849,10 @@ function createMcpHttpHandler(runtime, input) {
                 .sort((left, right) => left.sessionId.localeCompare(right.sessionId))
                 .map(async (session) => {
                 const binding = await runtime.bindingStore.getBinding(session.sessionId);
-                const inboxCount = await runtime.inboxStore.countInboxMessages(session.sessionId);
                 return {
                     session_id: session.sessionId,
                     session_label: session.label ?? null,
                     updated_at: session.updatedAt,
-                    inbox_count: inboxCount,
                     binding: binding
                         ? {
                             telegram_chat_id: binding.telegramChatId,
@@ -561,18 +860,9 @@ function createMcpHttpHandler(runtime, input) {
                             linked_at: binding.linkedAt,
                         }
                         : null,
-                    tmux: {
-                        tmux_session_name: session.tmuxSessionName ?? null,
-                        tmux_window_name: session.tmuxWindowName ?? null,
-                        tmux_window_index: typeof session.tmuxWindowIndex === "number"
-                            ? session.tmuxWindowIndex
-                            : null,
-                        tmux_pane_id: session.tmuxPaneId ?? null,
-                        tmux_pane_index: typeof session.tmuxPaneIndex === "number"
-                            ? session.tmuxPaneIndex
-                            : null,
-                        tmux_target: session.tmuxTarget ?? null,
-                        last_nudge_at: session.lastTmuxNudgeAt ?? null,
+                    terminal: {
+                        terminal_target: session.terminalTarget ?? null,
+                        last_nudge_at: session.lastTerminalNudgeAt ?? null,
                     },
                 };
             }));
@@ -601,13 +891,33 @@ function createMcpHttpHandler(runtime, input) {
                 return;
             }
             const result = await runtime.maintenanceStore.pruneAll();
+            let gatewayDeleted = null;
+            if (runtime.config.distributed.mode === "gateway" ||
+                runtime.config.distributed.mode === "both") {
+                try {
+                    const gatewayResult = await runtime.callBroker("telegramMcp.gateway.pruneGatewayState", {}, {
+                        meta: { internal_call: true },
+                    });
+                    gatewayDeleted =
+                        gatewayResult?.deleted && typeof gatewayResult.deleted === "object"
+                            ? gatewayResult.deleted
+                            : null;
+                }
+                catch (error) {
+                    runtime.logger.warn("Gateway DB prune failed through HTTP endpoint", {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
             runtime.logger.warn("MCP service state pruned through HTTP endpoint", {
                 deletedKeys: result.deletedKeys,
+                gatewayDeleted,
                 remoteAddress: req.socket.remoteAddress,
             });
             writeJson(res, 200, {
                 ok: true,
                 deleted_keys: result.deletedKeys,
+                ...(gatewayDeleted ? { gateway_deleted: gatewayDeleted } : {}),
             });
             return;
         }
@@ -781,6 +1091,17 @@ function createMcpHttpHandler(runtime, input) {
         }
     };
     let shuttingDown = false;
+    const handleUpgrade = async (req, socket, head, pathname) => {
+        const normalizedPathname = normalizePrefixedPathname(pathname);
+        if (normalizedPathname !== `${webAppBasePath}/api/live/ws` &&
+            normalizedPathname !== "/gateway/live/ws") {
+            return false;
+        }
+        liveWsServer.handleUpgrade(req, socket, head, (clientSocket) => {
+            liveWsServer.emit("connection", clientSocket, req);
+        });
+        return true;
+    };
     const shutdown = async () => {
         if (shuttingDown) {
             return;
@@ -789,9 +1110,21 @@ function createMcpHttpHandler(runtime, input) {
         runtime.logger.info("MCP HTTP handler shutdown requested");
         await Promise.all(Array.from(transports.values()).map((entry) => closeSessionEntry(entry)));
         transports.clear();
+        await new Promise((resolve, reject) => {
+            liveWsServer.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
     };
     return {
         handleRequest,
+        handleUpgrade,
         close: shutdown,
     };
 }
+const wsLib = ws_1.default;
+const WebSocketServer = wsLib.WebSocketServer;