@deadragdoll/tellymcp 0.0.10 → 0.0.12

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

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportTerminalRuntime = void 0;
+const grammy_1 = require("grammy");
+const client_1 = require("../terminal/client");
+class TransportTerminalRuntime {
+    host;
+    terminalPromptScanTimer;
+    terminalPromptScanInFlight = false;
+    constructor(host) {
+        this.host = host;
+    }
+    get actions() {
+        const actions = this.host.terminalActions;
+        if (!actions) {
+            throw new Error("TransportTerminalRuntime requires terminal actions");
+        }
+        return actions;
+    }
+    clearTerminalNudgeDebounceTimers() {
+        for (const timer of this.host.terminalNudgeDebounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.host.terminalNudgeDebounceTimers.clear();
+    }
+    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;
+        }
+        const intervalMs = this.host.config.terminal.promptScanIntervalSeconds * 1000;
+        const timer = setInterval(() => {
+            void this.runTerminalPromptScanCycle().catch((error) => {
+                this.host.logger.warn("terminal prompt scan cycle failed", {
+                    error: error instanceof Error
+                        ? (error.stack ?? error.message)
+                        : String(error),
+                });
+            });
+        }, intervalMs);
+        timer.unref();
+        this.terminalPromptScanTimer = timer;
+        this.host.logger.info("terminal prompt scan scheduled", {
+            intervalSeconds: this.host.config.terminal.promptScanIntervalSeconds,
+            cooldownSeconds: this.host.config.terminal.promptScanCooldownSeconds,
+            strategy: this.host.config.terminal.promptScanStrategy,
+            minScore: this.host.config.terminal.promptScanMinScore,
+        });
+        void this.runTerminalPromptScanCycle().catch((error) => {
+            this.host.logger.warn("initial terminal prompt scan failed", {
+                error: error instanceof Error
+                    ? (error.stack ?? error.message)
+                    : String(error),
+            });
+        });
+    }
+    pausePromptScan() {
+        if (!this.terminalPromptScanTimer) {
+            return;
+        }
+        this.clearTerminalPromptScanTimer();
+        this.host.logger.info("terminal prompt scan paused", {});
+    }
+    scheduleTerminalNudgeForInboxMessage(sessionId, session) {
+        if (!this.host.config.terminal.nudgeEnabled) {
+            return;
+        }
+        if (!session?.terminalTarget) {
+            this.host.logger.debug("terminal nudge scheduling skipped for inbox message", {
+                sessionId,
+                reason: "no_terminal_target",
+            });
+            return;
+        }
+        const existingTimer = this.host.terminalNudgeDebounceTimers.get(sessionId);
+        if (existingTimer) {
+            clearTimeout(existingTimer);
+        }
+        const timer = setTimeout(() => {
+            this.host.terminalNudgeDebounceTimers.delete(sessionId);
+            void this.actions
+                .nudgeForInboxMessage(sessionId)
+                .catch((error) => {
+                const payload = {
+                    sessionId,
+                    error: error instanceof Error
+                        ? (error.stack ?? error.message)
+                        : String(error),
+                };
+                if ((0, client_1.isTerminalUnavailableError)(error)) {
+                    void this.host.sessionStore
+                        .getSession(sessionId)
+                        .then((currentSession) => {
+                        if (!currentSession?.terminalTarget) {
+                            return;
+                        }
+                        return this.actions.notifyUnavailable(sessionId, currentSession, error);
+                    });
+                    this.host.logger.warn("terminal nudge skipped because terminal is unavailable", payload);
+                    return;
+                }
+                this.host.logger.error("terminal nudge failed", payload);
+            });
+        }, this.host.config.terminal.nudgeDebounceSeconds * 1000);
+        timer.unref();
+        this.host.terminalNudgeDebounceTimers.set(sessionId, timer);
+        this.host.logger.info("terminal nudge scheduled for inbox message", {
+            sessionId,
+            terminalTarget: session.terminalTarget,
+            debounceSeconds: this.host.config.terminal.nudgeDebounceSeconds,
+        });
+    }
+    async sendTypingForSession(sessionId) {
+        if (!this.host.isTelegramEnabled()) {
+            this.host.logger.debug("Telegram typing skipped because transport is disabled", {
+                sessionId,
+            });
+            return;
+        }
+        const binding = await this.host.bindingStore.getBinding(sessionId);
+        if (!binding) {
+            this.host.logger.debug("Telegram typing skipped because session is unbound", {
+                sessionId,
+            });
+            return;
+        }
+        let attempt = 0;
+        while (true) {
+            attempt += 1;
+            try {
+                await this.host.bot.api.sendChatAction(binding.telegramChatId, "typing");
+                this.host.logger.debug("Telegram typing action sent", {
+                    sessionId,
+                    telegramChatId: binding.telegramChatId,
+                    telegramUserId: binding.telegramUserId,
+                });
+                return;
+            }
+            catch (error) {
+                if (!(error instanceof grammy_1.GrammyError) || error.error_code !== 429) {
+                    throw error;
+                }
+                const retryAfterSeconds = Math.max(1, error.parameters.retry_after ?? 1);
+                this.host.logger.warn("Telegram rate limit hit while sending typing action, cooling down", {
+                    sessionId,
+                    telegramChatId: binding.telegramChatId,
+                    telegramUserId: binding.telegramUserId,
+                    attempt,
+                    retryAfterSeconds,
+                    description: error.description,
+                });
+                await new Promise((resolve) => setTimeout(resolve, retryAfterSeconds * 1000));
+            }
+        }
+    }
+    async runTerminalPromptScanCycle() {
+        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;
+        }
+    }
+}
+exports.TransportTerminalRuntime = TransportTerminalRuntime;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,330 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trimTrailingSlashes = trimTrailingSlashes;
+exports.normalizeBasePath = normalizeBasePath;
+exports.joinHttpPath = joinHttpPath;
+exports.resolveWebAppPublicBaseUrl = resolveWebAppPublicBaseUrl;
+exports.resolveGatewayControlBaseUrl = resolveGatewayControlBaseUrl;
+exports.isMenuEntryCommand = isMenuEntryCommand;
+exports.isHelpCommand = isHelpCommand;
+exports.parseAdminAuthCommand = parseAdminAuthCommand;
+exports.readMenuPayloadKey = readMenuPayloadKey;
+exports.buildDatedRelativePath = buildDatedRelativePath;
+exports.buildPrincipalKey = buildPrincipalKey;
+exports.formatTerminalBridgeError = formatTerminalBridgeError;
+exports.splitLongTelegramText = splitLongTelegramText;
+exports.escapeMarkdownV2 = escapeMarkdownV2;
+exports.escapeMarkdownV2CodeBlock = escapeMarkdownV2CodeBlock;
+exports.escapeHtml = escapeHtml;
+exports.splitTitleAndBody = splitTitleAndBody;
+exports.renderMarkdownChunk = renderMarkdownChunk;
+exports.shouldNudge = shouldNudge;
+exports.slugifyFilenamePart = slugifyFilenamePart;
+exports.formatMenuTimestamp = formatMenuTimestamp;
+exports.normalizeGatewayBaseUrl = normalizeGatewayBaseUrl;
+exports.buildLocalHandoffId = buildLocalHandoffId;
+exports.buildLocalNoteContent = buildLocalNoteContent;
+exports.buildAdminClientTitle = buildAdminClientTitle;
+exports.buildAdminClientButtonLabel = buildAdminClientButtonLabel;
+exports.extractCallbackSuffix = extractCallbackSuffix;
+const node_path_1 = __importDefault(require("node:path"));
+const client_1 = require("../terminal/client");
+function trimTrailingSlashes(value) {
+    return value.replace(/\/+$/u, "");
+}
+function normalizeBasePath(value) {
+    const trimmed = trimTrailingSlashes(value.trim());
+    return trimmed.startsWith("/") ? trimmed || "/" : `/${trimmed || ""}`;
+}
+function joinHttpPath(prefix, suffix) {
+    const normalizedPrefix = prefix ? normalizeBasePath(prefix) : "";
+    const normalizedSuffix = normalizeBasePath(suffix);
+    if (!normalizedPrefix || normalizedPrefix === "/") {
+        return normalizedSuffix;
+    }
+    return `${normalizedPrefix}${normalizedSuffix}`.replace(/\/{2,}/gu, "/");
+}
+function resolveWebAppPublicBaseUrl(config) {
+    if (!config.webapp.publicUrl) {
+        return null;
+    }
+    const rootPrefix = normalizeBasePath(process.env.ROOT_PREFIX || "/api");
+    const webAppBasePath = normalizeBasePath(config.webapp.basePath || "/webapp");
+    const expectedPath = trimTrailingSlashes(`${rootPrefix === "/" ? "" : rootPrefix}${webAppBasePath}`) || "/";
+    const url = new URL(config.webapp.publicUrl);
+    const currentPath = normalizeBasePath(url.pathname || "/");
+    if (currentPath === expectedPath) {
+        return trimTrailingSlashes(url.toString());
+    }
+    if (currentPath === webAppBasePath) {
+        url.pathname = expectedPath;
+        return trimTrailingSlashes(url.toString());
+    }
+    if (currentPath.endsWith(webAppBasePath)) {
+        url.pathname = expectedPath;
+        return trimTrailingSlashes(url.toString());
+    }
+    url.pathname = expectedPath;
+    return trimTrailingSlashes(url.toString());
+}
+function resolveGatewayControlBaseUrl(config) {
+    if (config.distributed.mode === "gateway" ||
+        config.distributed.mode === "both") {
+        const runtimePort = Number(process.env.PORT || config.mcp.httpPort);
+        const rootPrefix = normalizeBasePath(process.env.ROOT_PREFIX || "/api");
+        const gatewayPath = joinHttpPath(rootPrefix, "/gateway");
+        return trimTrailingSlashes(`http://127.0.0.1:${runtimePort}${gatewayPath}`);
+    }
+    if (!config.distributed.gatewayPublicUrl) {
+        return null;
+    }
+    const url = new URL(config.distributed.gatewayPublicUrl);
+    url.pathname = url.pathname.replace(/\/+$/u, "");
+    if (!url.pathname.endsWith("/gateway")) {
+        url.pathname = `${url.pathname}/gateway`.replace(/\/{2,}/gu, "/");
+    }
+    return trimTrailingSlashes(url.toString());
+}
+function isMenuEntryCommand(text) {
+    return /^\/(?:menu|start)(?:@\w+)?$/i.test(text.trim());
+}
+function isHelpCommand(text) {
+    return /^\/help(?:@\w+)?$/i.test(text.trim());
+}
+function parseAdminAuthCommand(text) {
+    const match = text.trim().match(/^\/auth(?:@\w+)?(?:\s+(.+))?$/i);
+    return match?.[1]?.trim() || null;
+}
+function readMenuPayloadKey(ctx) {
+    const payload = ctx.match;
+    return typeof payload === "string" && payload.length > 0 ? payload : null;
+}
+function buildDatedRelativePath(fileName, date = new Date()) {
+    const dateSegment = date.toISOString().slice(0, 10);
+    const timeSegment = date.toTimeString().slice(0, 8).replace(/:/gu, "-");
+    return `${dateSegment}/${timeSegment}/${fileName}`;
+}
+function buildPrincipalKey(principal) {
+    return `${principal.telegramChatId}:${principal.telegramUserId}`;
+}
+function formatTerminalBridgeError(_config, error, fallback) {
+    if ((0, client_1.isTerminalUnavailableError)(error)) {
+        return "Terminal runtime is unavailable right now.";
+    }
+    return fallback;
+}
+function splitLongTelegramText(text, maxChars) {
+    const normalized = text.trim();
+    if (normalized.length <= maxChars) {
+        return [normalized];
+    }
+    const paragraphs = normalized.split("\n\n");
+    const chunks = [];
+    let current = "";
+    const flush = () => {
+        const trimmed = current.trim();
+        if (trimmed) {
+            chunks.push(trimmed);
+        }
+        current = "";
+    };
+    const appendSegment = (segment) => {
+        if (!segment) {
+            return;
+        }
+        if (segment.length <= maxChars) {
+            const candidate = current ? `${current}\n\n${segment}` : segment;
+            if (candidate.length <= maxChars) {
+                current = candidate;
+                return;
+            }
+            flush();
+            current = segment;
+            return;
+        }
+        flush();
+        const lines = segment.split("\n");
+        let lineChunk = "";
+        for (const line of lines) {
+            if (line.length > maxChars) {
+                if (lineChunk) {
+                    chunks.push(lineChunk.trim());
+                    lineChunk = "";
+                }
+                for (let index = 0; index < line.length; index += maxChars) {
+                    chunks.push(line.slice(index, index + maxChars).trim());
+                }
+                continue;
+            }
+            const candidate = lineChunk ? `${lineChunk}\n${line}` : line;
+            if (candidate.length <= maxChars) {
+                lineChunk = candidate;
+            }
+            else {
+                chunks.push(lineChunk.trim());
+                lineChunk = line;
+            }
+        }
+        if (lineChunk) {
+            current = lineChunk;
+        }
+    };
+    for (const paragraph of paragraphs) {
+        appendSegment(paragraph);
+    }
+    flush();
+    return chunks.filter((chunk) => chunk.length > 0);
+}
+function escapeMarkdownV2(text) {
+    const specialChars = new Set([
+        "_",
+        "*",
+        "[",
+        "]",
+        "(",
+        ")",
+        "~",
+        "`",
+        ">",
+        "#",
+        "+",
+        "-",
+        "=",
+        "|",
+        "{",
+        "}",
+        ".",
+        "!",
+        "\\",
+    ]);
+    return Array.from(text, (char) => specialChars.has(char) ? `\\${char}` : char).join("");
+}
+function escapeMarkdownV2CodeBlock(text) {
+    return text.replace(/\\/g, "\\\\").replace(/`/g, "\\`");
+}
+function escapeHtml(text) {
+    return text
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+function splitTitleAndBody(text) {
+    const normalized = text.trim();
+    const [firstLine = "", ...rest] = normalized.split("\n");
+    const title = firstLine.trim() || "Codex";
+    const body = rest.join("\n").trim();
+    return {
+        title,
+        body: body || firstLine.trim(),
+    };
+}
+function renderMarkdownChunk(title, body) {
+    return `*${escapeMarkdownV2(title)}*\n\n\`\`\`\n${escapeMarkdownV2CodeBlock(body)}\n\`\`\``;
+}
+function shouldNudge(lastNudgeAt, cooldownSeconds, nowMs) {
+    if (!lastNudgeAt) {
+        return true;
+    }
+    const lastMs = Date.parse(lastNudgeAt);
+    if (Number.isNaN(lastMs)) {
+        return true;
+    }
+    return nowMs - lastMs >= cooldownSeconds * 1000;
+}
+function slugifyFilenamePart(input) {
+    return input
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 48);
+}
+function formatMenuTimestamp(timestamp) {
+    if (!timestamp) {
+        return null;
+    }
+    const date = new Date(timestamp);
+    if (Number.isNaN(date.getTime())) {
+        return null;
+    }
+    const day = String(date.getDate()).padStart(2, "0");
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const year = date.getFullYear();
+    const hours = String(date.getHours()).padStart(2, "0");
+    const minutes = String(date.getMinutes()).padStart(2, "0");
+    return `${day}.${month}.${year} ${hours}:${minutes}`;
+}
+function normalizeGatewayBaseUrl(value) {
+    const url = new URL(value);
+    url.pathname = url.pathname.replace(/\/+$/u, "");
+    if (!url.pathname.endsWith("/gateway")) {
+        url.pathname = `${url.pathname}/gateway`.replace(/\/{2,}/gu, "/");
+    }
+    return url;
+}
+function buildLocalHandoffId(fileName, now) {
+    const timestamp = now.toISOString().replace(/[:.]/gu, "-");
+    return `${timestamp}-${slugifyFilenamePart(fileName) || "file-handoff"}`;
+}
+function buildLocalNoteContent(input) {
+    return [
+        "---",
+        `handoff_id: ${JSON.stringify(input.handoffId)}`,
+        `kind: "local-file"`,
+        `created_at: ${JSON.stringify(input.createdAt)}`,
+        `session_id: ${JSON.stringify(input.sessionId)}`,
+        `session_label: ${JSON.stringify(input.sessionLabel ?? input.sessionId)}`,
+        `artifacts:\n  - ${JSON.stringify(input.filePath)}`,
+        "---",
+        "",
+        "# Summary",
+        `Local file handoff: ${node_path_1.default.basename(input.filePath)}`,
+        "",
+        "# Message",
+        input.description.trim(),
+        "",
+        "# Artifacts",
+        `- ${input.filePath}`,
+        "",
+    ].join("\n");
+}
+function buildAdminClientTitle(client) {
+    const displayName = client.telegram_display_name?.trim() || "";
+    const telegramUsername = client.telegram_username?.trim().replace(/^@/u, "") || "";
+    const botUsername = client.bot_username?.trim().replace(/^@/u, "") || "";
+    const clientLabel = client.client_label?.trim() || "";
+    const namespace = client.namespace?.trim() || "";
+    const nodeId = client.node_id?.trim() || "";
+    const runtimeLabel = [namespace, nodeId].filter(Boolean).join("/") || nodeId || "";
+    const fallback = (clientLabel || runtimeLabel || client.client_uuid).trim();
+    const identityParts = [
+        displayName || null,
+        !displayName && telegramUsername ? `@${telegramUsername}` : null,
+        !displayName && !telegramUsername && clientLabel ? clientLabel : null,
+        !displayName && !telegramUsername && !clientLabel && runtimeLabel
+            ? runtimeLabel
+            : null,
+        botUsername ? `🤖@${botUsername}` : null,
+    ].filter(Boolean);
+    return identityParts.length > 0 ? identityParts.join(" · ") : fallback;
+}
+function buildAdminClientButtonLabel(client) {
+    const markers = [
+        client.is_connected ? "🟢" : null,
+        client.is_registered ? "🗂" : null,
+    ]
+        .filter(Boolean)
+        .join("");
+    const prefix = markers ? `${markers} ` : "";
+    return `${prefix}${buildAdminClientTitle(client)}`.slice(0, 56);
+}
+function extractCallbackSuffix(ctx, prefix) {
+    const data = ctx.callbackQuery?.data;
+    if (!data || !data.startsWith(prefix)) {
+        return null;
+    }
+    return data.slice(prefix.length) || null;
+}

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

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportXchangeState = void 0;
+const relay_1 = require("../../../app/webapp/relay");
+const client_1 = require("../terminal/client");
+class TransportXchangeState {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async resolveSessionStorageAccess(sessionId) {
+        const trimmed = sessionId.trim();
+        if (!trimmed) {
+            return { sessionId: trimmed, mode: "meta" };
+        }
+        const relay = (0, relay_1.parseLiveRelaySessionId)(trimmed);
+        if (relay?.localSessionId) {
+            const localSession = await this.host.sessionStore.getSession(relay.localSessionId);
+            if (localSession?.cwd?.trim()) {
+                return { sessionId: relay.localSessionId, mode: "filesystem" };
+            }
+            return { sessionId: trimmed, mode: "relay" };
+        }
+        const direct = await this.host.sessionStore.getSession(trimmed);
+        if (direct?.cwd?.trim()) {
+            return { sessionId: trimmed, mode: "filesystem" };
+        }
+        return { sessionId: trimmed, mode: "meta" };
+    }
+    async listActiveSessionFiles(sessionId) {
+        const access = await this.resolveSessionStorageAccess(sessionId);
+        const metas = access.mode === "filesystem"
+            ? await this.listReconciledSessionXchangeMetas(access.sessionId, await this.listSessionFilesystemXchangeFiles(access.sessionId))
+            : access.mode === "relay"
+                ? await this.listRelaySessionXchangeFileMetas(access.sessionId, "telegram-upload")
+                : await this.host.xchangeFileMetaStore.listXchangeFileMetas(access.sessionId);
+        const uploadFiles = metas
+            .filter((meta) => meta.source === "telegram-upload")
+            .map((meta) => meta.filePath);
+        return uploadFiles.sort((left, right) => right.localeCompare(left));
+    }
+    async listActiveSessionStorageEntries(sessionId) {
+        const access = await this.resolveSessionStorageAccess(sessionId);
+        if (access.mode === "relay") {
+            const metas = await this.listRelaySessionXchangeFileMetas(access.sessionId);
+            return metas.map((meta) => ({
+                filePath: meta.filePath,
+                meta,
+            }));
+        }
+        if (access.mode === "meta") {
+            const metas = await this.host.xchangeFileMetaStore.listXchangeFileMetas(access.sessionId);
+            return metas.map((meta) => ({
+                filePath: meta.filePath,
+                meta,
+            }));
+        }
+        const filePaths = await this.listSessionFilesystemXchangeFiles(access.sessionId);
+        const metas = await this.listReconciledSessionXchangeMetas(access.sessionId, filePaths);
+        const metaByPath = new Map(metas.map((meta) => [meta.filePath, meta]));
+        return filePaths.map((filePath) => ({
+            filePath,
+            meta: metaByPath.get(filePath) ?? null,
+        }));
+    }
+    async listActiveSessionScreenshots(sessionId) {
+        const access = await this.resolveSessionStorageAccess(sessionId);
+        const metas = access.mode === "filesystem"
+            ? await this.listReconciledSessionXchangeMetas(access.sessionId, await this.listSessionFilesystemXchangeFiles(access.sessionId))
+            : access.mode === "relay"
+                ? await this.listRelaySessionXchangeFileMetas(access.sessionId, "browser-screenshot")
+                : await this.host.xchangeFileMetaStore.listXchangeFileMetas(access.sessionId);
+        const screenshots = metas
+            .filter((meta) => meta.source === "browser-screenshot")
+            .map((meta) => meta.filePath);
+        return screenshots.sort((left, right) => right.localeCompare(left));
+    }
+    async listSessionFilesystemXchangeFiles(sessionId) {
+        const session = await this.host.sessionStore.getSession(sessionId);
+        const resolvedWorkspaceDir = session?.cwd?.trim() || "";
+        if (!resolvedWorkspaceDir) {
+            throw new Error(`Workspace cwd is not registered for console '${sessionId}'.`);
+        }
+        const files = await (0, client_1.listXchangeFiles)(this.host.config.terminal, resolvedWorkspaceDir, this.host.config.exchange.dir);
+        return files.sort((left, right) => right.localeCompare(left));
+    }
+    async listReconciledSessionXchangeMetas(sessionId, existingFiles) {
+        const metas = await this.host.xchangeFileMetaStore.listXchangeFileMetas(sessionId);
+        if (metas.length === 0) {
+            return [];
+        }
+        const existingSet = new Set(existingFiles);
+        const staleMetas = metas.filter((meta) => !existingSet.has(meta.filePath));
+        for (const meta of staleMetas) {
+            await this.host.xchangeFileMetaStore.deleteXchangeFileMeta(sessionId, meta.filePath);
+        }
+        return metas.filter((meta) => existingSet.has(meta.filePath));
+    }
+    async listRelaySessionXchangeFileMetas(sessionId, source) {
+        const output = await this.host.callGatewayJson("/storage/list", {
+            session_id: sessionId,
+            ...(source ? { source } : {}),
+        });
+        return Array.isArray(output.metas) ? output.metas : [];
+    }
+}
+exports.TransportXchangeState = TransportXchangeState;