@deadragdoll/tellymcp 0.0.1

package/dist/services/features/telegram-mcp/gateway-delivery.service.js

@@ -0,0 +1,378 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEGRAM_MCP_GATEWAY_DELIVERY_SERVICE_NAME = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const runtime_service_1 = require("./runtime.service");
+const ids_1 = require("./src/shared/lib/ids/ids");
+const client_1 = require("./src/shared/integrations/tmux/client");
+exports.TELEGRAM_MCP_GATEWAY_DELIVERY_SERVICE_NAME = "telegramMcp.gatewayDelivery";
+function renderYamlArray(values) {
+    if (values.length === 0) {
+        return "[]";
+    }
+    return `\n${values.map((value) => `  - ${JSON.stringify(value)}`).join("\n")}`;
+}
+function buildNoteContent(input) {
+    const lines = ["---"];
+    lines.push(`message_uuid: ${JSON.stringify(input.delivery.message_uuid)}`);
+    lines.push(`kind: ${JSON.stringify(input.delivery.kind)}`);
+    lines.push(`from_session_id: ${JSON.stringify(input.delivery.source_session_uuid)}`);
+    lines.push(`from_label: ${JSON.stringify(input.delivery.source_session_label)}`);
+    lines.push(`to_session_id: ${JSON.stringify(input.delivery.target_session_uuid)}`);
+    lines.push(`to_label: ${JSON.stringify(input.delivery.target_session_label)}`);
+    lines.push(`created_at: ${JSON.stringify(input.delivery.created_at)}`);
+    if (input.delivery.project_uuid) {
+        lines.push(`project_uuid: ${JSON.stringify(input.delivery.project_uuid)}`);
+    }
+    if (input.delivery.requires_reply) {
+        lines.push("requires_reply: true");
+    }
+    if (input.delivery.in_reply_to) {
+        lines.push(`in_reply_to: ${JSON.stringify(input.delivery.in_reply_to)}`);
+    }
+    if (input.copiedArtifacts.length > 0) {
+        lines.push(`artifacts:${renderYamlArray(input.copiedArtifacts)}`);
+    }
+    lines.push("---", "", "# Summary", input.delivery.summary.trim(), "", "# Message", input.delivery.message.trim());
+    if (input.delivery.expected_reply?.trim()) {
+        lines.push("", "# Expected Reply", input.delivery.expected_reply.trim());
+    }
+    if (input.delivery.requires_reply) {
+        lines.push("", "# Reply Params", `message_uuid: ${input.delivery.message_uuid}`, `target_session_id: ${input.delivery.source_session_uuid}`, ...(input.delivery.project_uuid
+            ? [`project_uuid: ${input.delivery.project_uuid}`]
+            : []), "", "# Action Required", "You must send a reply via send_partner_note.", "Your task is not complete until send_partner_note succeeds.", "Do not stop after local analysis or a chat explanation.", "Do not rely on linked partner.", "Pass target_session_id explicitly.", "If possible, also pass in_reply_to=message_uuid.", "Only after the tool succeeds may you say that the reply was sent.", "", "# Reply Tool Call Example", "send_partner_note(", `  session_id=${JSON.stringify(input.delivery.target_local_session_id)},`, `  target_session_id=${JSON.stringify(input.delivery.source_session_uuid)},`, `  kind=${JSON.stringify("reply")},`, ...(input.delivery.project_uuid
+            ? [`  project_uuid=${JSON.stringify(input.delivery.project_uuid)},`]
+            : []), `  in_reply_to=${JSON.stringify(input.delivery.message_uuid)},`, "  summary=\"Короткий итог\",", "  message=\"Подробный ответ\"", ")");
+    }
+    if (input.copiedArtifacts.length > 0) {
+        lines.push("", "# Artifacts", ...input.copiedArtifacts.map((artifact) => `- ${artifact}`));
+    }
+    return `${lines.join("\n")}\n`;
+}
+function buildShareIndexLine(input) {
+    return [
+        "-",
+        `[${input.delivery.created_at}]`,
+        `${input.delivery.source_session_label} → ${input.delivery.target_session_label}`,
+        `| ${input.delivery.kind} |`,
+        `${input.delivery.summary}`,
+        `| \`${input.relativeNotePath}\``,
+    ].join(" ");
+}
+function buildPartnerInboxText(input) {
+    const sourceActorLabel = input.delivery.source_actor_label || input.delivery.source_session_label;
+    const kindTitle = input.delivery.kind === "question"
+        ? `Получен вопрос от ${sourceActorLabel}.`
+        : input.delivery.kind === "reply"
+            ? `Получен ответ от ${sourceActorLabel}.`
+            : input.delivery.kind === "request"
+                ? `Получен запрос от ${sourceActorLabel}.`
+                : input.delivery.kind === "handoff"
+                    ? `Получен handoff от ${sourceActorLabel}.`
+                    : `Получено обновление от ${sourceActorLabel}.`;
+    return [
+        kindTitle,
+        ...(input.delivery.project_name
+            ? [`Проект: ${input.delivery.project_name}`]
+            : []),
+        `Сессия: ${input.delivery.source_session_label} -> ${input.delivery.target_session_label}`,
+        `Кратко: ${input.delivery.summary}`,
+        "",
+        `Действие: открой ${input.delivery.share_index_file_name}, затем note ниже.`,
+        `Note: ${input.notePath}`,
+        ...(input.copiedArtifacts.length > 0
+            ? ["", "Файлы:", ...input.copiedArtifacts.map((item) => `- ${item}`)]
+            : []),
+        ...(input.delivery.requires_reply
+            ? [
+                "",
+                `Reply message_uuid: ${input.delivery.message_uuid}`,
+                `Reply target_session_id: ${input.delivery.source_session_uuid}`,
+                ...(input.delivery.project_uuid
+                    ? [`Reply project_uuid: ${input.delivery.project_uuid}`]
+                    : []),
+                "Обязательно отправь reply через send_partner_note.",
+                "Задача не завершена, пока send_partner_note не отработал успешно.",
+                "Не останавливайся на локальном объяснении.",
+                "Не используй linked partner для ответа. Передай эти параметры явно в send_partner_note.",
+                "Только после успешного tool call можно считать ответ отправленным.",
+            ]
+            : []),
+    ].join("\n");
+}
+function buildTelegramDeliveryNotification(input) {
+    const sourceActorLabel = input.delivery.source_actor_label || input.delivery.source_session_label;
+    const kindTitle = input.delivery.kind === "question"
+        ? `Получен вопрос от ${sourceActorLabel}.`
+        : input.delivery.kind === "reply"
+            ? `Получен ответ от ${sourceActorLabel}.`
+            : input.delivery.kind === "request"
+                ? `Получен запрос от ${sourceActorLabel}.`
+                : input.delivery.kind === "handoff"
+                    ? input.copiedArtifacts.length > 0
+                        ? `Получен файл от ${sourceActorLabel}.`
+                        : `Получен handoff от ${sourceActorLabel}.`
+                    : `Получено обновление от ${sourceActorLabel}.`;
+    return [
+        kindTitle,
+        ...(input.delivery.project_name
+            ? [`Проект: ${input.delivery.project_name}`]
+            : []),
+        `Сессия: ${input.delivery.source_session_label} -> ${input.delivery.target_session_label}`,
+        `Тип: ${input.delivery.kind}`,
+        `Кратко: ${input.delivery.summary}`,
+        ...(input.copiedArtifacts.length > 0
+            ? [
+                "",
+                `Файлы: ${input.copiedArtifacts.length}`,
+                ...input.copiedArtifacts.map((item) => `- ${node_path_1.default.basename(item)}`),
+            ]
+            : []),
+        ...(input.delivery.requires_reply
+            ? [
+                "",
+                `Reply message_uuid: ${input.delivery.message_uuid}`,
+                `Reply target_session_id: ${input.delivery.source_session_uuid}`,
+                ...(input.delivery.project_uuid
+                    ? [`Reply project_uuid: ${input.delivery.project_uuid}`]
+                    : []),
+            ]
+            : []),
+        "",
+        `Note: ${input.notePath}`,
+    ].join("\n");
+}
+function buildOutgoingDeliveredText(input) {
+    return [
+        "✅ Доставка выполнена.",
+        ...(input.notice.projectName ? [`Проект: ${input.notice.projectName}`] : []),
+        ...(input.notice.targetLabel
+            ? [`Получатель: ${input.notice.targetLabel}`]
+            : []),
+        ...(input.notice.targetSessionLabel &&
+            input.notice.targetSessionLabel !== input.notice.targetLabel
+            ? [`Сессия: ${input.notice.targetSessionLabel}`]
+            : []),
+        `Тип: ${input.notice.kind}`,
+        "Статус: доставлено",
+        `Кратко: ${input.notice.summary}`,
+        `Share: ${input.notice.shareId || input.status.share_id}`,
+    ].join("\n");
+}
+function buildOutgoingFailedText(input) {
+    return [
+        "❌ Доставка не выполнена.",
+        ...(input.notice.projectName ? [`Проект: ${input.notice.projectName}`] : []),
+        ...(input.notice.targetLabel
+            ? [`Получатель: ${input.notice.targetLabel}`]
+            : []),
+        ...(input.notice.targetSessionLabel &&
+            input.notice.targetSessionLabel !== input.notice.targetLabel
+            ? [`Сессия: ${input.notice.targetSessionLabel}`]
+            : []),
+        `Тип: ${input.notice.kind}`,
+        "Статус: ошибка",
+        `Кратко: ${input.notice.summary}`,
+        `Share: ${input.notice.shareId || input.status.share_id}`,
+    ].join("\n");
+}
+const TelegramMcpGatewayDeliveryService = {
+    name: exports.TELEGRAM_MCP_GATEWAY_DELIVERY_SERVICE_NAME,
+    dependencies: [runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME],
+    methods: {
+        getRuntimeOrThrow() {
+            const runtimeService = this.runtimeService ??
+                this.broker.getLocalService(runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME);
+            if (!runtimeService) {
+                throw new Error(`Local Moleculer service '${runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME}' is unavailable`);
+            }
+            this.runtimeService = runtimeService;
+            return runtimeService.getRuntime();
+        },
+        async materializeIncomingDelivery(delivery) {
+            const runtime = this.getRuntimeOrThrow?.();
+            if (!runtime) {
+                throw new Error("Runtime is unavailable");
+            }
+            const targetSession = await runtime.sessionStore.getSession(delivery.target_local_session_id);
+            if (!targetSession) {
+                runtime.logger.warn("Skipping gateway delivery because target local session is not available", {
+                    deliveryUuid: delivery.delivery_uuid,
+                    targetLocalSessionId: delivery.target_local_session_id,
+                });
+                return;
+            }
+            const targetBinding = await runtime.bindingStore.getBinding(targetSession.sessionId);
+            if (!targetBinding) {
+                runtime.logger.warn("Skipping gateway delivery because target session is not paired with Telegram", {
+                    deliveryUuid: delivery.delivery_uuid,
+                    sessionId: targetSession.sessionId,
+                });
+                return;
+            }
+            const copiedArtifacts = [];
+            for (const artifact of delivery.artifacts) {
+                const relativePath = artifact.relative_path ||
+                    `shares/files/${delivery.share_id}/${artifact.original_name}`;
+                let localArtifactPath;
+                if (artifact.content_base64) {
+                    localArtifactPath = await (0, client_1.writeXchangeRelativeFile)(runtime.config.tmux, runtime.objectStore.resolveWorkspaceDir(targetSession), runtime.config.exchange.dir, relativePath, Buffer.from(artifact.content_base64, "base64"));
+                }
+                else {
+                    localArtifactPath = await runtime.objectStore.ensureLocalFile({
+                        sessionId: targetSession.sessionId,
+                        session: targetSession,
+                        filePath: artifact.original_name,
+                        relativePath,
+                        storageRef: artifact.storage_ref,
+                        source: "partner-artifact",
+                    });
+                }
+                copiedArtifacts.push(localArtifactPath);
+                await runtime.xchangeFileMetaStore.setXchangeFileMeta({
+                    sessionId: targetSession.sessionId,
+                    filePath: localArtifactPath,
+                    relativePath,
+                    source: "partner-artifact",
+                    uploadedAt: delivery.created_at,
+                    originalName: artifact.original_name,
+                    ...(artifact.mime_type ? { mimeType: artifact.mime_type } : {}),
+                    ...(typeof artifact.size_bytes === "number"
+                        ? { sizeBytes: artifact.size_bytes }
+                        : {}),
+                });
+            }
+            const noteContent = buildNoteContent({ delivery, copiedArtifacts });
+            const notePath = await (0, client_1.writeXchangeRelativeFile)(runtime.config.tmux, runtime.objectStore.resolveWorkspaceDir(targetSession), runtime.config.exchange.dir, delivery.note_relative_path, Buffer.from(noteContent, "utf8"));
+            await runtime.xchangeFileMetaStore.setXchangeFileMeta({
+                sessionId: targetSession.sessionId,
+                filePath: notePath,
+                relativePath: delivery.note_relative_path,
+                source: "partner-artifact",
+                uploadedAt: delivery.created_at,
+                mimeType: "text/markdown",
+                sizeBytes: Buffer.byteLength(noteContent, "utf8"),
+            });
+            await (0, client_1.writeXchangeRelativeFile)(runtime.config.tmux, runtime.objectStore.resolveWorkspaceDir(targetSession), runtime.config.exchange.dir, delivery.share_index_file_name, Buffer.from(`${buildShareIndexLine({
+                delivery,
+                relativeNotePath: delivery.note_relative_path,
+            })}\n`, "utf8"), { append: true });
+            const inboxMessage = {
+                id: (0, ids_1.createInboxMessageId)(new Date(delivery.created_at)),
+                sessionId: targetSession.sessionId,
+                telegramChatId: targetBinding.telegramChatId,
+                telegramUserId: targetBinding.telegramUserId,
+                sourceTelegramMessageId: Date.now(),
+                text: buildPartnerInboxText({
+                    delivery,
+                    notePath,
+                    copiedArtifacts,
+                }),
+                attachments: [notePath, ...copiedArtifacts],
+                receivedAt: delivery.created_at,
+            };
+            await runtime.inboxStore.createInboxMessage(inboxMessage);
+            try {
+                await runtime.telegramTransport.sendNotification({
+                    sessionId: targetSession.sessionId,
+                    ...(targetSession.label ? { sessionLabel: targetSession.label } : {}),
+                    recipient: {
+                        telegramChatId: targetBinding.telegramChatId,
+                        telegramUserId: targetBinding.telegramUserId,
+                    },
+                    message: buildTelegramDeliveryNotification({
+                        delivery,
+                        notePath,
+                        copiedArtifacts,
+                    }),
+                });
+            }
+            catch (error) {
+                runtime.logger.warn("Failed to send Telegram notification for gateway delivery", {
+                    deliveryUuid: delivery.delivery_uuid,
+                    sessionId: targetSession.sessionId,
+                    error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                });
+            }
+            try {
+                await runtime.telegramTransport.nudgeSessionPartnerNote(targetSession.sessionId);
+            }
+            catch (error) {
+                runtime.logger.warn("Failed to nudge tmux after gateway delivery", {
+                    deliveryUuid: delivery.delivery_uuid,
+                    sessionId: targetSession.sessionId,
+                    error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                });
+            }
+            runtime.logger.info("Gateway delivery materialized locally", {
+                deliveryUuid: delivery.delivery_uuid,
+                sessionId: targetSession.sessionId,
+                shareId: delivery.share_id,
+                kind: delivery.kind,
+                notePath,
+                copiedArtifacts,
+            });
+        },
+        async applyOutgoingDeliveryStatus(status) {
+            if (status.status !== "delivered" && status.status !== "failed") {
+                return;
+            }
+            const runtime = this.getRuntimeOrThrow?.();
+            if (!runtime) {
+                throw new Error("Runtime is unavailable");
+            }
+            const outgoingNotices = await runtime.maintenanceStore.listOutgoingDeliveryNotices();
+            const notice = outgoingNotices.find((item) => item.deliveryUuid === status.delivery_uuid);
+            if (!notice) {
+                return;
+            }
+            try {
+                await runtime.telegramTransport.editChatMessage(notice.telegramChatId, notice.telegramMessageId, status.status === "failed"
+                    ? buildOutgoingFailedText({ notice, status })
+                    : buildOutgoingDeliveredText({ notice, status }));
+                await runtime.maintenanceStore.deleteOutgoingDeliveryNotice(notice.deliveryUuid);
+            }
+            catch (error) {
+                runtime.logger.warn("Failed to update outgoing delivery status message in Telegram", {
+                    deliveryUuid: notice.deliveryUuid,
+                    sessionId: notice.sessionId,
+                    telegramChatId: notice.telegramChatId,
+                    telegramMessageId: notice.telegramMessageId,
+                    error: error instanceof Error
+                        ? (error.stack ?? error.message)
+                        : String(error),
+                });
+            }
+        },
+    },
+    actions: {
+        materializeIncomingDelivery: {
+            async handler(ctx) {
+                await this.materializeIncomingDelivery?.(ctx.params.delivery);
+                return { ok: true };
+            },
+        },
+        applyOutgoingDeliveryStatus: {
+            async handler(ctx) {
+                await this.applyOutgoingDeliveryStatus?.(ctx.params.status);
+                return { ok: true };
+            },
+        },
+    },
+    created() {
+        this.runtimeService = null;
+    },
+    async started() {
+        await this.broker.waitForServices([runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME]);
+        const runtimeService = this.broker.getLocalService(runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME);
+        if (!runtimeService) {
+            throw new Error(`Local Moleculer service '${runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME}' is unavailable`);
+        }
+        this.runtimeService = runtimeService;
+    },
+    async stopped() { },
+};
+exports.default = TelegramMcpGatewayDeliveryService;

package/dist/services/features/telegram-mcp/gateway-loopback.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasLocalTargetSession = hasLocalTargetSession;
+exports.hasOutgoingDeliveryNotice = hasOutgoingDeliveryNotice;
+function hasLocalTargetSession(session) {
+    return Boolean(session?.sessionId);
+}
+function hasOutgoingDeliveryNotice(notices, deliveryUuid) {
+    return notices.some((item) => item.deliveryUuid === deliveryUuid);
+}

package/dist/services/features/telegram-mcp/gateway-rmq.service.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEGRAM_MCP_GATEWAY_RMQ_SERVICE_NAME = void 0;
+const amqplib_1 = require("amqplib");
+const runtime_service_1 = require("./runtime.service");
+exports.TELEGRAM_MCP_GATEWAY_RMQ_SERVICE_NAME = "telegramMcp.gatewayRmq";
+function buildNodeSuffix() {
+    return (process.env.NODE_ID?.trim() ||
+        process.env.PROJECT_NAME?.trim() ||
+        "default").replace(/[^a-zA-Z0-9._-]+/gu, "-");
+}
+const QUEUE_NAME = `telegram_mcp.gateway.${buildNodeSuffix()}`;
+const RECONNECT_DELAY_MS = 3000;
+const TelegramMcpGatewayRmqService = {
+    name: exports.TELEGRAM_MCP_GATEWAY_RMQ_SERVICE_NAME,
+    dependencies: [runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME],
+    actions: {
+        publishDeliveryQueued: {
+            params: {
+                clientUuid: "string",
+                delivery: { type: "object" },
+            },
+            async handler(ctx) {
+                return {
+                    published: await this.publishMessage?.({
+                        type: "delivery.queued",
+                        payload: ctx.params,
+                    }),
+                };
+            },
+        },
+        publishDeliveryStatus: {
+            params: {
+                clientUuid: "string",
+                status: { type: "object" },
+            },
+            async handler(ctx) {
+                return {
+                    published: await this.publishMessage?.({
+                        type: "delivery.status",
+                        payload: ctx.params,
+                    }),
+                };
+            },
+        },
+        publishProjectMemberJoined: {
+            params: {
+                clientUuids: { type: "array", items: "string" },
+                projectUuid: "string",
+                projectName: "string",
+                memberDisplayName: { type: "string", optional: true },
+                memberTelegramUsername: { type: "string", optional: true },
+            },
+            async handler(ctx) {
+                return {
+                    published: await this.publishMessage?.({
+                        type: "project.member_joined",
+                        payload: ctx.params,
+                    }),
+                };
+            },
+        },
+        publishProjectMemberLeft: {
+            params: {
+                clientUuids: { type: "array", items: "string" },
+                projectUuid: "string",
+                projectName: "string",
+                memberDisplayName: { type: "string", optional: true },
+                memberTelegramUsername: { type: "string", optional: true },
+            },
+            async handler(ctx) {
+                return {
+                    published: await this.publishMessage?.({
+                        type: "project.member_left",
+                        payload: ctx.params,
+                    }),
+                };
+            },
+        },
+        publishProjectDeleted: {
+            params: {
+                clientUuids: { type: "array", items: "string" },
+                projectUuid: "string",
+                projectName: "string",
+            },
+            async handler(ctx) {
+                return {
+                    published: await this.publishMessage?.({
+                        type: "project.deleted",
+                        payload: ctx.params,
+                    }),
+                };
+            },
+        },
+    },
+    created() {
+        this.runtimeService = null;
+        this.connection = null;
+        this.channel = null;
+        this.consumerTag = null;
+        this.reconnectTimer = null;
+        this.stopRequested = false;
+    },
+    methods: {
+        getRuntimeOrThrow() {
+            const runtimeService = this.runtimeService ??
+                this.broker.getLocalService(runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME);
+            if (!runtimeService) {
+                throw new Error(`Local Moleculer service '${runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME}' is unavailable`);
+            }
+            this.runtimeService = runtimeService;
+            return runtimeService.getRuntime();
+        },
+        isEnabled() {
+            const runtime = this.getRuntimeOrThrow?.();
+            return Boolean(runtime &&
+                (runtime.config.distributed.mode === "gateway" ||
+                    runtime.config.distributed.mode === "both") &&
+                runtime.config.distributed.rmq?.host);
+        },
+        getExchangeName() {
+            return this.getRuntimeOrThrow?.().config.distributed.rmq?.exchange ??
+                "telegram_mcp.gateway";
+        },
+        getQueueName() {
+            return QUEUE_NAME;
+        },
+        async closeRmq() {
+            if (this.reconnectTimer) {
+                clearTimeout(this.reconnectTimer);
+                this.reconnectTimer = null;
+            }
+            const channel = this.channel;
+            this.channel = null;
+            this.consumerTag = null;
+            if (channel) {
+                await channel.close().catch(() => undefined);
+            }
+            const connection = this.connection;
+            this.connection = null;
+            if (connection) {
+                await connection.close().catch(() => undefined);
+            }
+        },
+        scheduleReconnect() {
+            if (this.stopRequested || this.reconnectTimer || !this.isEnabled?.()) {
+                return;
+            }
+            this.reconnectTimer = setTimeout(() => {
+                this.reconnectTimer = null;
+                void this.connectRmq?.();
+            }, RECONNECT_DELAY_MS);
+            this.logger.warn("Gateway RMQ reconnect scheduled", {
+                delayMs: RECONNECT_DELAY_MS,
+            });
+        },
+        async dispatchMessage(message) {
+            if (message.type === "delivery.queued") {
+                await this.broker.call("telegramMcp.gatewaySocket.notifyDeliveryQueued", message.payload, { meta: { internal_call: true } });
+                return;
+            }
+            if (message.type === "delivery.status") {
+                await this.broker.call("telegramMcp.gatewaySocket.notifyDeliveryStatus", message.payload, { meta: { internal_call: true } });
+                return;
+            }
+            if (message.type === "project.member_joined") {
+                await this.broker.call("telegramMcp.gatewaySocket.notifyProjectMemberJoined", message.payload, { meta: { internal_call: true } });
+                return;
+            }
+            if (message.type === "project.deleted") {
+                await this.broker.call("telegramMcp.gatewaySocket.notifyProjectDeleted", message.payload, { meta: { internal_call: true } });
+                return;
+            }
+            await this.broker.call("telegramMcp.gatewaySocket.notifyProjectMemberLeft", message.payload, { meta: { internal_call: true } });
+        },
+        async connectRmq() {
+            if (this.stopRequested || !this.isEnabled?.() || this.channel) {
+                return;
+            }
+            const runtime = this.getRuntimeOrThrow?.();
+            const rmq = runtime?.config.distributed.rmq;
+            if (!runtime || !rmq) {
+                return;
+            }
+            try {
+                const connection = await (0, amqplib_1.connect)({
+                    protocol: "amqp",
+                    hostname: rmq.host,
+                    port: rmq.port,
+                    ...(rmq.user ? { username: rmq.user } : {}),
+                    ...(rmq.password ? { password: rmq.password } : {}),
+                    vhost: rmq.vhost,
+                });
+                const channel = await connection.createChannel();
+                const exchange = this.getExchangeName?.() ?? rmq.exchange;
+                const queue = this.getQueueName?.() ?? QUEUE_NAME;
+                await channel.assertExchange(exchange, "topic", { durable: true });
+                await channel.assertQueue(queue, { durable: true });
+                await channel.bindQueue(queue, exchange, "delivery.queued");
+                await channel.bindQueue(queue, exchange, "delivery.status");
+                await channel.bindQueue(queue, exchange, "project.member_joined");
+                await channel.bindQueue(queue, exchange, "project.member_left");
+                await channel.bindQueue(queue, exchange, "project.deleted");
+                const onDisconnected = (eventName, error) => {
+                    this.logger.warn("Gateway RMQ connection closed", {
+                        eventName,
+                        error: error instanceof Error ? (error.stack ?? error.message) : undefined,
+                    });
+                    this.connection = null;
+                    this.channel = null;
+                    this.consumerTag = null;
+                    this.scheduleReconnect?.();
+                };
+                connection.on("error", (error) => onDisconnected("error", error));
+                connection.on("close", () => onDisconnected("close"));
+                const consumeResult = await channel.consume(queue, async (msg) => {
+                    if (!msg) {
+                        return;
+                    }
+                    try {
+                        const parsed = JSON.parse(msg.content.toString("utf8"));
+                        await this.dispatchMessage?.(parsed);
+                        channel.ack(msg);
+                    }
+                    catch (error) {
+                        this.logger.warn("Gateway RMQ message handling failed", {
+                            error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                            routingKey: msg.fields.routingKey,
+                        });
+                        channel.nack(msg, false, true);
+                    }
+                }, { noAck: false });
+                this.connection = connection;
+                this.channel = channel;
+                this.consumerTag = consumeResult.consumerTag;
+                this.logger.warn("Gateway RMQ connected", {
+                    host: rmq.host,
+                    port: rmq.port,
+                    queue,
+                    exchange,
+                });
+            }
+            catch (error) {
+                this.logger.warn("Gateway RMQ connect failed", {
+                    host: rmq.host,
+                    port: rmq.port,
+                    error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                });
+                await this.closeRmq?.();
+                this.scheduleReconnect?.();
+            }
+        },
+        async publishMessage(message) {
+            if (!this.isEnabled?.()) {
+                return false;
+            }
+            if (!this.channel) {
+                await this.connectRmq?.();
+            }
+            if (!this.channel) {
+                return false;
+            }
+            const routingKey = message.type;
+            const published = this.channel.publish(this.getExchangeName?.() ?? "telegram_mcp.gateway", routingKey, Buffer.from(JSON.stringify(message), "utf8"), {
+                contentType: "application/json",
+                deliveryMode: 2,
+                timestamp: Date.now(),
+            });
+            return published;
+        },
+    },
+    async started() {
+        await this.broker.waitForServices([runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME]);
+        const runtimeService = this.broker.getLocalService(runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME);
+        if (!runtimeService) {
+            throw new Error(`Local Moleculer service '${runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME}' is unavailable`);
+        }
+        this.runtimeService = runtimeService;
+        if (!this.isEnabled?.()) {
+            this.logger.info("Gateway RMQ is disabled", {
+                distributedMode: runtimeService.getRuntime().config.distributed.mode,
+                rmqConfigured: Boolean(runtimeService.getRuntime().config.distributed.rmq?.host),
+            });
+            return;
+        }
+        this.stopRequested = false;
+        await this.connectRmq?.();
+    },
+    async stopped() {
+        this.stopRequested = true;
+        await this.closeRmq?.();
+    },
+};
+exports.default = TelegramMcpGatewayRmqService;