@deadragdoll/tellymcp 0.0.10 → 0.0.12

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

@@ -0,0 +1,665 @@
+"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;
+const TERMINAL_PROMPT_SCAN_MATCHED_LINES_LIMIT = 6;
+class TransportTerminalActions {
+    host;
+    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,
+            ...(typeof session.cwd === "string" ? { cwd: session.cwd } : {}),
+            ...(typeof session.terminalTarget === "string"
+                ? { target: session.terminalTarget }
+                : {}),
+        });
+        if (!ensuredTarget) {
+            return null;
+        }
+        if (ensuredTarget === session.terminalTarget) {
+            return ensuredTarget;
+        }
+        await this.host.sessionStore.setSession({
+            ...session,
+            terminalTarget: ensuredTarget,
+            updatedAt: new Date().toISOString(),
+        });
+        this.host.logger.info("PTY terminal target normalized", {
+            sessionId,
+            previousTerminalTarget: session.terminalTarget,
+            normalizedTerminalTarget: ensuredTarget,
+        });
+        return ensuredTarget;
+    }
+    async nudgeForInboxMessage(sessionId) {
+        await this.nudgeForSession(sessionId, {
+            message: this.host.config.terminal.nudgeMessage,
+            reason: "human_message",
+        });
+    }
+    async nudgeForSession(sessionId, input) {
+        if (!this.host.config.terminal.nudgeEnabled) {
+            return;
+        }
+        const session = await this.host.sessionStore.getSession(sessionId);
+        if (!session?.terminalTarget) {
+            this.host.logger.debug("terminal nudge skipped", {
+                sessionId,
+                nudgeReason: input.reason,
+                skipReason: "no_terminal_target",
+            });
+            return;
+        }
+        let normalizedSession = session;
+        if (!session.terminalTarget.startsWith("pty:")) {
+            const normalizedTarget = await this.ensurePtyTargetForSession(sessionId, session);
+            if (normalizedTarget) {
+                normalizedSession = {
+                    ...session,
+                    terminalTarget: normalizedTarget,
+                };
+            }
+        }
+        const nowMs = Date.now();
+        if (!(0, transportUtils_1.shouldNudge)(session.lastTerminalNudgeAt, this.host.config.terminal.nudgeCooldownSeconds, nowMs)) {
+            this.host.logger.debug("terminal nudge skipped because of cooldown", {
+                sessionId,
+                reason: input.reason,
+                terminalTarget: normalizedSession.terminalTarget,
+                lastTerminalNudgeAt: normalizedSession.lastTerminalNudgeAt,
+            });
+            return;
+        }
+        await this.host.sendTypingForSession(sessionId);
+        let terminalTarget = normalizedSession.terminalTarget ?? null;
+        if (!terminalTarget) {
+            this.host.logger.debug("terminal nudge skipped", {
+                sessionId,
+                nudgeReason: input.reason,
+                skipReason: "normalized_target_missing",
+            });
+            return;
+        }
+        try {
+            await (0, client_1.sendTerminalLiteralLine)(this.host.config.terminal, terminalTarget, input.message);
+        }
+        catch (error) {
+            if ((0, client_1.isTerminalTargetInvalidError)(error) || (0, client_1.isTerminalUnavailableError)(error)) {
+                const recoveredTarget = await this.ensurePtyTargetForSession(sessionId, normalizedSession);
+                if (recoveredTarget) {
+                    terminalTarget = recoveredTarget;
+                    await (0, client_1.sendTerminalLiteralLine)(this.host.config.terminal, recoveredTarget, input.message);
+                }
+                else {
+                    await this.notifyTargetInvalid(sessionId, normalizedSession, error);
+                    throw error;
+                }
+            }
+            else {
+                throw error;
+            }
+        }
+        const lastTerminalNudgeAt = new Date(nowMs).toISOString();
+        await this.host.sessionStore.setSession({
+            ...normalizedSession,
+            terminalTarget: terminalTarget,
+            lastTerminalNudgeAt,
+        });
+        this.host.terminalNudgeFailureNoticeAt.delete(sessionId);
+        this.host.logger.info("terminal nudge sent", {
+            sessionId,
+            reason: input.reason,
+            message: input.message,
+            terminalTarget,
+            lastTerminalNudgeAt,
+        });
+    }
+    async tryRecoverTarget(sessionId, session) {
+        const recoveredTarget = await (0, client_1.resolveTerminalTargetFromHint)(this.host.config.terminal, {
+            terminalTarget: session.terminalTarget,
+        });
+        if (!recoveredTarget || recoveredTarget === session.terminalTarget) {
+            return recoveredTarget;
+        }
+        await this.host.sessionStore.setSession({
+            ...session,
+            terminalTarget: recoveredTarget,
+            updatedAt: new Date().toISOString(),
+        });
+        this.host.logger.warn("terminal target auto-recovered", {
+            sessionId,
+            previousTerminalTarget: session.terminalTarget,
+            recoveredTerminalTarget: recoveredTarget,
+        });
+        return recoveredTarget;
+    }
+    async notifyTargetInvalid(sessionId, session, error) {
+        const binding = await this.host.bindingStore.getBinding(sessionId);
+        if (!binding) {
+            return;
+        }
+        const nowMs = Date.now();
+        const lastNoticeAt = this.host.terminalNudgeFailureNoticeAt.get(sessionId);
+        if (lastNoticeAt &&
+            nowMs - lastNoticeAt < TERMINAL_NUDGE_FAILURE_NOTICE_COOLDOWN_MS) {
+            return;
+        }
+        this.host.terminalNudgeFailureNoticeAt.set(sessionId, nowMs);
+        const sessionLabel = session.label ?? sessionId;
+        const terminalTarget = session.terminalTarget ?? "unknown";
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const locale = await this.host.resolveLocaleForTelegramUserId(binding.telegramUserId);
+        try {
+            await this.host.sendNotification({
+                sessionId,
+                sessionLabel: "TellyMCP",
+                recipient: {
+                    telegramChatId: binding.telegramChatId,
+                    telegramUserId: binding.telegramUserId,
+                },
+                message: [
+                    this.host.t(locale, "menu:notices.terminal.target_invalid_title", {
+                        sessionName: sessionLabel,
+                    }),
+                    this.host.t(locale, "menu:notices.terminal.target_invalid_target", {
+                        terminalTarget,
+                    }),
+                    this.host.t(locale, "menu:system.error_prefix", {
+                        message: errorMessage,
+                    }),
+                    this.host.t(locale, "menu:system.terminal_recreated_hint"),
+                    this.host.t(locale, "menu:notices.terminal.target_invalid_action"),
+                ].join("\n"),
+            });
+        }
+        catch (notifyError) {
+            this.host.logger.warn("Failed to deliver terminal target failure notification", {
+                sessionId,
+                terminalTarget,
+                telegramChatId: binding.telegramChatId,
+                telegramUserId: binding.telegramUserId,
+                notifyError: notifyError instanceof Error
+                    ? (notifyError.stack ?? notifyError.message)
+                    : String(notifyError),
+            });
+        }
+    }
+    async notifyUnavailable(sessionId, session, error) {
+        const binding = await this.host.bindingStore.getBinding(sessionId);
+        if (!binding) {
+            return;
+        }
+        const nowMs = Date.now();
+        const lastNoticeAt = this.host.terminalNudgeFailureNoticeAt.get(sessionId);
+        if (lastNoticeAt &&
+            nowMs - lastNoticeAt < TERMINAL_NUDGE_FAILURE_NOTICE_COOLDOWN_MS) {
+            return;
+        }
+        this.host.terminalNudgeFailureNoticeAt.set(sessionId, nowMs);
+        const sessionLabel = session.label ?? sessionId;
+        const terminalTarget = session.terminalTarget ?? "unknown";
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const locale = await this.host.resolveLocaleForTelegramUserId(binding.telegramUserId);
+        try {
+            await this.host.sendNotification({
+                sessionId,
+                sessionLabel: "TellyMCP",
+                recipient: {
+                    telegramChatId: binding.telegramChatId,
+                    telegramUserId: binding.telegramUserId,
+                },
+                message: [
+                    this.host.t(locale, "menu:notices.terminal.unavailable_title", {
+                        sessionName: sessionLabel,
+                    }),
+                    this.host.t(locale, "menu:notices.terminal.unavailable_body"),
+                    this.host.t(locale, "menu:notices.terminal.unavailable_target", {
+                        terminalTarget,
+                    }),
+                    this.host.t(locale, "menu:system.error_prefix", {
+                        message: errorMessage,
+                    }),
+                    this.host.t(locale, "menu:notices.terminal.unavailable_reason"),
+                    this.host.t(locale, "menu:notices.terminal.unavailable_action"),
+                ].join("\n"),
+            });
+        }
+        catch (notifyError) {
+            this.host.logger.warn("Failed to deliver terminal unavailable notification", {
+                sessionId,
+                terminalTarget,
+                telegramChatId: binding.telegramChatId,
+                telegramUserId: binding.telegramUserId,
+                notifyError: notifyError instanceof Error
+                    ? (notifyError.stack ?? notifyError.message)
+                    : String(notifyError),
+            });
+        }
+    }
+    async scanPromptForSession(session) {
+        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 ?? 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);
+        }
+        catch (error) {
+            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;
+            }
+            if ((0, client_1.isTerminalTargetInvalidError)(error)) {
+                const recoveredTarget = await this.tryRecoverTarget(session.sessionId, session);
+                if (!recoveredTarget) {
+                    this.host.logger.debug("terminal prompt scan skipped because target is invalid", {
+                        sessionId: session.sessionId,
+                        sessionLabel: session.label,
+                        terminalTarget,
+                    });
+                    return;
+                }
+                terminalTarget = recoveredTarget;
+                capture = await this.capturePromptBuffer({
+                    ...session,
+                    terminalTarget: recoveredTarget,
+                });
+            }
+            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,
+                    error: error instanceof Error
+                        ? (error.stack ?? error.message)
+                        : String(error),
+                });
+                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,
+        });
+        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;
+        }
+        if (!this.shouldSendPromptNotice(session.sessionId, detection)) {
+            return;
+        }
+        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");
+        }
+        if (this.host.config.terminal.captureMode === "visible") {
+            return (0, client_1.captureVisibleTerminal)(this.host.config.terminal, target, this.host.config.terminal.captureLines, this.host.config.webapp.visibleScreens);
+        }
+        return (0, client_1.captureTerminalPaneRange)(this.host.config.terminal, target, `-${this.host.config.terminal.captureLines}`, false);
+    }
+    shouldSendPromptNotice(sessionId, detection) {
+        const existing = this.host.terminalPromptNoticeState.get(sessionId);
+        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,
+            });
+            return false;
+        }
+        this.host.terminalPromptNoticeState.set(sessionId, {
+            fingerprint: detection.fingerprint,
+            sentAtMs: Date.now(),
+        });
+        return true;
+    }
+    async notifyPromptDetected(session, binding, detection, terminalTarget) {
+        if (!binding) {
+            return;
+        }
+        const locale = await this.host.resolveLocaleForTelegramUserId(binding.telegramUserId);
+        const sessionLabel = session.label ?? session.sessionId;
+        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,
+        });
+        try {
+            await this.host.sendLiveViewLauncherMessage({
+                principal: {
+                    telegramChatId: binding.telegramChatId,
+                    telegramUserId: binding.telegramUserId,
+                },
+                sessionId: session.sessionId,
+                sessionName: sessionLabel,
+                locale,
+            });
+        }
+        catch (error) {
+            this.host.logger.warn("Failed to deliver terminal prompt live launcher", {
+                sessionId: session.sessionId,
+                terminalTarget,
+                telegramChatId: binding.telegramChatId,
+                telegramUserId: binding.telegramUserId,
+                error: error instanceof Error
+                    ? (error.stack ?? error.message)
+                    : String(error),
+            });
+        }
+        this.host.logger.info("terminal prompt detected", {
+            sessionId: session.sessionId,
+            terminalTarget,
+            score: detection.score,
+            strategy: this.host.config.terminal.promptScanStrategy,
+            minScore: this.host.config.terminal.promptScanMinScore,
+            reasons: detection.reasons,
+            fingerprint: detection.fingerprint,
+            matchedLines: detection.matchedLines,
+            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) {
+            throw new Error("terminal target is not configured");
+        }
+        const paneStart = await this.resolveCaptureStart(target, scope);
+        const stdout = await (0, client_1.captureTerminalPaneRange)(this.host.config.terminal, target, paneStart, false);
+        const capturedAt = new Date().toISOString();
+        const scopeDescription = this.describeCaptureScope(scope);
+        const titleBase = session.label ?? session.sessionId;
+        const filenameBase = (0, transportUtils_1.slugifyFilenamePart)(titleBase) || "session-buffer";
+        const timestamp = capturedAt.replace(/[:.]/g, "-");
+        const filename = `${filenameBase}-${timestamp}.md`;
+        const content = [
+            "# Terminal Buffer",
+            "",
+            `- Session: ${session.label ?? session.sessionId}`,
+            `- Session ID: ${session.sessionId}`,
+            `- terminal target: ${target}`,
+            `- Capture scope: ${scopeDescription}`,
+            `- Captured at: ${capturedAt}`,
+            "",
+            "```text",
+            stdout.replaceAll("\u0000", ""),
+            "```",
+            "",
+        ].join("\n");
+        return {
+            filename,
+            buffer: Buffer.from(content, "utf8"),
+            captureMode: scope.mode,
+            scopeDescription,
+        };
+    }
+    async resolveCaptureStart(target, scope) {
+        if (scope.mode === "full") {
+            return "-";
+        }
+        if (scope.mode === "lines") {
+            return `-${scope.lines}`;
+        }
+        const height = await (0, client_1.getTerminalWindowHeight)(this.host.config.terminal, target);
+        if (typeof height !== "number" || height <= 0) {
+            return `-${this.host.config.terminal.captureLines}`;
+        }
+        return `-${height}`;
+    }
+    describeCaptureScope(scope) {
+        switch (scope.mode) {
+            case "visible":
+                return "visible pane";
+            case "lines":
+                return `last ${scope.lines} lines`;
+            case "full":
+                return "full history";
+        }
+    }
+}
+exports.TransportTerminalActions = TransportTerminalActions;