@deadragdoll/tellymcp 0.0.10 → 0.0.11

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

@@ -0,0 +1,352 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportFileHandoffActions = void 0;
+const node_buffer_1 = require("node:buffer");
+const node_path_1 = __importDefault(require("node:path"));
+const grammy_1 = require("grammy");
+const xchangeRecordHints_1 = require("../../lib/xchangeRecordHints");
+const sqliteRecordStore_1 = require("../xchange/sqliteRecordStore");
+const client_1 = require("../terminal/client");
+const transportUtils_1 = require("./transportUtils");
+class TransportFileHandoffActions {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async beginModeForTarget(ctx, input) {
+        const principal = this.host.getPrincipalFromContext(ctx);
+        if (!principal) {
+            await ctx.answerCallbackQuery({
+                text: "Telegram user or chat is missing.",
+                show_alert: true,
+            });
+            return;
+        }
+        const session = await this.host.sessionStore.getSession(input.sessionId);
+        const meta = await this.host.xchangeFileMetaStore.getXchangeFileMeta(input.sessionId, input.filePath);
+        const fileName = meta?.originalName ||
+            (meta?.relativePath ? node_path_1.default.basename(meta.relativePath) : undefined) ||
+            node_path_1.default.basename(input.filePath);
+        const principalKey = (0, transportUtils_1.buildPrincipalKey)(principal);
+        const locale = await this.host.resolveLocaleForContext(ctx);
+        await ctx.answerCallbackQuery({
+            text: this.host.t(locale, "menu:handoff.prompt_title"),
+        });
+        const sent = await this.host.replyText(ctx, [
+            this.host.t(locale, "menu:handoff.prompt_title"),
+            "",
+            this.host.t(locale, "menu:handoff.route", {
+                sourceSessionName: session?.label ?? input.sessionId,
+                targetSessionName: input.targetSessionLabel,
+            }),
+            this.host.t(locale, "menu:handoff.recipient", {
+                label: input.targetSessionLabel,
+            }),
+            this.host.t(locale, "menu:handoff.file", { fileName }),
+            "",
+            this.host.t(locale, "menu:handoff.prompt_body"),
+            this.host.t(locale, "menu:handoff.prompt_hint"),
+        ].join("\n"), { kind: "menu", sessionId: input.sessionId }, {
+            reply_markup: new grammy_1.InlineKeyboard().text(this.host.t(locale, "menu:handoff.cancel"), "file-handoff-cancel"),
+        });
+        this.host.pendingFileHandoffs.set(principalKey, {
+            sessionId: input.sessionId,
+            filePath: input.filePath,
+            target: "partner",
+            targetSessionId: input.targetSessionId,
+            targetSessionLabel: input.targetSessionLabel,
+            ...(input.projectUuid ? { projectUuid: input.projectUuid } : {}),
+            initiatedAt: new Date().toISOString(),
+            ...(sent && "message_id" in sent ? { promptMessageId: sent.message_id } : {}),
+        });
+    }
+    async cancelPending(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.pendingFileHandoffs.get(principalKey);
+        if (!pending) {
+            await ctx.answerCallbackQuery({
+                text: this.host.t(locale, "menu:handoff.no_pending"),
+                show_alert: true,
+            });
+            return;
+        }
+        this.host.pendingFileHandoffs.delete(principalKey);
+        await this.deletePendingPrompt(ctx, pending);
+        await ctx.answerCallbackQuery({
+            text: this.host.t(locale, "menu:handoff.cancelled"),
+        });
+        if (pending.projectUuid && pending.targetSessionId && pending.targetSessionLabel) {
+            const project = await this.host.getProjectPayloadByUuid(pending.sessionId, pending.projectUuid);
+            if (project) {
+                await this.host.showProjectMemberDetail(ctx, {
+                    sessionId: pending.sessionId,
+                    projectUuid: pending.projectUuid,
+                    projectName: project.projectName,
+                    targetSessionId: pending.targetSessionId,
+                    targetSessionLabel: pending.targetSessionLabel,
+                    ...(project.inviteToken ? { inviteToken: project.inviteToken } : {}),
+                });
+                return;
+            }
+        }
+        if (pending.projectUuid) {
+            await this.host.showProjectsMenu(ctx);
+            return;
+        }
+        await this.host.showMainMenu(ctx);
+    }
+    async handlePending(ctx, text) {
+        const locale = await this.host.resolveLocaleForContext(ctx);
+        const principal = this.host.getPrincipalFromContext(ctx);
+        if (!principal) {
+            return false;
+        }
+        const principalKey = (0, transportUtils_1.buildPrincipalKey)(principal);
+        const pending = this.host.pendingFileHandoffs.get(principalKey);
+        if (!pending) {
+            return false;
+        }
+        if (text.startsWith("/")) {
+            this.host.pendingFileHandoffs.delete(principalKey);
+            await this.deletePendingPrompt(ctx, pending);
+            return false;
+        }
+        const description = text.trim();
+        if (!description) {
+            return true;
+        }
+        if (pending.target === "agent") {
+            await this.deliverToAgent({
+                principal,
+                sessionId: pending.sessionId,
+                filePath: pending.filePath,
+                sourceTelegramMessageId: ctx.message?.message_id ?? 0,
+                description,
+            });
+            this.host.pendingFileHandoffs.delete(principalKey);
+            await this.deletePendingPrompt(ctx, pending);
+            await this.host.replyText(ctx, this.host.t(locale, "menu:handoff.delivered_agent"), { kind: "menu", sessionId: pending.sessionId });
+            return true;
+        }
+        if (pending.projectUuid) {
+            await this.host.ensureProjectSessionRegistered({
+                principal,
+                sessionId: pending.sessionId,
+                projectUuid: pending.projectUuid,
+            });
+        }
+        const output = await this.deliverToPartner({
+            sessionId: pending.sessionId,
+            filePath: pending.filePath,
+            description,
+            ...(pending.targetSessionId ? { targetSessionId: pending.targetSessionId } : {}),
+            ...(pending.projectUuid ? { projectUuid: pending.projectUuid } : {}),
+        });
+        this.host.pendingFileHandoffs.delete(principalKey);
+        await this.deletePendingPrompt(ctx, pending);
+        const sent = await this.host.replyText(ctx, [
+            this.host.t(locale, "menu:handoff.queued_partner"),
+            ...(output.project_name
+                ? [this.host.t(locale, "menu:handoff.project", { projectName: output.project_name })]
+                : []),
+            ...(output.target_actor_label
+                ? [this.host.t(locale, "menu:handoff.recipient", { label: output.target_actor_label })]
+                : []),
+            ...(output.target_session_label
+                ? [this.host.t(locale, "menu:handoff.session", { label: output.target_session_label })]
+                : []),
+            this.host.t(locale, "menu:handoff.status", {
+                status: output.delivery_status === "delivered"
+                    ? this.host.t(locale, "menu:handoff.delivered")
+                    : this.host.t(locale, "menu:handoff.queued"),
+            }),
+            this.host.t(locale, "menu:handoff.share", { shareId: output.share_id }),
+        ].join("\n"), { kind: "menu", sessionId: pending.sessionId });
+        if (output.delivery_status === "queued" && sent && "message_id" in sent && ctx.chat) {
+            const meta = await this.host.xchangeFileMetaStore.getXchangeFileMeta(pending.sessionId, pending.filePath);
+            const fileName = meta?.originalName ||
+                (meta?.relativePath ? node_path_1.default.basename(meta.relativePath) : undefined) ||
+                node_path_1.default.basename(pending.filePath);
+            const handoffSummary = description
+                .split(/\r?\n/u)
+                .map((line) => line.trim())
+                .find(Boolean) ?? `Передача файла: ${fileName}`;
+            await this.host.maintenanceStore.setOutgoingDeliveryNotice({
+                deliveryUuid: output.inbox_message_id,
+                sessionId: pending.sessionId,
+                telegramChatId: ctx.chat.id,
+                telegramMessageId: sent.message_id,
+                shareId: output.share_id,
+                kind: output.kind,
+                summary: handoffSummary,
+                ...(output.project_name ? { projectName: output.project_name } : {}),
+                ...(output.target_actor_label
+                    ? { targetLabel: output.target_actor_label }
+                    : pending.targetSessionLabel
+                        ? { targetLabel: pending.targetSessionLabel }
+                        : {}),
+                ...(output.target_session_label ? { targetSessionLabel: output.target_session_label } : {}),
+            });
+        }
+        return true;
+    }
+    async deliverToPartnerPublic(input) {
+        return this.deliverToPartner(input);
+    }
+    async deletePendingPrompt(ctx, pending) {
+        if (!pending.promptMessageId) {
+            return;
+        }
+        try {
+            await this.host.deleteMessage(ctx.chat.id, pending.promptMessageId);
+        }
+        catch (error) {
+            this.host.logger.warn("Failed to delete pending file handoff prompt", {
+                sessionId: pending.sessionId,
+                promptMessageId: pending.promptMessageId,
+                target: pending.target,
+                error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+            });
+        }
+    }
+    async deliverToAgent(input) {
+        const meta = await this.host.xchangeFileMetaStore.getXchangeFileMeta(input.sessionId, input.filePath);
+        const session = await this.host.sessionStore.getSession(input.sessionId);
+        const fileName = meta?.originalName ||
+            (meta?.relativePath ? node_path_1.default.basename(meta.relativePath) : undefined) ||
+            node_path_1.default.basename(input.filePath);
+        const handoffSummary = input.description
+            .split(/\r?\n/u)
+            .map((line) => line.trim())
+            .find(Boolean) ?? `Локальная передача файла: ${fileName}`;
+        const now = new Date();
+        const createdAt = now.toISOString();
+        const handoffId = (0, transportUtils_1.buildLocalHandoffId)(fileName, now);
+        const relativeArtifactPath = `local/files/${handoffId}/${fileName}`;
+        const ensuredFilePath = meta?.storageRef
+            ? await this.host.objectStore.ensureLocalFile({
+                sessionId: input.sessionId,
+                session,
+                filePath: input.filePath,
+                relativePath: relativeArtifactPath,
+                storageRef: meta.storageRef,
+                source: "partner-artifact",
+            })
+            : input.filePath;
+        const workspaceDir = this.host.objectStore.resolveWorkspaceDir(session);
+        const relativeNotePath = `local/${handoffId}.md`;
+        const noteContent = (0, transportUtils_1.buildLocalNoteContent)({
+            handoffId,
+            createdAt,
+            sessionId: input.sessionId,
+            ...(session?.label ? { sessionLabel: session.label } : {}),
+            filePath: ensuredFilePath,
+            description: input.description,
+        });
+        const notePath = await (0, client_1.writeXchangeRelativeFile)(this.host.config.terminal, workspaceDir, this.host.config.exchange.dir, relativeNotePath, node_buffer_1.Buffer.from(noteContent, "utf8"));
+        await (0, sqliteRecordStore_1.upsertXchangeRecord)(this.host.config.terminal, workspaceDir, this.host.config.exchange.dir, {
+            record_id: handoffId,
+            session_id: input.sessionId,
+            category: "local_handoff",
+            direction: "local",
+            status: "new",
+            kind: "local-file",
+            summary: handoffSummary,
+            body_text: noteContent,
+            action_desc: (0, xchangeRecordHints_1.buildLocalHandoffActionDesc)(),
+            tools: (0, xchangeRecordHints_1.buildLocalHandoffTools)(),
+            note_path: notePath,
+            note_relative_path: relativeNotePath,
+            attachments: [
+                {
+                    file_path: notePath,
+                    relative_path: relativeNotePath,
+                    original_name: node_path_1.default.basename(relativeNotePath),
+                    mime_type: "text/markdown",
+                    size_bytes: node_buffer_1.Buffer.byteLength(noteContent, "utf8"),
+                },
+                {
+                    file_path: ensuredFilePath,
+                    relative_path: relativeArtifactPath,
+                    original_name: fileName,
+                    ...(meta?.mimeType ? { mime_type: meta.mimeType } : {}),
+                    ...(typeof meta?.sizeBytes === "number" ? { size_bytes: meta.sizeBytes } : {}),
+                    ...(meta?.storageRef ? { storage_ref: meta.storageRef } : {}),
+                },
+            ],
+            tags: ["local", "handoff", "file"],
+            created_at: createdAt,
+            updated_at: createdAt,
+        });
+        try {
+            await this.host.nudgeSessionInbox(input.sessionId);
+        }
+        catch (error) {
+            this.host.logger.warn("terminal nudge failed after local agent handoff", {
+                sessionId: input.sessionId,
+                handoffId,
+                filePath: ensuredFilePath,
+                error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+            });
+        }
+    }
+    async deliverToPartner(input) {
+        const meta = await this.host.xchangeFileMetaStore.getXchangeFileMeta(input.sessionId, input.filePath);
+        const session = await this.host.sessionStore.getSession(input.sessionId);
+        const fileName = meta?.originalName ||
+            (meta?.relativePath ? node_path_1.default.basename(meta.relativePath) : undefined) ||
+            node_path_1.default.basename(input.filePath);
+        const localFilePath = await this.host.objectStore.ensureLocalFile({
+            sessionId: input.sessionId,
+            session,
+            filePath: input.filePath,
+            source: meta?.source ?? "telegram-upload",
+            ...(meta?.relativePath ? { relativePath: meta.relativePath } : {}),
+            ...(meta?.storageRef ? { storageRef: meta.storageRef } : {}),
+        });
+        const fileContent = await (0, client_1.readWorkspaceFile)(this.host.config.terminal, this.host.objectStore.resolveWorkspaceDir(session), localFilePath);
+        const handoffSummary = input.description
+            .split(/\r?\n/u)
+            .map((line) => line.trim())
+            .find(Boolean) ?? `Передача файла: ${fileName}`;
+        return this.host.sendPartnerNote({
+            session_id: input.sessionId,
+            ...(input.targetSessionId ? { target_session_id: input.targetSessionId } : {}),
+            ...(input.projectUuid ? { project_uuid: input.projectUuid } : {}),
+            kind: "handoff",
+            summary: handoffSummary,
+            message: [
+                "Partner sent a file for the current task.",
+                `File: ${fileName}`,
+                "",
+                "Description:",
+                input.description,
+                ...(meta?.caption ? ["", "Caption:", meta.caption] : []),
+            ].join("\n"),
+            artifacts: [input.filePath],
+            artifact_refs: [
+                {
+                    file_path: input.filePath,
+                    ...(meta?.relativePath ? { relative_path: meta.relativePath } : {}),
+                    ...(meta?.originalName ? { original_name: meta.originalName } : { original_name: fileName }),
+                    ...(meta?.mimeType ? { mime_type: meta.mimeType } : {}),
+                    ...(typeof meta?.sizeBytes === "number" ? { size_bytes: meta.sizeBytes } : {}),
+                    content_base64: node_buffer_1.Buffer.from(fileContent).toString("base64"),
+                },
+            ],
+        });
+    }
+}
+exports.TransportFileHandoffActions = TransportFileHandoffActions;

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

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAdminClientSessionButtonLabel = buildAdminClientSessionButtonLabel;
+exports.buildAdminClientSessionViewButtonLabel = buildAdminClientSessionViewButtonLabel;
+exports.formatFilePreviewLabel = formatFilePreviewLabel;
+exports.formatStoragePreviewLabel = formatStoragePreviewLabel;
+exports.formatSessionMenuLabel = formatSessionMenuLabel;
+exports.buildInboxText = buildInboxText;
+exports.parsePartnerNoteText = parsePartnerNoteText;
+const node_path_1 = __importDefault(require("node:path"));
+function buildAdminClientSessionButtonLabel(session) {
+    const sessionName = (session.label?.trim() || session.local_session_id).trim();
+    const projectName = session.project_name?.trim() || null;
+    return projectName
+        ? `${sessionName} · ${projectName}`.slice(0, 56)
+        : sessionName.slice(0, 56);
+}
+function buildAdminClientSessionViewButtonLabel(session) {
+    const markers = [
+        session.is_connected ? "🟢" : null,
+        session.is_collab ? "👥" : null,
+    ]
+        .filter(Boolean)
+        .join("");
+    const prefix = markers ? `${markers} ` : "";
+    return `${prefix}${buildAdminClientSessionButtonLabel(session)}`.slice(0, 56);
+}
+function formatFilePreviewLabel(filePath, meta) {
+    return (meta?.originalName ||
+        (meta?.relativePath ? node_path_1.default.basename(meta.relativePath) : undefined) ||
+        node_path_1.default.basename(filePath));
+}
+function formatStoragePreviewLabel(filePath, meta) {
+    const base = formatFilePreviewLabel(filePath, meta);
+    const prefix = meta?.source === "browser-screenshot"
+        ? "📸 "
+        : meta?.source === "partner-artifact"
+            ? "🤝 "
+            : "📄 ";
+    return `${prefix}${base}`.slice(0, 56);
+}
+function formatSessionMenuLabel(input) {
+    const base = input.sessionLabel ?? input.sessionId;
+    return `📁 ${base}`;
+}
+function buildInboxText(text, attachments) {
+    const lines = [];
+    if (text) {
+        lines.push(text);
+    }
+    if (attachments.length > 0) {
+        if (lines.length > 0) {
+            lines.push("");
+        }
+        lines.push("Files saved in .mcp-xchange:");
+        lines.push(...attachments.map((attachment) => `- ${attachment}`));
+    }
+    if (lines.length === 0) {
+        return "Files uploaded from Telegram.";
+    }
+    return lines.join("\n");
+}
+function parsePartnerNoteText(text) {
+    const normalized = text.trim();
+    const lines = normalized.split("\n");
+    const summary = lines[0]?.trim() || normalized;
+    const body = lines.slice(1).join("\n").replace(/^\s*\n/u, "").trim();
+    return {
+        summary,
+        message: body || normalized,
+    };
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportGatewayActions = void 0;
+class TransportGatewayActions {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async sendPartnerNote(input) {
+        const collaborationService = this.host.getCollaborationService();
+        if (collaborationService) {
+            return collaborationService.sendPartnerNote(input);
+        }
+        throw new Error("Collaboration service is not configured");
+    }
+    async ensureGatewayClientUuid(principal, actor) {
+        return this.host.projectState.ensureGatewayClientUuid(principal, actor);
+    }
+    async listGatewayProjects(principal, actor) {
+        return this.host.projectState.listGatewayProjects(principal, actor);
+    }
+    async listGatewayProjectSessions(principal, projectUuid) {
+        return this.host.projectState.listGatewayProjectSessions(principal, projectUuid);
+    }
+    async listGatewaySessionHistory(principal, localSessionId) {
+        return this.host.projectState.listGatewaySessionHistory(principal, localSessionId);
+    }
+    async ensureProjectSessionRegistered(input) {
+        await this.host.projectState.ensureProjectSessionRegistered(input);
+    }
+    async loadProjectsContext(ctx) {
+        return this.host.projectState.loadProjectsContext(ctx);
+    }
+    async activateProjectForSession(input) {
+        await this.host.projectState.activateProjectForSession(input);
+    }
+    async ensureOpenedProjectIsActive(input) {
+        await this.host.projectState.ensureOpenedProjectIsActive(input);
+    }
+    async buildProjectsFingerprint(ctx) {
+        return this.host.projectState.buildProjectsFingerprint(ctx);
+    }
+}
+exports.TransportGatewayActions = TransportGatewayActions;

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

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransportLifecycleActions = void 0;
+const versionHandshake_1 = require("../../lib/version/versionHandshake");
+const transportUtils_1 = require("./transportUtils");
+class TransportLifecycleActions {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    async sendStartupNotifications(runtimeDirname) {
+        if (!this.host.isTelegramEnabled()) {
+            this.host.logger.debug("Startup notifications skipped because Telegram transport is disabled");
+            return;
+        }
+        const packageVersion = (0, versionHandshake_1.getTellyMcpPackageVersion)(runtimeDirname);
+        const availableUpdate = await (0, versionHandshake_1.detectAvailablePackageUpdate)({
+            currentVersion: packageVersion,
+        });
+        if (availableUpdate) {
+            this.host.logger.warn("A newer TellyMCP package version is available", {
+                currentVersion: availableUpdate.currentVersion,
+                latestVersion: availableUpdate.latestVersion,
+                packageName: versionHandshake_1.TELLYMCP_PACKAGE_NAME,
+            });
+        }
+        const sessions = await this.host.sessionStore.listSessions();
+        const groupedRecipients = new Map();
+        for (const session of sessions) {
+            const binding = await this.host.bindingStore.getBinding(session.sessionId);
+            if (!binding) {
+                continue;
+            }
+            const key = `${binding.telegramChatId}:${binding.telegramUserId}`;
+            const current = groupedRecipients.get(key);
+            if (current) {
+                current.sessionIds.push(session.sessionId);
+                current.sessionLabels.push(session.label ?? session.sessionId);
+                continue;
+            }
+            groupedRecipients.set(key, {
+                binding: {
+                    telegramChatId: binding.telegramChatId,
+                    telegramUserId: binding.telegramUserId,
+                },
+                sessionIds: [session.sessionId],
+                sessionLabels: [session.label ?? session.sessionId],
+            });
+        }
+        if (groupedRecipients.size === 0) {
+            this.host.logger.info("Skipping startup notifications because no sessions have an active Telegram route");
+            return;
+        }
+        const runtimePort = this.host.config.distributed.mode === "gateway" ||
+            this.host.config.distributed.mode === "both"
+            ? Number(process.env.PORT || this.host.config.mcp.httpPort)
+            : this.host.config.mcp.httpPort;
+        const rootPrefix = this.host.config.distributed.mode === "gateway" ||
+            this.host.config.distributed.mode === "both"
+            ? (0, transportUtils_1.normalizeBasePath)(process.env.ROOT_PREFIX || "/api")
+            : "";
+        const localMcpPath = this.host.config.distributed.mode === "gateway" ||
+            this.host.config.distributed.mode === "both"
+            ? (0, transportUtils_1.joinHttpPath)(rootPrefix, this.host.config.mcp.httpPath)
+            : this.host.config.mcp.httpPath;
+        const localWebappPath = this.host.config.distributed.mode === "gateway" ||
+            this.host.config.distributed.mode === "both"
+            ? (0, transportUtils_1.joinHttpPath)(rootPrefix, this.host.config.webapp.basePath)
+            : this.host.config.webapp.basePath;
+        const localMcpUrl = `http://${this.host.config.mcp.httpHost}:${runtimePort}${localMcpPath}`;
+        const localWebappUrl = `http://${this.host.config.mcp.httpHost}:${runtimePort}${localWebappPath}`;
+        for (const recipientGroup of groupedRecipients.values()) {
+            const primarySessionId = recipientGroup.sessionIds[0];
+            if (!primarySessionId) {
+                continue;
+            }
+            const locale = await this.host.resolveLocaleForTelegramUserId(recipientGroup.binding.telegramUserId);
+            const uniqueSessionLabels = Array.from(new Set(recipientGroup.sessionLabels)).sort();
+            const browserStatus = this.host.config.browser.enabled
+                ? (this.host.config.browser.headless ? "enabled, headless" : "enabled, headed")
+                : "disabled";
+            const startupMessage = [
+                this.host.t(locale, "menu:notices.startup.title"),
+                this.host.t(locale, "menu:notices.startup.version", {
+                    packageVersion,
+                }),
+                this.host.t(locale, "menu:notices.startup.protocol", {
+                    protocolVersion: versionHandshake_1.TELLYMCP_PROTOCOL_VERSION,
+                }),
+                this.host.t(locale, "menu:notices.startup.mode", {
+                    mode: this.host.config.distributed.mode,
+                }),
+                ...(this.host.config.telegram.botUsername
+                    ? [
+                        this.host.t(locale, "menu:notices.startup.bot", {
+                            botUsername: this.host.config.telegram.botUsername.replace(/^@/u, ""),
+                        }),
+                    ]
+                    : []),
+                this.host.t(locale, "menu:notices.startup.sessions", {
+                    count: uniqueSessionLabels.length,
+                }),
+                this.host.t(locale, "menu:notices.startup.session_list", {
+                    sessions: uniqueSessionLabels.join(", "),
+                }),
+                this.host.t(locale, "menu:notices.startup.mcp", {
+                    url: localMcpUrl,
+                }),
+                ...(this.host.config.webapp.enabled
+                    ? [this.host.t(locale, "menu:notices.startup.webapp", { url: localWebappUrl })]
+                    : []),
+                ...(this.host.config.distributed.gatewayPublicUrl
+                    ? [
+                        this.host.t(locale, "menu:notices.startup.gateway", {
+                            url: this.host.config.distributed.gatewayPublicUrl,
+                        }),
+                    ]
+                    : []),
+                ...(this.host.config.distributed.gatewayWsUrl
+                    ? [
+                        this.host.t(locale, "menu:notices.startup.gateway_ws", {
+                            url: this.host.config.distributed.gatewayWsUrl,
+                        }),
+                    ]
+                    : []),
+                this.host.t(locale, "menu:notices.startup.browser", {
+                    status: browserStatus,
+                }),
+                ...(availableUpdate
+                    ? [
+                        this.host.t(locale, "menu:notices.startup.update_available", {
+                            currentVersion: availableUpdate.currentVersion,
+                            latestVersion: availableUpdate.latestVersion,
+                        }),
+                        this.host.t(locale, "menu:notices.startup.update_command", {
+                            packageName: versionHandshake_1.TELLYMCP_PACKAGE_NAME,
+                            latestVersion: availableUpdate.latestVersion,
+                        }),
+                    ]
+                    : []),
+                this.host.t(locale, "menu:notices.startup.hint"),
+            ].join("\n");
+            try {
+                await this.host.sendNotification({
+                    sessionId: primarySessionId,
+                    sessionLabel: "TellyMCP",
+                    recipient: recipientGroup.binding,
+                    message: startupMessage,
+                });
+            }
+            catch (error) {
+                this.host.logger.warn("Failed to deliver Telegram startup notification", {
+                    telegramChatId: recipientGroup.binding.telegramChatId,
+                    telegramUserId: recipientGroup.binding.telegramUserId,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+    }
+}
+exports.TransportLifecycleActions = TransportLifecycleActions;