@deadragdoll/tellymcp 0.0.10 → 0.0.12

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportAttachmentStore = void 0;
+const transportUtils_1 = require("./transportUtils");
+class TransportAttachmentStore {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async storeTelegramUploadMetas(input) {
+        for (let index = 0; index < input.attachments.length; index += 1) {
+            const attachment = input.attachments[index];
+            if (!attachment) {
+                continue;
+            }
+            const descriptor = input.descriptors?.[index];
+            await this.host.xchangeFileMetaStore.setXchangeFileMeta({
+                sessionId: input.sessionId,
+                filePath: attachment.filePath,
+                relativePath: attachment.relativePath,
+                source: "telegram-upload",
+                sourceTelegramMessageId: input.sourceTelegramMessageId,
+                uploadedAt: input.uploadedAt,
+                storageRef: attachment.storageRef,
+                bucketName: attachment.bucketName,
+                objectName: attachment.objectName,
+                vfsNodeId: attachment.vfsNodeId,
+                vfsPublicUrl: attachment.vfsPublicUrl,
+                vfsParentId: attachment.vfsParentId,
+                mimeType: attachment.mimeType,
+                sizeBytes: attachment.sizeBytes,
+                ...(descriptor && !descriptor.preferredName.startsWith("photo-")
+                    ? { originalName: descriptor.preferredName }
+                    : {}),
+                ...(input.caption ? { caption: input.caption } : {}),
+            });
+        }
+    }
+    async ensureStoredXchangeFile(sessionId, filePath, source) {
+        const session = await this.host.sessionStore.getSession(sessionId);
+        const meta = await this.host.xchangeFileMetaStore.getXchangeFileMeta(sessionId, filePath);
+        if (!meta) {
+            return { session, filePath };
+        }
+        const materializedPath = await this.host.objectStore.ensureLocalFile({
+            sessionId,
+            session,
+            filePath,
+            relativePath: meta.relativePath,
+            storageRef: meta.storageRef,
+            source,
+        });
+        return {
+            session,
+            filePath: materializedPath,
+        };
+    }
+    async downloadIncomingAttachments(session, sessionId, sourceTelegramMessageId, attachments) {
+        if (attachments.length === 0) {
+            return [];
+        }
+        const savedFiles = [];
+        for (const attachment of attachments) {
+            const savedFile = await this.downloadTelegramFile(session, sessionId, attachment.fileId, sourceTelegramMessageId, attachment.preferredName, attachment.mimeType);
+            savedFiles.push(savedFile);
+        }
+        return savedFiles;
+    }
+    async downloadTelegramFile(session, sessionId, fileId, _sourceTelegramMessageId, preferredName, preferredMimeType) {
+        const telegramFile = await this.host.getTelegramFile(fileId);
+        if (!telegramFile.file_path) {
+            throw new Error("Telegram file path is missing");
+        }
+        const outputName = preferredName;
+        const fileUrl = `https://api.telegram.org/file/bot${this.host.getRequiredBotToken("download Telegram files")}/${telegramFile.file_path}`;
+        const response = await this.host.telegramFetch(fileUrl);
+        if (!response.ok) {
+            throw new Error(`Telegram file download failed with status ${response.status}`);
+        }
+        const buffer = Buffer.from(await response.arrayBuffer());
+        return this.host.objectStore.storeFile({
+            session,
+            sessionId,
+            source: "telegram-upload",
+            relativePath: (0, transportUtils_1.buildDatedRelativePath)(outputName),
+            content: buffer,
+            mimeType: preferredMimeType ||
+                response.headers.get("content-type") ||
+                undefined,
+        });
+    }
+}
+exports.TransportAttachmentStore = TransportAttachmentStore;

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

@@ -0,0 +1,385 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportBroadcastActions = void 0;
+const grammy_1 = require("grammy");
+const relay_1 = require("../../../app/webapp/relay");
+const redactSecrets_1 = require("../../lib/redact-secrets/redactSecrets");
+const telegramXchangeRecords_1 = require("../../lib/telegramXchangeRecords");
+const transportFormatting_1 = require("./transportFormatting");
+const transportUtils_1 = require("./transportUtils");
+class TransportBroadcastActions {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async beginBroadcast(ctx) {
+        const locale = await this.host.resolveLocaleForContext(ctx);
+        const principal = this.host.getPrincipalFromContext(ctx);
+        if (!principal) {
+            await ctx.answerCallbackQuery({
+                text: this.host.t(locale, "common:errors.no_telegram_identity"),
+                show_alert: true,
+            });
+            return;
+        }
+        const sessionIds = await this.host.bindingStore.listBoundSessionIdsForPrincipal(principal);
+        if (sessionIds.length === 0) {
+            await ctx.answerCallbackQuery({
+                text: this.host.t(locale, "menu:broadcast.no_linked_sessions"),
+                show_alert: true,
+            });
+            return;
+        }
+        const principalKey = (0, transportUtils_1.buildPrincipalKey)(principal);
+        this.host.pendingRenames.delete(principalKey);
+        await ctx.answerCallbackQuery({
+            text: this.host.t(locale, "menu:broadcast.begin", { count: sessionIds.length }),
+        });
+        const sent = await this.host.replyText(ctx, [
+            this.host.t(locale, "menu:broadcast.title"),
+            "",
+            this.host.t(locale, "menu:broadcast.body", { count: sessionIds.length }),
+            this.host.t(locale, "menu:broadcast.hint"),
+            this.host.t(locale, "menu:broadcast.cancel_hint"),
+        ].join("\n"), { kind: "menu" }, { reply_markup: new grammy_1.InlineKeyboard().text("Cancel", "broadcast-cancel") });
+        this.host.pendingBroadcasts.set(principalKey, {
+            initiatedAt: new Date().toISOString(),
+            scope: "linked",
+            ...(sent ? { promptMessageId: sent.message_id } : {}),
+            ...(ctx.callbackQuery?.message?.message_id
+                ? { menuMessageId: ctx.callbackQuery.message.message_id }
+                : {}),
+        });
+    }
+    async beginProjectBroadcast(ctx) {
+        const locale = await this.host.resolveLocaleForContext(ctx);
+        const principal = this.host.getPrincipalFromContext(ctx);
+        if (!principal) {
+            await ctx.answerCallbackQuery({
+                text: this.host.t(locale, "common:errors.no_telegram_identity"),
+                show_alert: true,
+            });
+            return;
+        }
+        const sessionId = await this.host.bindingStore.getActiveSessionIdForPrincipal(principal);
+        if (!sessionId) {
+            await ctx.answerCallbackQuery({
+                text: this.host.t(locale, "common:errors.no_active_session"),
+                show_alert: true,
+            });
+            return;
+        }
+        const projects = await this.host.listGatewayProjects(principal);
+        if (projects.length === 0) {
+            await ctx.answerCallbackQuery({
+                text: this.host.t(locale, "menu:broadcast.no_projects_first"),
+                show_alert: true,
+            });
+            return;
+        }
+        const targets = await this.collectCollabBroadcastTargets(principal);
+        const totalTargets = targets.localTargetSessionIds.length + targets.remoteTargets.length;
+        if (totalTargets === 0) {
+            await ctx.answerCallbackQuery({
+                text: this.host.t(locale, "menu:broadcast.no_collab_targets"),
+                show_alert: true,
+            });
+            return;
+        }
+        const principalKey = (0, transportUtils_1.buildPrincipalKey)(principal);
+        this.host.pendingRenames.delete(principalKey);
+        await ctx.answerCallbackQuery({
+            text: this.host.t(locale, "menu:broadcast.collab_begin", { count: totalTargets }),
+        });
+        const sent = await this.host.replyText(ctx, [
+            this.host.t(locale, "menu:broadcast.collab_title"),
+            "",
+            this.host.t(locale, "menu:broadcast.collab_projects", { count: projects.length }),
+            this.host.t(locale, "menu:broadcast.collab_sessions", { count: totalTargets }),
+            "",
+            this.host.t(locale, "menu:broadcast.collab_body"),
+            this.host.t(locale, "menu:broadcast.collab_hint"),
+            this.host.t(locale, "menu:broadcast.cancel_hint"),
+        ].join("\n"), { kind: "menu", sessionId }, { reply_markup: new grammy_1.InlineKeyboard().text("Cancel", "broadcast-cancel") });
+        this.host.pendingBroadcasts.set(principalKey, {
+            initiatedAt: new Date().toISOString(),
+            scope: "project",
+            sessionId,
+            localTargetSessionIds: targets.localTargetSessionIds,
+            remoteTargets: targets.remoteTargets,
+            ...(sent ? { promptMessageId: sent.message_id } : {}),
+            ...(ctx.callbackQuery?.message?.message_id
+                ? { menuMessageId: ctx.callbackQuery.message.message_id }
+                : {}),
+        });
+    }
+    async cancelPendingBroadcast(ctx) {
+        const locale = await this.host.resolveLocaleForContext(ctx);
+        const principal = this.host.getPrincipalFromContext(ctx);
+        if (!principal) {
+            await ctx.answerCallbackQuery({
+                text: this.host.t(locale, "common:errors.no_telegram_identity"),
+                show_alert: true,
+            });
+            return;
+        }
+        const principalKey = (0, transportUtils_1.buildPrincipalKey)(principal);
+        const pending = this.host.pendingBroadcasts.get(principalKey);
+        if (!pending) {
+            await ctx.answerCallbackQuery({
+                text: this.host.t(locale, "menu:broadcast.mode_not_active"),
+                show_alert: true,
+            });
+            return;
+        }
+        this.host.pendingBroadcasts.delete(principalKey);
+        await this.deletePendingBroadcastArtifacts(ctx, pending, false);
+        await ctx.answerCallbackQuery({
+            text: this.host.t(locale, "menu:broadcast.cancelled"),
+        });
+        if (pending.scope === "project") {
+            await this.host.showCollabToolsMenu(ctx);
+            return;
+        }
+        await this.host.showDeveloperMenu(ctx);
+    }
+    async handlePendingBroadcast(ctx, text) {
+        const principal = this.host.getPrincipalFromContext(ctx);
+        if (!principal) {
+            return false;
+        }
+        const principalKey = (0, transportUtils_1.buildPrincipalKey)(principal);
+        const pending = this.host.pendingBroadcasts.get(principalKey);
+        if (!pending) {
+            return false;
+        }
+        if (text.startsWith("/")) {
+            this.host.pendingBroadcasts.delete(principalKey);
+            await this.deletePendingBroadcastArtifacts(ctx, pending, false);
+            return false;
+        }
+        const broadcastText = text.trim();
+        if (pending.scope === "linked" &&
+            (await this.host.bindingStore.listBoundSessionIdsForPrincipal(principal)).length === 0) {
+            this.host.pendingBroadcasts.delete(principalKey);
+            await this.deletePendingBroadcastArtifacts(ctx, pending, false);
+            await this.host.replyText(ctx, "Broadcast cancelled because no visible sessions were found.", { kind: "menu" });
+            return true;
+        }
+        const receivedAt = new Date(ctx.message?.date ? ctx.message.date * 1000 : Date.now()).toISOString();
+        let storedCount = 0;
+        let remoteCount = 0;
+        if (pending.scope === "project") {
+            const parsed = (0, transportFormatting_1.parsePartnerNoteText)(broadcastText);
+            const sourceSession = pending.sessionId
+                ? await this.host.sessionStore.getSession(pending.sessionId)
+                : null;
+            const sourceLabel = sourceSession?.label ?? pending.sessionId ?? "session";
+            for (const sessionId of pending.localTargetSessionIds ?? []) {
+                const session = await this.host.sessionStore.getSession(sessionId);
+                await (0, telegramXchangeRecords_1.writeTelegramMessageXchangeRecord)({
+                    config: this.host.config,
+                    session,
+                    sessionId,
+                    text: [
+                        "Collab broadcast from Telegram user.",
+                        `Source session: ${sourceLabel}`,
+                        `Summary: ${parsed.summary}`,
+                        "",
+                        "Message:",
+                        parsed.message,
+                    ].join("\n"),
+                    createdAt: receivedAt,
+                    summary: parsed.summary,
+                    tags: ["telegram", "broadcast", "collab", "human"],
+                });
+                storedCount += 1;
+                try {
+                    this.host.scheduleTerminalNudgeForInboxMessage(sessionId, session);
+                }
+                catch (error) {
+                    this.host.logger.error("terminal nudge failed after project broadcast xchange capture", {
+                        sessionId,
+                        error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                    });
+                }
+            }
+            for (const target of pending.remoteTargets ?? []) {
+                await this.host.sendPartnerNote({
+                    target_session_id: target.sessionUuid,
+                    kind: "request",
+                    summary: parsed.summary,
+                    message: [
+                        "Collab broadcast from Telegram user.",
+                        ...(target.projectName ? [`Project: ${target.projectName}`] : []),
+                        `Source session: ${sourceLabel}`,
+                        "",
+                        "Message:",
+                        parsed.message,
+                    ].join("\n"),
+                    requires_reply: false,
+                    ...(pending.sessionId ? { session_id: pending.sessionId } : {}),
+                    ...(target.projectUuid ? { project_uuid: target.projectUuid } : {}),
+                });
+                remoteCount += 1;
+            }
+        }
+        else {
+            const sessionIds = await this.host.bindingStore.listBoundSessionIdsForPrincipal(principal);
+            for (const sessionId of sessionIds) {
+                const relayTarget = (0, relay_1.parseLiveRelaySessionId)(sessionId);
+                if (relayTarget) {
+                    try {
+                        await this.host.routeTelegramInboxToRelaySession({
+                            ctx,
+                            principal,
+                            relayTarget,
+                            sourceSessionId: sessionId,
+                            messageText: broadcastText,
+                            attachments: [],
+                        });
+                        remoteCount += 1;
+                        this.host.logger.info("Telegram broadcast routed to gateway relay session", {
+                            sessionId,
+                            chatId: principal.telegramChatId,
+                            userId: principal.telegramUserId,
+                            targetClientUuid: relayTarget.clientUuid,
+                            targetLocalSessionId: relayTarget.localSessionId,
+                            text: (0, redactSecrets_1.redactSecrets)(broadcastText),
+                        });
+                        continue;
+                    }
+                    catch (error) {
+                        this.host.logger.error("Failed to route Telegram broadcast to gateway relay session", {
+                            sessionId,
+                            chatId: principal.telegramChatId,
+                            userId: principal.telegramUserId,
+                            targetClientUuid: relayTarget.clientUuid,
+                            targetLocalSessionId: relayTarget.localSessionId,
+                            error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                        });
+                        continue;
+                    }
+                }
+                const session = await this.host.sessionStore.getSession(sessionId);
+                await (0, telegramXchangeRecords_1.writeTelegramMessageXchangeRecord)({
+                    config: this.host.config,
+                    session,
+                    sessionId,
+                    text: broadcastText,
+                    createdAt: receivedAt,
+                    summary: (0, transportFormatting_1.parsePartnerNoteText)(broadcastText).summary,
+                    tags: ["telegram", "broadcast", "human"],
+                });
+                storedCount += 1;
+                this.host.logger.info("Telegram broadcast message stored in xchange", {
+                    sessionId,
+                    chatId: principal.telegramChatId,
+                    userId: principal.telegramUserId,
+                    text: (0, redactSecrets_1.redactSecrets)(broadcastText),
+                });
+                try {
+                    this.host.scheduleTerminalNudgeForInboxMessage(sessionId, session);
+                }
+                catch (error) {
+                    this.host.logger.error("terminal nudge failed after broadcast xchange capture", {
+                        sessionId,
+                        error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                    });
+                }
+            }
+        }
+        this.host.pendingBroadcasts.delete(principalKey);
+        await this.deletePendingBroadcastArtifacts(ctx, pending, false);
+        this.host.logger.info("Telegram broadcast completed", {
+            chatId: principal.telegramChatId,
+            userId: principal.telegramUserId,
+            scope: pending.scope,
+            storedCount,
+            remoteCount,
+            sessionCount: storedCount + remoteCount,
+            initiatedAt: pending.initiatedAt,
+            text: (0, redactSecrets_1.redactSecrets)(broadcastText),
+        });
+        const locale = await this.host.resolveLocaleForContext(ctx);
+        await this.host.replyText(ctx, pending.scope === "project"
+            ? [
+                this.host.t(locale, "menu:broadcast.completed_collab", {
+                    count: storedCount + remoteCount,
+                }),
+                this.host.t(locale, "menu:broadcast.completed_collab_local", { count: storedCount }),
+                this.host.t(locale, "menu:broadcast.completed_collab_remote", { count: remoteCount }),
+                this.host.t(locale, "menu:broadcast.completed_collab_total", {
+                    count: storedCount + remoteCount,
+                }),
+            ].join("\n")
+            : await this.host.tForContext(ctx, "menu:broadcast.completed_linked", {
+                count: storedCount + remoteCount,
+            }), { kind: "menu", ...(pending.sessionId ? { sessionId: pending.sessionId } : {}) });
+        return true;
+    }
+    async collectCollabBroadcastTargets(principal) {
+        const currentClientUuid = await this.host.ensureGatewayClientUuid(principal);
+        const projects = await this.host.listGatewayProjects(principal);
+        const visibleLocalSessionIds = new Set(await this.host.bindingStore.listBoundSessionIdsForPrincipal(principal));
+        const localTargetSessionIds = [];
+        const remoteTargets = [];
+        const seenLogicalTargets = new Set();
+        for (const project of projects) {
+            const projectSessions = await this.host.listGatewayProjectSessions(principal, project.project_uuid);
+            for (const item of projectSessions) {
+                const logicalTargetKey = `${item.client_uuid}:${item.local_session_id}`;
+                if (seenLogicalTargets.has(logicalTargetKey)) {
+                    continue;
+                }
+                seenLogicalTargets.add(logicalTargetKey);
+                const isVisibleLocalSession = item.client_uuid === currentClientUuid &&
+                    visibleLocalSessionIds.has(item.local_session_id);
+                if (isVisibleLocalSession) {
+                    localTargetSessionIds.push(item.local_session_id);
+                    continue;
+                }
+                remoteTargets.push({
+                    sessionUuid: item.session_uuid,
+                    sessionLabel: item.label?.trim() || item.local_session_id,
+                    clientUuid: item.client_uuid,
+                    localSessionId: item.local_session_id,
+                    projectUuid: item.project_uuid,
+                    ...(project.name ? { projectName: project.name } : {}),
+                });
+            }
+        }
+        return {
+            localTargetSessionIds: [...new Set(localTargetSessionIds)].sort(),
+            remoteTargets,
+        };
+    }
+    async listCollabBroadcastTargets(principal) {
+        return this.collectCollabBroadcastTargets(principal);
+    }
+    async deletePendingBroadcastArtifacts(ctx, pending, deleteMenuMessage) {
+        const chatId = ctx.chat?.id;
+        if (!chatId) {
+            return;
+        }
+        for (const messageId of [
+            pending.promptMessageId,
+            ...(deleteMenuMessage ? [pending.menuMessageId] : []),
+        ]) {
+            if (!messageId) {
+                continue;
+            }
+            try {
+                await this.host.deleteMessage(chatId, messageId);
+            }
+            catch (error) {
+                this.host.logger.warn("Failed to delete pending broadcast menu artifact", {
+                    chatId,
+                    messageId,
+                    error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                });
+            }
+        }
+    }
+}
+exports.TransportBroadcastActions = TransportBroadcastActions;

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportConsoleRegistry = void 0;
+const relay_1 = require("../../../app/webapp/relay");
+class TransportConsoleRegistry {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    labelSeparator = " · ";
+    async clearStaleRelaySessions(input) {
+        for (const sessionId of input.existingBound) {
+            if (!sessionId.startsWith("relay~")) {
+                continue;
+            }
+            if (input.liveRelaySessionIds.has(sessionId)) {
+                continue;
+            }
+            await this.host.bindingStore.clearBinding(sessionId);
+            await this.host.sessionStore.clearSession(sessionId);
+        }
+    }
+    async listScopedConsoles(input) {
+        const response = await this.host.callGatewayJson("/sessions/known", {
+            connected_only: true,
+            ...(input?.principal
+                ? { telegram_user_id: input.principal.telegramUserId }
+                : {}),
+            ...(this.host.config.distributed.gatewayToken
+                ? { gateway_token: this.host.config.distributed.gatewayToken }
+                : {}),
+        });
+        return Array.isArray(response.sessions) ? response.sessions : [];
+    }
+    async ensureScopedConsolesBound(input) {
+        const existingBound = new Set(await this.host.bindingStore.listBoundSessionIdsForPrincipal(input.principal));
+        const consoles = await this.listScopedConsoles({
+            principal: input.principal,
+        });
+        const liveRelaySessionIds = new Set(consoles.map((consoleSession) => (0, relay_1.buildLiveRelaySessionId)(consoleSession.client_uuid, consoleSession.local_session_id)));
+        await this.clearStaleRelaySessions({
+            existingBound,
+            liveRelaySessionIds,
+        });
+        if (liveRelaySessionIds.size === 0) {
+            const nextActive = await this.host.bindingStore.getActiveSessionIdForPrincipal(input.principal);
+            return {
+                sessionIds: [],
+                activeSessionId: nextActive,
+            };
+        }
+        const relaySessionIds = [];
+        for (const consoleSession of consoles) {
+            const relaySessionId = (0, relay_1.buildLiveRelaySessionId)(consoleSession.client_uuid, consoleSession.local_session_id);
+            relaySessionIds.push(relaySessionId);
+            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));
+        const nextActive = existingActive && nextBound.has(existingActive)
+            ? existingActive
+            : relaySessionIds[0] ?? existingActive ?? null;
+        if (nextActive) {
+            await this.host.bindingStore.setActiveSessionIdForPrincipal(input.principal, nextActive);
+        }
+        this.host.logger.info("Gateway scoped consoles synchronized for principal", {
+            chatId: input.principal.telegramChatId,
+            userId: input.principal.telegramUserId,
+            consoleCount: relaySessionIds.length,
+            activeSessionId: nextActive,
+        });
+        return {
+            sessionIds: relaySessionIds,
+            activeSessionId: nextActive,
+        };
+    }
+    async materializeRelaySession(input) {
+        const existingSession = await this.host.sessionStore.getSession(input.relaySessionId);
+        const label = this.buildConsoleLabel(input.consoleSession);
+        const projectName = input.consoleSession.project_names[0] ?? undefined;
+        const nextSession = {
+            sessionId: input.relaySessionId,
+            label,
+            activeProjectUuid: input.consoleSession.project_uuids[0] ?? undefined,
+            activeProjectName: projectName ?? undefined,
+            ...(input.consoleSession.cwd?.trim()
+                ? { cwd: input.consoleSession.cwd.trim() }
+                : {}),
+            updatedAt: new Date().toISOString(),
+        };
+        await this.host.sessionStore.setSession({
+            ...(existingSession ?? nextSession),
+            ...nextSession,
+            ...(nextSession.cwd
+                ? { cwd: nextSession.cwd }
+                : existingSession?.cwd
+                    ? { cwd: existingSession.cwd }
+                    : {}),
+            ...(existingSession?.task ? { task: existingSession.task } : {}),
+            ...(existingSession?.summary ? { summary: existingSession.summary } : {}),
+            ...(existingSession?.files ? { files: existingSession.files } : {}),
+            ...(existingSession?.decisions
+                ? { decisions: existingSession.decisions }
+                : {}),
+            ...(existingSession?.risks ? { risks: existingSession.risks } : {}),
+            ...(existingSession?.lastSeenToolsHash
+                ? { lastSeenToolsHash: existingSession.lastSeenToolsHash }
+                : {}),
+            ...(existingSession?.lastNotifiedToolsHash
+                ? { lastNotifiedToolsHash: existingSession.lastNotifiedToolsHash }
+                : {}),
+        });
+        await this.host.bindingStore.setBinding({
+            sessionId: input.relaySessionId,
+            telegramChatId: input.principal.telegramChatId,
+            telegramUserId: input.principal.telegramUserId,
+            ...(input.ctx?.from?.username
+                ? { telegramUsername: input.ctx.from.username }
+                : {}),
+            linkedAt: new Date().toISOString(),
+        });
+        return nextSession;
+    }
+    buildConsoleLabel(session) {
+        const base = session.session_label?.trim() || session.local_session_id.trim() || "console";
+        const owner = session.telegram_display_name?.trim() ||
+            session.telegram_username?.trim() ||
+            session.system_username?.trim() ||
+            session.client_label?.trim() ||
+            session.node_id?.trim() ||
+            session.client_uuid.slice(0, 8);
+        if (base.includes(this.labelSeparator)) {
+            return base;
+        }
+        return owner ? `${base} · ${owner}` : base;
+    }
+}
+exports.TransportConsoleRegistry = TransportConsoleRegistry;