@deadragdoll/tellymcp 0.0.11 → 0.0.13

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

@@ -26,6 +26,9 @@ function principalActiveSessionKey(principal) {
 function principalActiveSessionMatchPattern(telegramUserId) {
     return `${KEY_PREFIX}:principal:*:${telegramUserId}:active-session`;
 }
+function bindingMatchPattern() {
+    return `${KEY_PREFIX}:binding:*`;
+}
 function menuPayloadKey(key) {
     return `${KEY_PREFIX}:menu-payload:${key}`;
 }
@@ -41,6 +44,12 @@ function adminAuthorizedMatchPattern() {
 function gatewayClientUuidKey() {
     return `${KEY_PREFIX}:gateway:client-uuid`;
 }
+function browserAttachmentKey(sessionId) {
+    return `${KEY_PREFIX}:browser-attachment:${sessionId}`;
+}
+function browserRecordingKey(sessionId) {
+    return `${KEY_PREFIX}:browser-recording:${sessionId}`;
+}
 function outgoingDeliveryNoticeKey(deliveryUuid) {
     return `${KEY_PREFIX}:gateway:outgoing-delivery:${deliveryUuid}`;
 }
@@ -100,6 +109,8 @@ class RedisStateStore {
         await this.clearXchangeFileMetas(sessionId);
         await this.clearProjectMenuViewStates(sessionId);
         await this.clearOutgoingDeliveryNoticesForSession(sessionId);
+        await this.clearBrowserAttachment(sessionId);
+        await this.clearBrowserRecording(sessionId);
         await this.sessionAdapter.delete(sessionKey(sessionId));
     }
     async createPairCode(record, ttlSeconds) {
@@ -204,6 +215,31 @@ class RedisStateStore {
     async listBoundSessionIdsForPrincipal(principal) {
         return this.redis.smembers(principalSessionsKey(principal));
     }
+    async listBoundPrincipals() {
+        const principals = new Map();
+        let cursor = "0";
+        do {
+            const [nextCursor, keys] = await this.redis.scan(cursor, "MATCH", bindingMatchPattern(), "COUNT", 100);
+            cursor = nextCursor;
+            for (const key of keys) {
+                const raw = await this.redis.get(key);
+                const binding = parseJson(raw);
+                if (!binding) {
+                    continue;
+                }
+                const telegramChatId = Number(binding.telegramChatId);
+                const telegramUserId = Number(binding.telegramUserId);
+                if (!Number.isFinite(telegramChatId) || !Number.isFinite(telegramUserId)) {
+                    continue;
+                }
+                principals.set(`${telegramChatId}:${telegramUserId}`, {
+                    telegramChatId,
+                    telegramUserId,
+                });
+            }
+        } while (cursor !== "0");
+        return Array.from(principals.values());
+    }
     async resetRuntimeState() {
         await this.redis.del(activeRequestKey());
         await this.redis.del(queueKey());
@@ -312,6 +348,26 @@ class RedisStateStore {
     async setGatewayClientUuid(clientUuid) {
         await this.redis.set(gatewayClientUuidKey(), clientUuid);
     }
+    async getBrowserAttachment(sessionId) {
+        const raw = await this.redis.get(browserAttachmentKey(sessionId));
+        return parseJson(raw);
+    }
+    async setBrowserAttachment(record) {
+        await this.redis.set(browserAttachmentKey(record.sessionId), JSON.stringify(record));
+    }
+    async clearBrowserAttachment(sessionId) {
+        await this.redis.del(browserAttachmentKey(sessionId));
+    }
+    async getBrowserRecording(sessionId) {
+        const raw = await this.redis.get(browserRecordingKey(sessionId));
+        return parseJson(raw);
+    }
+    async setBrowserRecording(record) {
+        await this.redis.set(browserRecordingKey(record.sessionId), JSON.stringify(record));
+    }
+    async clearBrowserRecording(sessionId) {
+        await this.redis.del(browserRecordingKey(sessionId));
+    }
     async setProjectMenuViewState(state) {
         await this.redis.set(projectMenuViewStateKey(state.projectUuid, state.sessionId), JSON.stringify(state));
     }

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

@@ -43,6 +43,7 @@ class TelegramTransport {
     lifecycleActions;
     attachmentStore;
     broadcastActions;
+    consoleRegistry;
     context;
     documentActions;
     eventActions;
@@ -185,6 +186,7 @@ class TelegramTransport {
         this.lifecycleActions = composition.lifecycleActions;
         this.attachmentStore = composition.attachmentStore;
         this.broadcastActions = composition.broadcastActions;
+        this.consoleRegistry = composition.consoleRegistry;
         this.context = composition.context;
         this.documentActions = composition.documentActions;
         this.eventActions = composition.eventActions;
@@ -436,9 +438,44 @@ class TelegramTransport {
     async sendStartupNotifications() {
         await this.lifecycleActions.sendStartupNotifications(__dirname);
     }
+    ensurePromptScanRunning() {
+        this.terminalRuntime.ensurePromptScanRunning();
+    }
+    pausePromptScan() {
+        this.terminalRuntime.pausePromptScan();
+    }
     async sendAdminGatewayRegistrationNotifications(input) {
         await this.requestFlow.sendAdminGatewayRegistrationNotifications(input);
     }
+    async hydrateGatewayClientOwnerRoute(input) {
+        if (this.config.distributed.mode !== "gateway") {
+            return;
+        }
+        const route = await this.callGatewayJson("/user/route", {
+            client_uuid: input.clientUuid,
+            ...(input.gatewayUserUuid ? { gateway_user_uuid: input.gatewayUserUuid } : {}),
+        });
+        if (typeof route.telegram_user_id !== "number" ||
+            typeof route.telegram_chat_id !== "number") {
+            this.logger.debug("Skipping gateway owner route hydration because Telegram route is unavailable", {
+                clientUuid: input.clientUuid,
+                gatewayUserUuid: input.gatewayUserUuid ?? null,
+            });
+            return;
+        }
+        await this.consoleRegistry.ensureScopedConsolesBound({
+            principal: {
+                telegramChatId: route.telegram_chat_id,
+                telegramUserId: route.telegram_user_id,
+            },
+        });
+        this.logger.info("Gateway owner route hydrated for live client", {
+            clientUuid: input.clientUuid,
+            gatewayUserUuid: input.gatewayUserUuid ?? null,
+            telegramChatId: route.telegram_chat_id,
+            telegramUserId: route.telegram_user_id,
+        });
+    }
     async sendRequest(input) {
         return this.requestFlow.sendRequest(input);
     }

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

@@ -53,12 +53,18 @@ class TransportConsoleRegistry {
         for (const consoleSession of consoles) {
             const relaySessionId = (0, relay_1.buildLiveRelaySessionId)(consoleSession.client_uuid, consoleSession.local_session_id);
             relaySessionIds.push(relaySessionId);
-            await this.materializeRelaySession({
-                ctx: input.ctx,
-                principal: input.principal,
-                relaySessionId,
-                consoleSession,
-            });
+            await this.materializeRelaySession(input.ctx
+                ? {
+                    ctx: input.ctx,
+                    principal: input.principal,
+                    relaySessionId,
+                    consoleSession,
+                }
+                : {
+                    principal: input.principal,
+                    relaySessionId,
+                    consoleSession,
+                });
         }
         const existingActive = await this.host.bindingStore.getActiveSessionIdForPrincipal(input.principal);
         const nextBound = new Set(await this.host.bindingStore.listBoundSessionIdsForPrincipal(input.principal));
@@ -119,7 +125,7 @@ class TransportConsoleRegistry {
             sessionId: input.relaySessionId,
             telegramChatId: input.principal.telegramChatId,
             telegramUserId: input.principal.telegramUserId,
-            ...(input.ctx.from?.username
+            ...(input.ctx?.from?.username
                 ? { telegramUsername: input.ctx.from.username }
                 : {}),
             linkedAt: new Date().toISOString(),

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

@@ -92,6 +92,11 @@ function buildTransportConstructorWiring(host) {
         resolveLocaleForTelegramUserId: (userId) => context.resolveLocaleForTelegramUserId(userId),
         sendNotification: (input) => requestFlow.sendNotification(input),
         sendLiveViewLauncherMessage: (input) => liveActions.sendLauncherMessage(input),
+        callGatewayJson: (path, payload) => host.callGatewayJson(path, payload),
+        createTerminalPromptActionPayload: (sessionId, actions) => payloadState.createTerminalPromptActionPayload(sessionId, actions),
+        getMenuPayloadByKey: (key) => host.menuPayloadStore.getMenuPayload(key),
+        resolveLocaleForContext: (ctx) => context.resolveLocaleForContext(ctx),
+        sendChatMessage: (telegramChatId, text, options, meta) => outputActions.sendChatMessage(telegramChatId, text, options, meta),
         t: (locale, key, vars) => context.t(locale, key, vars),
     });
     const terminalRuntime = new transportTerminalRuntime_1.TransportTerminalRuntime({
@@ -103,6 +108,9 @@ function buildTransportConstructorWiring(host) {
         isTelegramEnabled: () => host.config.distributed.mode !== "client" && Boolean(host.config.telegram.botToken?.trim()),
         terminalActions,
         terminalNudgeDebounceTimers: host.terminalNudgeDebounceTimers,
+        ensureGatewayScopedConsolesBoundForPrincipal: async (principal) => {
+            await consoleRegistry.ensureScopedConsolesBound({ principal });
+        },
     });
     const menuFingerprints = new transportMenuFingerprints_1.TransportMenuFingerprints({
         logger: host.logger,
@@ -560,6 +568,7 @@ function buildTransportConstructorWiring(host) {
         handleProjectMemberNoteCallback: (ctx) => projectActions.handleProjectMemberNoteCallback(ctx),
         handleProjectMemberLiveCallback: (ctx) => projectActions.handleProjectMemberLiveCallback(ctx),
         handleLiveApprovalCallback: (ctx) => projectActions.handleLiveApprovalCallback(ctx),
+        handleTerminalPromptActionCallback: (ctx) => terminalActions.handlePromptActionCallback(ctx),
         handleProjectDetailCallback: (ctx) => projectActions.handleProjectDetailCallback(ctx),
         handleProjectDeleteCallback: (ctx) => projectActions.handleProjectDeleteCallback(ctx),
         handleProjectLeaveCallback: (ctx) => projectActions.handleProjectLeaveCallback(ctx),

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

@@ -41,6 +41,9 @@ class TransportMenuShell {
         bot.callbackQuery(/^live-approval:(approve|deny):(.+)$/u, async (ctx) => {
             await this.host.handleLiveApprovalCallback(ctx);
         });
+        bot.callbackQuery(/^terminal-prompt-action:(\d+|enter|escape):(.+)$/u, async (ctx) => {
+            await this.host.handleTerminalPromptActionCallback(ctx);
+        });
         bot.callbackQuery(/^project-detail:(.+)$/u, async (ctx) => {
             await this.host.handleProjectDetailCallback(ctx);
         });

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

@@ -77,6 +77,13 @@ class TransportPayloadState {
             ...(input.projectName ? { projectName: input.projectName } : {}),
         });
     }
+    async createTerminalPromptActionPayload(sessionId, actions) {
+        return this.createPayload({
+            kind: "terminal-prompt-action",
+            sessionId,
+            promptActions: actions,
+        });
+    }
     async createPartnerFileTargetPayload(sessionId, targetSessionId, title, filePath) {
         return this.createPayload({
             kind: "partner-file-target",

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

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransportTerminalActions = void 0;
+const grammy_1 = require("grammy");
 const client_1 = require("../terminal/client");
+const relay_1 = require("../../../app/webapp/relay");
 const terminalPromptDetection_1 = require("../../lib/terminalPromptDetection");
 const transportUtils_1 = require("./transportUtils");
 const TERMINAL_NUDGE_FAILURE_NOTICE_COOLDOWN_MS = 5 * 60 * 1000;
@@ -11,6 +13,74 @@ class TransportTerminalActions {
     constructor(host) {
         this.host = host;
     }
+    buildCapturePreview(capture) {
+        return capture
+            .split("\n")
+            .map((line) => line.trimEnd())
+            .filter((line) => line.trim().length > 0)
+            .slice(-6);
+    }
+    buildPromptActionTokens(detection) {
+        const actions = [];
+        const promptActions = detection.promptActions;
+        if (promptActions) {
+            actions.push(...promptActions.numberedOptions);
+            if (promptActions.hasEnter) {
+                actions.push("enter");
+            }
+            if (promptActions.hasEscape) {
+                actions.push("escape");
+            }
+        }
+        return Array.from(new Set(actions));
+    }
+    buildPromptActionKeyboard(payloadKey, actions) {
+        if (actions.length === 0) {
+            return null;
+        }
+        const keyboard = new grammy_1.InlineKeyboard();
+        for (const action of actions) {
+            const label = action === "enter"
+                ? "Enter"
+                : action === "escape"
+                    ? "Esc"
+                    : action;
+            keyboard.text(label, `terminal-prompt-action:${action}:${payloadKey}`);
+        }
+        return keyboard;
+    }
+    async sendPromptAction(sessionId, action) {
+        if (action === "enter" || action === "escape") {
+            await this.host.callGatewayJson("/live/action", {
+                session_id: sessionId,
+                action,
+            });
+            return;
+        }
+        await this.host.callGatewayJson("/live/action", {
+            session_id: sessionId,
+            action: "text",
+            text: action,
+        });
+    }
+    isExpectedRelayCaptureMiss(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return (/\bInvalid live relay view response\b/u.test(message) ||
+            /\bis not connected\b/u.test(message) ||
+            /\brequest is rejected\b/u.test(message) ||
+            /\brelay live capture did not return terminal content\b/u.test(message));
+    }
+    buildRelayTerminalTarget(sessionId) {
+        const relay = (0, relay_1.parseLiveRelaySessionId)(sessionId);
+        if (!relay) {
+            return null;
+        }
+        return `relay:${relay.clientUuid}/${relay.localSessionId}`;
+    }
+    extractTerminalTextFromGatewayMarkdown(markdownContent) {
+        const match = markdownContent.match(/```text\n([\s\S]*?)\n```/u);
+        return match?.[1] ?? markdownContent;
+    }
     async ensurePtyTargetForSession(sessionId, session) {
         const ensuredTarget = (0, client_1.ensureTerminalTargetForSession)(this.host.config.terminal, {
             sessionId,
@@ -243,17 +313,39 @@ class TransportTerminalActions {
         }
     }
     async scanPromptForSession(session) {
-        if (!session.terminalTarget) {
+        const relayTerminalTarget = this.buildRelayTerminalTarget(session.sessionId);
+        if (!session.terminalTarget && !relayTerminalTarget) {
+            this.host.logger.debug("terminal prompt scan skipped", {
+                sessionId: session.sessionId,
+                sessionLabel: session.label,
+                isRelaySession: relayTerminalTarget !== null,
+                skipReason: "no_terminal_target",
+            });
             this.host.terminalPromptNoticeState.delete(session.sessionId);
             return;
         }
         const binding = await this.host.bindingStore.getBinding(session.sessionId);
         if (!binding) {
+            this.host.logger.debug("terminal prompt scan skipped", {
+                sessionId: session.sessionId,
+                sessionLabel: session.label,
+                isRelaySession: relayTerminalTarget !== null,
+                terminalTarget: session.terminalTarget ?? relayTerminalTarget,
+                skipReason: "no_binding",
+            });
             this.host.terminalPromptNoticeState.delete(session.sessionId);
             return;
         }
-        let terminalTarget = session.terminalTarget;
+        let terminalTarget = session.terminalTarget ?? relayTerminalTarget;
         let capture;
+        this.host.logger.debug("terminal prompt scan started", {
+            sessionId: session.sessionId,
+            sessionLabel: session.label,
+            isRelaySession: relayTerminalTarget !== null,
+            terminalTarget,
+            strategy: this.host.config.terminal.promptScanStrategy,
+            minScore: this.host.config.terminal.promptScanMinScore,
+        });
         try {
             capture = await this.capturePromptBuffer(session);
         }
@@ -261,6 +353,7 @@ class TransportTerminalActions {
             if ((0, client_1.isTerminalUnavailableError)(error)) {
                 this.host.logger.debug("terminal prompt scan skipped because terminal is unavailable", {
                     sessionId: session.sessionId,
+                    sessionLabel: session.label,
                     terminalTarget,
                 });
                 return;
@@ -270,6 +363,7 @@ class TransportTerminalActions {
                 if (!recoveredTarget) {
                     this.host.logger.debug("terminal prompt scan skipped because target is invalid", {
                         sessionId: session.sessionId,
+                        sessionLabel: session.label,
                         terminalTarget,
                     });
                     return;
@@ -281,6 +375,19 @@ class TransportTerminalActions {
                 });
             }
             else {
+                if (relayTerminalTarget &&
+                    this.isExpectedRelayCaptureMiss(error)) {
+                    this.host.logger.debug("terminal prompt scan skipped because relay capture is unavailable", {
+                        sessionId: session.sessionId,
+                        sessionLabel: session.label,
+                        terminalTarget,
+                        error: error instanceof Error
+                            ? (error.stack ?? error.message)
+                            : String(error),
+                    });
+                    this.host.terminalPromptNoticeState.delete(session.sessionId);
+                    return;
+                }
                 this.host.logger.warn("terminal prompt scan capture failed", {
                     sessionId: session.sessionId,
                     terminalTarget,
@@ -291,6 +398,15 @@ class TransportTerminalActions {
                 return;
             }
         }
+        const capturePreview = this.buildCapturePreview(capture);
+        this.host.logger.debug("terminal prompt buffer captured", {
+            sessionId: session.sessionId,
+            sessionLabel: session.label,
+            terminalTarget,
+            captureChars: capture.length,
+            captureLines: capture.split("\n").length,
+            previewTail: capturePreview,
+        });
         const detection = (0, terminalPromptDetection_1.detectTerminalInteractivePrompt)(capture, {
             strategy: this.host.config.terminal.promptScanStrategy,
             minScore: this.host.config.terminal.promptScanMinScore,
@@ -298,9 +414,11 @@ class TransportTerminalActions {
         if (!detection) {
             this.host.logger.debug("terminal prompt scan found no interactive prompt", {
                 sessionId: session.sessionId,
+                sessionLabel: session.label,
                 terminalTarget,
                 strategy: this.host.config.terminal.promptScanStrategy,
                 minScore: this.host.config.terminal.promptScanMinScore,
+                previewTail: capturePreview,
             });
             this.host.terminalPromptNoticeState.delete(session.sessionId);
             return;
@@ -308,9 +426,35 @@ class TransportTerminalActions {
         if (!this.shouldSendPromptNotice(session.sessionId, detection)) {
             return;
         }
-        await this.notifyPromptDetected(session, binding, detection, terminalTarget);
+        await this.notifyPromptDetected(session, binding, detection, terminalTarget ?? relayTerminalTarget ?? "unknown");
     }
     async capturePromptBuffer(session) {
+        const relay = (0, relay_1.parseLiveRelaySessionId)(session.sessionId);
+        if (relay) {
+            this.host.logger.debug("terminal prompt relay capture requested", {
+                sessionId: session.sessionId,
+                clientUuid: relay.clientUuid,
+                localSessionId: relay.localSessionId,
+            });
+            const output = await this.host.callGatewayJson("/live/capture-buffer", {
+                session_id: session.sessionId,
+                scope: {
+                    mode: "visible",
+                },
+            });
+            const markdownContent = typeof output.markdown_content === "string"
+                ? output.markdown_content
+                : "";
+            if (!markdownContent.trim()) {
+                this.host.logger.warn("terminal prompt relay capture returned empty content", {
+                    sessionId: session.sessionId,
+                    clientUuid: relay.clientUuid,
+                    localSessionId: relay.localSessionId,
+                });
+                throw new Error("relay live capture did not return terminal content");
+            }
+            return this.extractTerminalTextFromGatewayMarkdown(markdownContent);
+        }
         const target = session.terminalTarget;
         if (!target) {
             throw new Error("terminal target is not configured");
@@ -322,23 +466,18 @@ class TransportTerminalActions {
     }
     shouldSendPromptNotice(sessionId, detection) {
         const existing = this.host.terminalPromptNoticeState.get(sessionId);
-        const nowMs = Date.now();
-        const cooldownMs = this.host.config.terminal.promptScanCooldownSeconds * 1000;
-        if (existing &&
-            existing.fingerprint === detection.fingerprint &&
-            nowMs - existing.sentAtMs < cooldownMs) {
-            this.host.logger.debug("terminal prompt detected but notification is on cooldown", {
+        if (existing && existing.fingerprint === detection.fingerprint) {
+            this.host.logger.debug("terminal prompt detected but fingerprint is unchanged", {
                 sessionId,
                 fingerprint: detection.fingerprint,
                 score: detection.score,
                 reasons: detection.reasons,
-                cooldownSeconds: this.host.config.terminal.promptScanCooldownSeconds,
             });
             return false;
         }
         this.host.terminalPromptNoticeState.set(sessionId, {
             fingerprint: detection.fingerprint,
-            sentAtMs: nowMs,
+            sentAtMs: Date.now(),
         });
         return true;
     }
@@ -348,30 +487,25 @@ class TransportTerminalActions {
         }
         const locale = await this.host.resolveLocaleForTelegramUserId(binding.telegramUserId);
         const sessionLabel = session.label ?? session.sessionId;
-        const excerpt = detection.matchedLines
-            .slice(-TERMINAL_PROMPT_SCAN_MATCHED_LINES_LIMIT)
-            .join("\n");
-        await this.host.sendNotification({
+        const excerpt = detection.excerpt
+            .split("\n")
+            .slice(-Math.max(TERMINAL_PROMPT_SCAN_MATCHED_LINES_LIMIT + 2, 8))
+            .join("\n") || detection.matchedLines.slice(-TERMINAL_PROMPT_SCAN_MATCHED_LINES_LIMIT).join("\n");
+        const promptActionTokens = this.buildPromptActionTokens(detection);
+        const payloadKey = promptActionTokens.length > 0
+            ? await this.host.createTerminalPromptActionPayload(session.sessionId, promptActionTokens)
+            : null;
+        const replyMarkup = payloadKey
+            ? this.buildPromptActionKeyboard(payloadKey, promptActionTokens)
+            : null;
+        await this.host.sendChatMessage(binding.telegramChatId, [
+            this.host.t(locale, "menu:notices.terminal.prompt_detected_title", {
+                sessionName: sessionLabel,
+            }),
+            excerpt,
+        ].join("\n"), replyMarkup ? { reply_markup: replyMarkup } : {}, {
+            kind: "notification",
             sessionId: session.sessionId,
-            sessionLabel: "TellyMCP",
-            recipient: {
-                telegramChatId: binding.telegramChatId,
-                telegramUserId: binding.telegramUserId,
-            },
-            message: [
-                this.host.t(locale, "menu:notices.terminal.prompt_detected_title", {
-                    sessionName: sessionLabel,
-                }),
-                this.host.t(locale, "menu:notices.terminal.prompt_detected_score", {
-                    score: detection.score,
-                }),
-                this.host.t(locale, "menu:notices.terminal.prompt_detected_target", {
-                    terminalTarget: terminalTarget,
-                }),
-                this.host.t(locale, "menu:notices.terminal.prompt_detected_hint"),
-                this.host.t(locale, "menu:notices.terminal.prompt_detected_excerpt"),
-                excerpt,
-            ].join("\n"),
         });
         try {
             await this.host.sendLiveViewLauncherMessage({
@@ -407,6 +541,69 @@ class TransportTerminalActions {
             excerpt,
         });
     }
+    async handlePromptActionCallback(ctx) {
+        const locale = await this.host.resolveLocaleForContext(ctx);
+        const data = ctx.callbackQuery?.data ?? "";
+        const match = data.match(/^terminal-prompt-action:(\d+|enter|escape):(.+)$/u);
+        if (!match) {
+            await ctx.answerCallbackQuery({
+                text: this.host.t(locale, "menu:notices.terminal.prompt_action_invalid"),
+                show_alert: true,
+            });
+            return;
+        }
+        const [, actionRaw, payloadKeyRaw] = match;
+        const payloadKey = payloadKeyRaw?.trim();
+        const action = actionRaw?.trim().toLowerCase();
+        if (!payloadKey || !action) {
+            await ctx.answerCallbackQuery({
+                text: this.host.t(locale, "menu:notices.terminal.prompt_action_invalid"),
+                show_alert: true,
+            });
+            return;
+        }
+        const payload = await this.host.getMenuPayloadByKey(payloadKey);
+        const storedActions = Array.isArray(payload?.promptActions)
+            ? payload.promptActions
+                .map((value) => (typeof value === "string" ? value.trim().toLowerCase() : ""))
+                .filter((value) => value.length > 0)
+            : [];
+        if (!payload ||
+            payload.kind !== "terminal-prompt-action" ||
+            !payload.sessionId ||
+            !storedActions.includes(action)) {
+            await ctx.answerCallbackQuery({
+                text: this.host.t(locale, "menu:notices.terminal.prompt_action_stale"),
+                show_alert: true,
+            });
+            return;
+        }
+        try {
+            await this.sendPromptAction(String(payload.sessionId), action);
+            await ctx.answerCallbackQuery({
+                text: this.host.t(locale, "menu:notices.terminal.prompt_action_sent", {
+                    action: action === "enter"
+                        ? "Enter"
+                        : action === "escape"
+                            ? "Esc"
+                            : action,
+                }),
+            });
+        }
+        catch (error) {
+            this.host.logger.warn("terminal prompt action callback failed", {
+                sessionId: String(payload.sessionId),
+                action,
+                error: error instanceof Error
+                    ? (error.stack ?? error.message)
+                    : String(error),
+            });
+            await ctx.answerCallbackQuery({
+                text: this.host.t(locale, "menu:notices.terminal.prompt_action_failed"),
+                show_alert: true,
+            });
+        }
+    }
     async captureBuffer(session, scope) {
         const target = session.terminalTarget;
         if (!target) {