@deadragdoll/tellymcp 0.0.11 → 0.0.12

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) {

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

@@ -25,9 +25,35 @@ class TransportTerminalRuntime {
     }
     startPromptScan() {
         if (!this.host.config.terminal.promptScanEnabled) {
+            this.host.logger.debug("terminal prompt scan disabled", {
+                promptScanEnabled: this.host.config.terminal.promptScanEnabled,
+            });
+            return;
+        }
+        if (this.host.config.distributed.mode === "gateway") {
+            this.host.logger.info("terminal prompt scan armed for live clients", {
+                intervalSeconds: this.host.config.terminal.promptScanIntervalSeconds,
+                cooldownSeconds: this.host.config.terminal.promptScanCooldownSeconds,
+                strategy: this.host.config.terminal.promptScanStrategy,
+                minScore: this.host.config.terminal.promptScanMinScore,
+            });
+            return;
+        }
+        this.ensurePromptScanRunning();
+    }
+    clearTerminalPromptScanTimer() {
+        if (this.terminalPromptScanTimer) {
+            clearInterval(this.terminalPromptScanTimer);
+            this.terminalPromptScanTimer = undefined;
+        }
+    }
+    ensurePromptScanRunning() {
+        if (!this.host.config.terminal.promptScanEnabled) {
+            return;
+        }
+        if (this.terminalPromptScanTimer) {
             return;
         }
-        this.clearTerminalPromptScanTimer();
         const intervalMs = this.host.config.terminal.promptScanIntervalSeconds * 1000;
         const timer = setInterval(() => {
             void this.runTerminalPromptScanCycle().catch((error) => {
@@ -54,11 +80,12 @@ class TransportTerminalRuntime {
             });
         });
     }
-    clearTerminalPromptScanTimer() {
-        if (this.terminalPromptScanTimer) {
-            clearInterval(this.terminalPromptScanTimer);
-            this.terminalPromptScanTimer = undefined;
+    pausePromptScan() {
+        if (!this.terminalPromptScanTimer) {
+            return;
         }
+        this.clearTerminalPromptScanTimer();
+        this.host.logger.info("terminal prompt scan paused", {});
     }
     scheduleTerminalNudgeForInboxMessage(sessionId, session) {
         if (!this.host.config.terminal.nudgeEnabled) {
@@ -153,15 +180,43 @@ class TransportTerminalRuntime {
         }
     }
     async runTerminalPromptScanCycle() {
-        if (!this.host.config.terminal.promptScanEnabled || this.terminalPromptScanInFlight) {
+        if (!this.host.config.terminal.promptScanEnabled) {
+            this.host.logger.debug("terminal prompt scan cycle skipped", {
+                skipReason: "disabled",
+            });
+            return;
+        }
+        if (this.terminalPromptScanInFlight) {
+            this.host.logger.debug("terminal prompt scan cycle skipped", {
+                skipReason: "in_flight",
+            });
             return;
         }
         this.terminalPromptScanInFlight = true;
         try {
+            if (this.host.ensureGatewayScopedConsolesBoundForPrincipal) {
+                const principals = await this.host.bindingStore.listBoundPrincipals();
+                this.host.logger.debug("terminal prompt scan syncing bound gateway principals", {
+                    principalCount: principals.length,
+                });
+                for (const principal of principals) {
+                    await this.host.ensureGatewayScopedConsolesBoundForPrincipal(principal);
+                }
+            }
             const sessions = await this.host.sessionStore.listSessions();
+            this.host.logger.debug("terminal prompt scan cycle started", {
+                sessionCount: sessions.length,
+            });
+            if (sessions.length === 0) {
+                this.host.logger.debug("terminal prompt scan cycle found no sessions");
+                return;
+            }
             for (const session of sessions) {
                 await this.actions.scanPromptForSession(session);
             }
+            this.host.logger.debug("terminal prompt scan cycle completed", {
+                sessionCount: sessions.length,
+            });
         }
         finally {
             this.terminalPromptScanInFlight = false;