@deadragdoll/tellymcp 0.0.1

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

@@ -0,0 +1,1141 @@
+"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_SERVICE_NAME = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = __importDefault(require("node:path"));
+const db_1 = require("../../../lib/mixins/db");
+const gatewayReplyResolution_1 = require("./src/features/distributed-gateway/model/gatewayReplyResolution");
+const ensuredb_service_1 = require("./ensuredb.service");
+exports.TELEGRAM_MCP_GATEWAY_SERVICE_NAME = "telegramMcp.gateway";
+const MCP_SCHEMA = process.env.DB_SCHEME || "mcp";
+const DISTRIBUTED_MODE = process.env.DISTRIBUTED_MODE || "client";
+const GATEWAY_ENABLED = DISTRIBUTED_MODE === "gateway" || DISTRIBUTED_MODE === "both";
+function trimOptionalText(value) {
+    const text = typeof value === "string" ? value.trim() : String(value ?? "").trim();
+    return text ? text : null;
+}
+function sanitizeArtifactName(value) {
+    const withoutControlChars = Array.from(value)
+        .map((char) => (char.charCodeAt(0) < 32 ? "-" : char))
+        .join("");
+    return withoutControlChars
+        .trim()
+        .replace(/[/\\]+/gu, "-")
+        .replace(/\s+/gu, " ")
+        .replace(/^\.+$/u, "file")
+        .slice(0, 180) || "file";
+}
+function allocateArtifactRelativePath(shareId, preferredName, usedNames) {
+    const sanitized = sanitizeArtifactName(preferredName);
+    const ext = node_path_1.default.extname(sanitized);
+    const base = ext ? sanitized.slice(0, -ext.length) : sanitized;
+    let candidate = sanitized;
+    let index = 1;
+    while (usedNames.has(candidate.toLowerCase())) {
+        candidate = `${base}--${index}${ext}`;
+        index += 1;
+    }
+    usedNames.add(candidate.toLowerCase());
+    return `shares/files/${shareId}/${candidate}`;
+}
+function readClientMeta(client) {
+    if (!client?.meta || typeof client.meta !== "object" || Array.isArray(client.meta)) {
+        return {};
+    }
+    return client.meta;
+}
+const TelegramMcpGatewayService = {
+    name: exports.TELEGRAM_MCP_GATEWAY_SERVICE_NAME,
+    mixins: [db_1.DBMixin],
+    dependencies: [ensuredb_service_1.TELEGRAM_MCP_ENSUREDB_SERVICE_NAME],
+    methods: {
+        normalizeOptionalText(value) {
+            const text = typeof value === "string" ? value.trim() : String(value ?? "").trim();
+            return text ? text : null;
+        },
+        requireText(value, fieldName) {
+            const text = this.normalizeOptionalText?.(value);
+            if (!text) {
+                throw new Error(`${fieldName} is required`);
+            }
+            return text;
+        },
+        async registerClientRecord(input) {
+            const clientUuid = this.normalizeOptionalText?.(input.client_uuid) || (0, node_crypto_1.randomUUID)();
+            const now = new Date().toISOString();
+            const clientLabel = this.normalizeOptionalText?.(input.client_label);
+            const botUsername = this.normalizeOptionalText?.(input.bot_username);
+            const tokenFingerprint = this.normalizeOptionalText?.(input.bot_token_fingerprint);
+            const meta = input.meta && typeof input.meta === "object" && !Array.isArray(input.meta)
+                ? input.meta
+                : {};
+            const existing = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_clients")
+                .where({ client_uuid: clientUuid })
+                .first();
+            if (existing) {
+                await this.db
+                    .withSchema(MCP_SCHEMA)
+                    .table("gateway_clients")
+                    .where({ client_uuid: clientUuid })
+                    .update({
+                    ...(clientLabel ? { client_label: clientLabel } : {}),
+                    ...(botUsername ? { bot_username: botUsername } : {}),
+                    ...(tokenFingerprint ? { bot_token_fingerprint: tokenFingerprint } : {}),
+                    meta: this.db.raw(`?::jsonb`, [JSON.stringify(meta)]),
+                    updated_at: now,
+                    last_seen_at: now,
+                });
+                return {
+                    client_uuid: clientUuid,
+                    created: false,
+                    updated_at: now,
+                };
+            }
+            await this.db.withSchema(MCP_SCHEMA).table("gateway_clients").insert({
+                client_uuid: clientUuid,
+                ...(clientLabel ? { client_label: clientLabel } : {}),
+                ...(botUsername ? { bot_username: botUsername } : {}),
+                ...(tokenFingerprint ? { bot_token_fingerprint: tokenFingerprint } : {}),
+                meta: this.db.raw(`?::jsonb`, [JSON.stringify(meta)]),
+                created_at: now,
+                updated_at: now,
+                last_seen_at: now,
+            });
+            return {
+                client_uuid: clientUuid,
+                created: true,
+                updated_at: now,
+            };
+        },
+        async createProjectRecord(input) {
+            const clientUuid = this.requireText?.(input.client_uuid, "client_uuid");
+            const name = this.requireText?.(input.name, "name");
+            const client = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_clients")
+                .where({ client_uuid: clientUuid })
+                .first();
+            if (!client) {
+                throw new Error(`Client ${clientUuid} is not registered`);
+            }
+            const clientMeta = readClientMeta(client);
+            const ownerTelegramUserId = this.normalizeOptionalText?.(clientMeta.telegram_user_id);
+            const ownerTelegramUsername = this.normalizeOptionalText?.(clientMeta.telegram_username);
+            const ownerDisplayName = this.normalizeOptionalText?.(clientMeta.telegram_display_name);
+            const projectUuid = (0, node_crypto_1.randomUUID)();
+            const inviteToken = (0, node_crypto_1.randomUUID)();
+            const now = new Date().toISOString();
+            await this.db.withSchema(MCP_SCHEMA).table("gateway_projects").insert({
+                project_uuid: projectUuid,
+                name,
+                invite_token: inviteToken,
+                created_by_client_uuid: clientUuid,
+                ...(ownerTelegramUserId
+                    ? { owner_telegram_user_id: ownerTelegramUserId }
+                    : {}),
+                ...(ownerTelegramUsername
+                    ? { owner_telegram_username: ownerTelegramUsername }
+                    : {}),
+                ...(ownerDisplayName ? { owner_display_name: ownerDisplayName } : {}),
+                is_active: true,
+                created_at: now,
+                updated_at: now,
+            });
+            await this.db.withSchema(MCP_SCHEMA).table("gateway_project_members").insert({
+                project_uuid: projectUuid,
+                client_uuid: clientUuid,
+                role: "owner",
+                status: "active",
+                ...(ownerTelegramUserId ? { telegram_user_id: ownerTelegramUserId } : {}),
+                ...(ownerTelegramUsername ? { telegram_username: ownerTelegramUsername } : {}),
+                ...(ownerDisplayName ? { display_name: ownerDisplayName } : {}),
+                joined_at: now,
+            });
+            return {
+                project_uuid: projectUuid,
+                invite_token: inviteToken,
+                name,
+                created: true,
+            };
+        },
+        async joinProjectRecord(input) {
+            const clientUuid = this.requireText?.(input.client_uuid, "client_uuid");
+            const inviteToken = this.requireText?.(input.invite_token, "invite_token");
+            const client = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_clients")
+                .where({ client_uuid: clientUuid })
+                .first();
+            if (!client) {
+                throw new Error(`Client ${clientUuid} is not registered`);
+            }
+            const clientMeta = readClientMeta(client);
+            const memberTelegramUserId = this.normalizeOptionalText?.(clientMeta.telegram_user_id);
+            const memberTelegramUsername = this.normalizeOptionalText?.(clientMeta.telegram_username);
+            const memberDisplayName = this.normalizeOptionalText?.(clientMeta.telegram_display_name);
+            const project = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_projects")
+                .where({ invite_token: inviteToken, is_active: true })
+                .first();
+            if (!project) {
+                throw new Error("Project invite token is invalid or inactive");
+            }
+            const existing = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_project_members")
+                .where({
+                project_uuid: project.project_uuid,
+                client_uuid: clientUuid,
+            })
+                .first();
+            if (existing) {
+                const notifyRows = existing.status !== "active"
+                    ? await this.db
+                        .withSchema(MCP_SCHEMA)
+                        .table("gateway_project_members")
+                        .where({
+                        project_uuid: project.project_uuid,
+                        status: "active",
+                    })
+                        .whereNot({
+                        client_uuid: clientUuid,
+                    })
+                        .distinct("client_uuid")
+                    : [];
+                if (existing.status !== "active") {
+                    await this.db
+                        .withSchema(MCP_SCHEMA)
+                        .table("gateway_project_members")
+                        .where({
+                        project_uuid: project.project_uuid,
+                        client_uuid: clientUuid,
+                    })
+                        .update({
+                        status: "active",
+                        ...(memberTelegramUserId
+                            ? { telegram_user_id: memberTelegramUserId }
+                            : {}),
+                        ...(memberTelegramUsername
+                            ? { telegram_username: memberTelegramUsername }
+                            : {}),
+                        ...(memberDisplayName ? { display_name: memberDisplayName } : {}),
+                        joined_at: new Date().toISOString(),
+                    });
+                }
+                return {
+                    project_uuid: project.project_uuid,
+                    invite_token: project.invite_token,
+                    name: project.name,
+                    joined: false,
+                    ...(notifyRows.length > 0
+                        ? {
+                            notify_client_uuids: notifyRows
+                                .map((row) => String(row.client_uuid))
+                                .filter(Boolean),
+                        }
+                        : {}),
+                    member_display_name: memberDisplayName ?? null,
+                    member_telegram_username: memberTelegramUsername ?? null,
+                };
+            }
+            await this.db.withSchema(MCP_SCHEMA).table("gateway_project_members").insert({
+                project_uuid: project.project_uuid,
+                client_uuid: clientUuid,
+                role: "member",
+                status: "active",
+                ...(memberTelegramUserId ? { telegram_user_id: memberTelegramUserId } : {}),
+                ...(memberTelegramUsername ? { telegram_username: memberTelegramUsername } : {}),
+                ...(memberDisplayName ? { display_name: memberDisplayName } : {}),
+                joined_at: new Date().toISOString(),
+            });
+            const notifyRows = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_project_members")
+                .where({
+                project_uuid: project.project_uuid,
+                status: "active",
+            })
+                .whereNot({
+                client_uuid: clientUuid,
+            })
+                .distinct("client_uuid");
+            return {
+                project_uuid: project.project_uuid,
+                invite_token: project.invite_token,
+                name: project.name,
+                joined: true,
+                ...(notifyRows.length > 0
+                    ? {
+                        notify_client_uuids: notifyRows
+                            .map((row) => String(row.client_uuid))
+                            .filter(Boolean),
+                    }
+                    : {}),
+                member_display_name: memberDisplayName ?? null,
+                member_telegram_username: memberTelegramUsername ?? null,
+            };
+        },
+        async registerSessionRecord(input) {
+            const clientUuid = this.requireText?.(input.client_uuid, "client_uuid");
+            const projectUuid = this.requireText?.(input.project_uuid, "project_uuid");
+            const localSessionId = this.requireText?.(input.local_session_id, "local_session_id");
+            const now = new Date().toISOString();
+            const membership = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_project_members")
+                .where({
+                project_uuid: projectUuid,
+                client_uuid: clientUuid,
+                status: "active",
+            })
+                .first();
+            if (!membership) {
+                throw new Error(`Client ${clientUuid} is not an active member of project ${projectUuid}`);
+            }
+            const existing = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_sessions")
+                .where({
+                project_uuid: projectUuid,
+                client_uuid: clientUuid,
+                local_session_id: localSessionId,
+            })
+                .first();
+            const payload = {
+                project_uuid: projectUuid,
+                client_uuid: clientUuid,
+                local_session_id: localSessionId,
+                ...(this.normalizeOptionalText?.(input.label)
+                    ? { label: this.normalizeOptionalText?.(input.label) }
+                    : {}),
+                ...(this.normalizeOptionalText?.(input.cwd)
+                    ? { cwd: this.normalizeOptionalText?.(input.cwd) }
+                    : {}),
+                ...(this.normalizeOptionalText?.(input.tmux_session_name)
+                    ? { tmux_session_name: this.normalizeOptionalText?.(input.tmux_session_name) }
+                    : {}),
+                ...(this.normalizeOptionalText?.(input.tmux_window_name)
+                    ? { tmux_window_name: this.normalizeOptionalText?.(input.tmux_window_name) }
+                    : {}),
+                ...(Number.isInteger(input.tmux_window_index)
+                    ? { tmux_window_index: input.tmux_window_index }
+                    : {}),
+                ...(this.normalizeOptionalText?.(input.tmux_pane_id)
+                    ? { tmux_pane_id: this.normalizeOptionalText?.(input.tmux_pane_id) }
+                    : {}),
+                ...(Number.isInteger(input.tmux_pane_index)
+                    ? { tmux_pane_index: input.tmux_pane_index }
+                    : {}),
+                ...(this.normalizeOptionalText?.(input.tmux_target)
+                    ? { tmux_target: this.normalizeOptionalText?.(input.tmux_target) }
+                    : {}),
+                status: this.normalizeOptionalText?.(input.status) || "active",
+                meta: this.db.raw(`?::jsonb`, [
+                    JSON.stringify(input.meta && typeof input.meta === "object" && !Array.isArray(input.meta)
+                        ? input.meta
+                        : {}),
+                ]),
+                updated_at: now,
+            };
+            if (existing) {
+                await this.db
+                    .withSchema(MCP_SCHEMA)
+                    .table("gateway_sessions")
+                    .where({ session_uuid: existing.session_uuid })
+                    .update(payload);
+                return {
+                    session_uuid: existing.session_uuid,
+                    created: false,
+                    updated_at: now,
+                };
+            }
+            const sessionUuid = (0, node_crypto_1.randomUUID)();
+            await this.db.withSchema(MCP_SCHEMA).table("gateway_sessions").insert({
+                session_uuid: sessionUuid,
+                ...payload,
+                created_at: now,
+            });
+            return {
+                session_uuid: sessionUuid,
+                created: true,
+                updated_at: now,
+            };
+        },
+        async unregisterSessionRecord(input) {
+            const clientUuid = this.requireText?.(input.client_uuid, "client_uuid");
+            const localSessionId = this.requireText?.(input.local_session_id, "local_session_id");
+            const deleted = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_sessions")
+                .where({
+                client_uuid: clientUuid,
+                local_session_id: localSessionId,
+            })
+                .del();
+            return {
+                local_session_id: localSessionId,
+                deleted,
+            };
+        },
+        async listProjectsRecord(input) {
+            const clientUuid = this.requireText?.(input.client_uuid, "client_uuid");
+            const rows = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_project_members as m")
+                .join("gateway_projects as p", "p.project_uuid", "m.project_uuid")
+                .where("m.client_uuid", clientUuid)
+                .where("m.status", "active")
+                .where("p.is_active", true)
+                .select("p.project_uuid", "p.name", "p.invite_token", "m.role", "m.status", "m.joined_at")
+                .orderBy("p.name", "asc");
+            return {
+                projects: rows.map((row) => ({
+                    project_uuid: row.project_uuid,
+                    name: row.name,
+                    invite_token: row.invite_token,
+                    role: row.role,
+                    status: row.status,
+                    ...(row.joined_at ? { joined_at: String(row.joined_at) } : {}),
+                })),
+            };
+        },
+        async leaveProjectRecord(input) {
+            const clientUuid = this.requireText?.(input.client_uuid, "client_uuid");
+            const projectUuid = this.requireText?.(input.project_uuid, "project_uuid");
+            const client = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_clients")
+                .where({ client_uuid: clientUuid })
+                .first();
+            const membership = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_project_members")
+                .where({
+                client_uuid: clientUuid,
+                project_uuid: projectUuid,
+            })
+                .first();
+            const project = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_projects")
+                .where({ project_uuid: projectUuid })
+                .first();
+            const clientMeta = readClientMeta(client ?? {});
+            const memberDisplayName = this.normalizeOptionalText?.(membership?.display_name) ??
+                this.normalizeOptionalText?.(clientMeta.telegram_display_name) ??
+                null;
+            const memberTelegramUsername = this.normalizeOptionalText?.(membership?.telegram_username) ??
+                this.normalizeOptionalText?.(clientMeta.telegram_username) ??
+                null;
+            const updated = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_project_members")
+                .where({
+                client_uuid: clientUuid,
+                project_uuid: projectUuid,
+            })
+                .update({
+                status: "left",
+            });
+            const notifyRows = updated > 0
+                ? await this.db
+                    .withSchema(MCP_SCHEMA)
+                    .table("gateway_project_members")
+                    .where({
+                    project_uuid: projectUuid,
+                    status: "active",
+                })
+                    .whereNot({
+                    client_uuid: clientUuid,
+                })
+                    .distinct("client_uuid")
+                : [];
+            return {
+                project_uuid: projectUuid,
+                left: updated > 0,
+                ...(project?.name ? { project_name: project.name } : {}),
+                ...(notifyRows.length > 0
+                    ? {
+                        notify_client_uuids: notifyRows
+                            .map((row) => String(row.client_uuid))
+                            .filter(Boolean),
+                    }
+                    : {}),
+                ...(memberDisplayName ? { member_display_name: memberDisplayName } : {}),
+                ...(memberTelegramUsername
+                    ? { member_telegram_username: memberTelegramUsername }
+                    : {}),
+            };
+        },
+        async deleteProjectRecord(input) {
+            const clientUuid = this.requireText?.(input.client_uuid, "client_uuid");
+            const projectUuid = this.requireText?.(input.project_uuid, "project_uuid");
+            const project = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_projects")
+                .where({ project_uuid: projectUuid, is_active: true })
+                .first();
+            if (!project) {
+                throw new Error("Project was not found or is already inactive.");
+            }
+            const ownerMembership = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_project_members")
+                .where({
+                client_uuid: clientUuid,
+                project_uuid: projectUuid,
+                status: "active",
+                role: "owner",
+            })
+                .first();
+            if (!ownerMembership) {
+                throw new Error("Only the project owner can delete this project.");
+            }
+            const notifyRows = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_project_members")
+                .where({
+                project_uuid: projectUuid,
+                status: "active",
+            })
+                .distinct("client_uuid");
+            const deleted = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_projects")
+                .where({ project_uuid: projectUuid })
+                .del();
+            return {
+                project_uuid: projectUuid,
+                deleted: deleted > 0,
+                ...(project.name ? { project_name: project.name } : {}),
+                ...(notifyRows.length > 0
+                    ? {
+                        notify_client_uuids: notifyRows
+                            .map((row) => String(row.client_uuid))
+                            .filter(Boolean),
+                    }
+                    : {}),
+            };
+        },
+        async listProjectSessionsRecord(input) {
+            const clientUuid = this.requireText?.(input.client_uuid, "client_uuid");
+            const projectUuid = this.requireText?.(input.project_uuid, "project_uuid");
+            const membership = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_project_members")
+                .where({
+                client_uuid: clientUuid,
+                project_uuid: projectUuid,
+                status: "active",
+            })
+                .first();
+            if (!membership) {
+                throw new Error(`Client ${clientUuid} is not an active member of project ${projectUuid}`);
+            }
+            const rows = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_sessions as s")
+                .leftJoin("gateway_clients as c", "c.client_uuid", "s.client_uuid")
+                .leftJoin("gateway_project_members as m", function joinMember() {
+                this.on("m.project_uuid", "=", "s.project_uuid").andOn("m.client_uuid", "=", "s.client_uuid");
+            })
+                .where("s.project_uuid", projectUuid)
+                .where("s.status", "active")
+                .where("m.status", "active")
+                .select("s.session_uuid", "s.project_uuid", "s.client_uuid", "s.local_session_id", "s.label", "s.status", "s.updated_at", "c.client_label", this.db.raw("coalesce(nullif(m.telegram_username, ''), nullif(c.meta->>'telegram_username', '')) as telegram_username"), "c.bot_username", "m.joined_at")
+                .orderByRaw("coalesce(s.label, s.local_session_id) asc")
+                .orderBy("s.updated_at", "desc");
+            return {
+                sessions: rows.map((row) => ({
+                    session_uuid: row.session_uuid,
+                    project_uuid: row.project_uuid,
+                    client_uuid: row.client_uuid,
+                    local_session_id: row.local_session_id,
+                    label: row.label ?? null,
+                    status: row.status,
+                    client_label: row.client_label ?? null,
+                    telegram_username: row.telegram_username ?? null,
+                    bot_username: row.bot_username ?? null,
+                    ...(row.joined_at ? { joined_at: String(row.joined_at) } : {}),
+                    ...(row.updated_at ? { updated_at: String(row.updated_at) } : {}),
+                })),
+            };
+        },
+        async sendPartnerNoteRecord(input) {
+            const clientUuid = this.requireText?.(input.client_uuid, "client_uuid");
+            const localSessionId = this.requireText?.(input.session_id, "session_id");
+            const targetSessionId = this.requireText?.(input.target_session_id, "target_session_id");
+            const requestedProjectUuid = this.normalizeOptionalText?.(input.project_uuid);
+            const kind = this.requireText?.(input.kind, "kind");
+            const summary = this.requireText?.(input.summary, "summary");
+            const message = this.requireText?.(input.message, "message");
+            const expectedReply = this.normalizeOptionalText?.(input.expected_reply);
+            const inReplyTo = this.normalizeOptionalText?.(input.in_reply_to);
+            const requiresReply = typeof input.requires_reply === "boolean"
+                ? input.requires_reply
+                : kind === "question" || kind === "request";
+            const targetSession = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_sessions as s")
+                .leftJoin("gateway_clients as c", "c.client_uuid", "s.client_uuid")
+                .leftJoin("gateway_projects as p", "p.project_uuid", "s.project_uuid")
+                .where({
+                "s.session_uuid": targetSessionId,
+                "s.status": "active",
+            })
+                .select("s.*", "p.name as project_name", this.db.raw("coalesce(nullif(c.meta->>'telegram_display_name', ''), nullif(c.meta->>'telegram_username', ''), c.client_label, c.bot_username) as target_actor_label"))
+                .first();
+            if (!targetSession) {
+                throw new Error(`Target project session ${targetSessionId} was not found.`);
+            }
+            if (requestedProjectUuid &&
+                requestedProjectUuid !== String(targetSession.project_uuid)) {
+                throw new Error("Target session does not belong to the requested project.");
+            }
+            const sourceSession = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_sessions")
+                .where({
+                project_uuid: String(targetSession.project_uuid),
+                client_uuid: clientUuid,
+                local_session_id: localSessionId,
+                status: "active",
+            })
+                .first();
+            if (!sourceSession) {
+                throw new Error(`Active project session '${localSessionId}' is not registered for client ${clientUuid} in project ${targetSession.project_uuid}.`);
+            }
+            const shareId = (0, node_crypto_1.randomUUID)();
+            const messageUuid = (0, node_crypto_1.randomUUID)();
+            const deliveryUuid = (0, node_crypto_1.randomUUID)();
+            const now = new Date().toISOString();
+            const resolvedInReplyTo = await (0, gatewayReplyResolution_1.resolveGatewayInReplyTo)(inReplyTo ?? undefined, {
+                findMessageUuidByMessageUuid: async (messageUuid) => {
+                    const directReplyTarget = await this.db
+                        .withSchema(MCP_SCHEMA)
+                        .table("gateway_messages")
+                        .where({ message_uuid: messageUuid })
+                        .select("message_uuid")
+                        .first();
+                    return directReplyTarget?.message_uuid
+                        ? String(directReplyTarget.message_uuid)
+                        : undefined;
+                },
+                findMessageUuidByShareId: async (shareId) => {
+                    const shareReplyTarget = await this.db
+                        .withSchema(MCP_SCHEMA)
+                        .table("gateway_messages")
+                        .whereRaw("meta->>'share_id' = ?", [shareId])
+                        .select("message_uuid")
+                        .orderBy("created_at", "desc")
+                        .first();
+                    return shareReplyTarget?.message_uuid
+                        ? String(shareReplyTarget.message_uuid)
+                        : undefined;
+                },
+            });
+            await this.db.withSchema(MCP_SCHEMA).table("gateway_messages").insert({
+                message_uuid: messageUuid,
+                project_uuid: sourceSession.project_uuid,
+                from_session_uuid: sourceSession.session_uuid,
+                to_session_uuid: targetSession.session_uuid,
+                kind,
+                summary,
+                body: message,
+                ...(expectedReply ? { expected_reply: expectedReply } : {}),
+                ...(resolvedInReplyTo ? { in_reply_to: resolvedInReplyTo } : {}),
+                requires_reply: requiresReply,
+                meta: this.db.raw(`?::jsonb`, [JSON.stringify({ share_id: shareId })]),
+                created_at: now,
+            });
+            const artifactRefs = Array.isArray(input.artifact_refs)
+                ? input.artifact_refs
+                : [];
+            const usedArtifactNames = new Set();
+            const queuedArtifacts = [];
+            for (const artifact of artifactRefs) {
+                const originalName = trimOptionalText(artifact.original_name) ||
+                    trimOptionalText(artifact.relative_path) ||
+                    trimOptionalText(artifact.file_path) ||
+                    "file";
+                const relativePath = allocateArtifactRelativePath(shareId, node_path_1.default.basename(originalName), usedArtifactNames);
+                const mimeType = trimOptionalText(artifact.mime_type) ?? undefined;
+                const storageRef = trimOptionalText(artifact.storage_ref) ?? undefined;
+                const contentBase64 = trimOptionalText(artifact.content_base64) ?? undefined;
+                const queuedArtifact = {
+                    artifact_uuid: (0, node_crypto_1.randomUUID)(),
+                    original_name: node_path_1.default.basename(originalName),
+                    ...(mimeType ? { mime_type: mimeType } : {}),
+                    ...(typeof artifact.size_bytes === "number"
+                        ? { size_bytes: artifact.size_bytes }
+                        : {}),
+                    ...(storageRef ? { storage_ref: storageRef } : {}),
+                    relative_path: relativePath,
+                    ...(contentBase64 ? { content_base64: contentBase64 } : {}),
+                };
+                queuedArtifacts.push(queuedArtifact);
+                await this.db.withSchema(MCP_SCHEMA).table("gateway_message_artifacts").insert({
+                    artifact_uuid: queuedArtifact.artifact_uuid,
+                    message_uuid: messageUuid,
+                    original_name: queuedArtifact.original_name,
+                    ...(queuedArtifact.mime_type
+                        ? { mime_type: queuedArtifact.mime_type }
+                        : {}),
+                    ...(typeof queuedArtifact.size_bytes === "number"
+                        ? { size_bytes: queuedArtifact.size_bytes }
+                        : {}),
+                    ...(queuedArtifact.storage_ref
+                        ? { storage_ref: queuedArtifact.storage_ref }
+                        : {}),
+                    relative_path: relativePath,
+                    meta: this.db.raw(`?::jsonb`, [
+                        JSON.stringify({
+                            file_path: trimOptionalText(artifact.file_path),
+                            relative_path: trimOptionalText(artifact.relative_path),
+                            content_base64: trimOptionalText(artifact.content_base64),
+                        }),
+                    ]),
+                    created_at: now,
+                });
+            }
+            await this.db.withSchema(MCP_SCHEMA).table("gateway_deliveries").insert({
+                delivery_uuid: deliveryUuid,
+                message_uuid: messageUuid,
+                target_client_uuid: targetSession.client_uuid,
+                target_session_uuid: targetSession.session_uuid,
+                status: "queued",
+                attempt_count: 0,
+                available_at: now,
+                created_at: now,
+            });
+            return {
+                session_id: localSessionId,
+                partner_session_id: targetSession.session_uuid,
+                ...(targetSession.project_name
+                    ? { project_name: targetSession.project_name }
+                    : {}),
+                ...(targetSession.target_actor_label
+                    ? { target_actor_label: targetSession.target_actor_label }
+                    : {}),
+                ...(targetSession.label
+                    ? { target_session_label: targetSession.label }
+                    : {}),
+                kind: kind,
+                share_id: shareId,
+                delivery_status: "queued",
+                note_path: `gateway://shares/${shareId}.md`,
+                share_index_path: "gateway://SHARED_INDEX.md",
+                copied_artifacts: artifactRefs.map((artifact) => trimOptionalText(artifact.original_name) ||
+                    trimOptionalText(artifact.relative_path) ||
+                    trimOptionalText(artifact.file_path) ||
+                    "file"),
+                inbox_message_id: deliveryUuid,
+                requires_reply: requiresReply,
+                delivery_uuid: deliveryUuid,
+                target_client_uuid: targetSession.client_uuid,
+                delivery: {
+                    delivery_uuid: deliveryUuid,
+                    message_uuid: messageUuid,
+                    share_id: shareId,
+                    ...(targetSession.project_name
+                        ? { project_name: targetSession.project_name }
+                        : {}),
+                    source_actor_label: sourceSession.label ?? sourceSession.local_session_id,
+                    kind,
+                    summary,
+                    message,
+                    ...(expectedReply ? { expected_reply: expectedReply } : {}),
+                    requires_reply: requiresReply,
+                    ...(resolvedInReplyTo ? { in_reply_to: resolvedInReplyTo } : {}),
+                    source_session_uuid: sourceSession.session_uuid,
+                    source_session_label: sourceSession.label ?? sourceSession.local_session_id,
+                    source_local_session_id: sourceSession.local_session_id,
+                    target_session_uuid: targetSession.session_uuid,
+                    target_local_session_id: targetSession.local_session_id,
+                    target_session_label: targetSession.label ?? targetSession.local_session_id,
+                    created_at: now,
+                    note_relative_path: `shares/${shareId}.md`,
+                    share_index_file_name: "SHARED_INDEX.md",
+                    artifacts: queuedArtifacts,
+                },
+            };
+        },
+        async pollDeliveriesRecord(input) {
+            const clientUuid = this.requireText?.(input.client_uuid, "client_uuid");
+            const limit = typeof input.limit === "number" && Number.isFinite(input.limit)
+                ? Math.max(1, Math.min(50, Math.trunc(input.limit)))
+                : 20;
+            const rows = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_deliveries as d")
+                .join("gateway_messages as m", "m.message_uuid", "d.message_uuid")
+                .join("gateway_projects as p", "p.project_uuid", "m.project_uuid")
+                .join("gateway_sessions as s_from", "s_from.session_uuid", "m.from_session_uuid")
+                .join("gateway_sessions as s_to", "s_to.session_uuid", "m.to_session_uuid")
+                .leftJoin("gateway_clients as c_from", "c_from.client_uuid", "s_from.client_uuid")
+                .where("d.target_client_uuid", clientUuid)
+                .where("d.status", "queued")
+                .where("d.available_at", "<=", this.db.fn.now())
+                .select("d.delivery_uuid", "d.message_uuid", "p.project_uuid", "m.kind", "m.summary", "m.body", "m.expected_reply", "m.requires_reply", "m.in_reply_to", "m.meta", "m.created_at", "p.name as project_name", this.db.raw("coalesce(nullif(c_from.meta->>'telegram_display_name', ''), nullif(c_from.meta->>'telegram_username', ''), c_from.client_label, c_from.bot_username) as source_actor_label"), "s_from.session_uuid as source_session_uuid", "s_from.local_session_id as source_local_session_id", "s_from.label as source_session_label", "s_to.session_uuid as target_session_uuid", "s_to.local_session_id as target_local_session_id", "s_to.label as target_session_label")
+                .orderBy("m.created_at", "asc")
+                .limit(limit);
+            const messageIds = rows.map((row) => row.message_uuid);
+            const artifactRows = messageIds.length
+                ? await this.db
+                    .withSchema(MCP_SCHEMA)
+                    .table("gateway_message_artifacts")
+                    .whereIn("message_uuid", messageIds)
+                    .select("artifact_uuid", "message_uuid", "original_name", "mime_type", "size_bytes", "storage_ref", "relative_path", "meta")
+                    .orderBy("created_at", "asc")
+                : [];
+            const artifactsByMessage = new Map();
+            for (const artifact of artifactRows) {
+                const meta = artifact.meta && typeof artifact.meta === "object" ? artifact.meta : {};
+                const list = artifactsByMessage.get(artifact.message_uuid) ?? [];
+                list.push({
+                    artifact_uuid: artifact.artifact_uuid,
+                    original_name: artifact.original_name,
+                    ...(artifact.mime_type ? { mime_type: artifact.mime_type } : {}),
+                    ...(typeof artifact.size_bytes === "number"
+                        ? { size_bytes: Number(artifact.size_bytes) }
+                        : {}),
+                    ...(artifact.storage_ref ? { storage_ref: artifact.storage_ref } : {}),
+                    ...(artifact.relative_path ? { relative_path: artifact.relative_path } : {}),
+                    ...(typeof meta.content_base64 === "string"
+                        ? {
+                            content_base64: meta.content_base64,
+                        }
+                        : {}),
+                });
+                artifactsByMessage.set(artifact.message_uuid, list);
+            }
+            return {
+                deliveries: rows.map((row) => {
+                    const meta = row.meta && typeof row.meta === "object" ? row.meta : {};
+                    const shareId = typeof meta.share_id === "string"
+                        ? meta.share_id
+                        : row.message_uuid;
+                    return {
+                        delivery_uuid: row.delivery_uuid,
+                        message_uuid: row.message_uuid,
+                        share_id: shareId,
+                        ...(row.project_uuid ? { project_uuid: row.project_uuid } : {}),
+                        ...(row.project_name ? { project_name: row.project_name } : {}),
+                        ...(row.source_actor_label
+                            ? { source_actor_label: row.source_actor_label }
+                            : {}),
+                        kind: row.kind,
+                        summary: row.summary,
+                        message: row.body,
+                        ...(row.expected_reply ? { expected_reply: row.expected_reply } : {}),
+                        requires_reply: Boolean(row.requires_reply),
+                        ...(row.in_reply_to ? { in_reply_to: row.in_reply_to } : {}),
+                        source_session_uuid: row.source_session_uuid,
+                        source_session_label: row.source_session_label ?? row.source_local_session_id,
+                        source_local_session_id: row.source_local_session_id,
+                        target_session_uuid: row.target_session_uuid,
+                        target_local_session_id: row.target_local_session_id,
+                        target_session_label: row.target_session_label ?? row.target_local_session_id,
+                        created_at: String(row.created_at),
+                        note_relative_path: `shares/${shareId}.md`,
+                        share_index_file_name: "SHARED_INDEX.md",
+                        artifacts: artifactsByMessage.get(row.message_uuid) ?? [],
+                    };
+                }),
+            };
+        },
+        async ackDeliveriesRecord(input) {
+            const clientUuid = this.requireText?.(input.client_uuid, "client_uuid");
+            const deliveryIds = Array.isArray(input.delivery_ids)
+                ? input.delivery_ids
+                    .map((item) => this.normalizeOptionalText?.(item))
+                    .filter((item) => Boolean(item))
+                : [];
+            if (deliveryIds.length === 0) {
+                throw new Error("delivery_ids must contain at least one id");
+            }
+            const rows = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_deliveries as d")
+                .join("gateway_messages as m", "m.message_uuid", "d.message_uuid")
+                .join("gateway_sessions as s_from", "s_from.session_uuid", "m.from_session_uuid")
+                .where("d.target_client_uuid", clientUuid)
+                .whereIn("d.delivery_uuid", deliveryIds)
+                .select("d.delivery_uuid", "d.delivered_at", "d.acked_at", "s_from.client_uuid as source_client_uuid", this.db.raw(`coalesce(m.meta->>'share_id', '') as share_id`));
+            const updated = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_deliveries")
+                .where("target_client_uuid", clientUuid)
+                .whereIn("delivery_uuid", deliveryIds)
+                .update({
+                status: "delivered",
+                acked_at: new Date().toISOString(),
+            });
+            return {
+                acked: updated,
+                deliveries: rows.map((row) => ({
+                    delivery_uuid: row.delivery_uuid,
+                    share_id: String(row.share_id || ""),
+                    status: "delivered",
+                    source_client_uuid: row.source_client_uuid,
+                    ...(row.delivered_at ? { delivered_at: String(row.delivered_at) } : {}),
+                    acked_at: new Date().toISOString(),
+                })),
+            };
+        },
+        async failDeliveriesRecord(input) {
+            const clientUuid = this.requireText?.(input.client_uuid, "client_uuid");
+            const deliveryIds = Array.isArray(input.delivery_ids)
+                ? input.delivery_ids
+                    .map((item) => this.normalizeOptionalText?.(item))
+                    .filter((item) => Boolean(item))
+                : [];
+            const errorText = this.normalizeOptionalText?.(input.error_text);
+            if (deliveryIds.length === 0) {
+                throw new Error("delivery_ids must contain at least one id");
+            }
+            const rows = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_deliveries as d")
+                .join("gateway_messages as m", "m.message_uuid", "d.message_uuid")
+                .join("gateway_sessions as s_from", "s_from.session_uuid", "m.from_session_uuid")
+                .where("d.target_client_uuid", clientUuid)
+                .whereIn("d.delivery_uuid", deliveryIds)
+                .select("d.delivery_uuid", "d.delivered_at", "d.acked_at", "s_from.client_uuid as source_client_uuid", this.db.raw(`coalesce(m.meta->>'share_id', '') as share_id`));
+            const updated = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_deliveries")
+                .where("target_client_uuid", clientUuid)
+                .whereIn("delivery_uuid", deliveryIds)
+                .update({
+                status: "failed",
+                ...(errorText ? { last_error: errorText } : {}),
+                acked_at: new Date().toISOString(),
+            });
+            return {
+                failed: updated,
+                deliveries: rows.map((row) => ({
+                    delivery_uuid: row.delivery_uuid,
+                    share_id: String(row.share_id || ""),
+                    status: "failed",
+                    source_client_uuid: row.source_client_uuid,
+                    ...(row.delivered_at ? { delivered_at: String(row.delivered_at) } : {}),
+                    acked_at: new Date().toISOString(),
+                })),
+            };
+        },
+        async listSenderDeliveryStatusesRecord(input) {
+            const clientUuid = this.requireText?.(input.client_uuid, "client_uuid");
+            const limit = typeof input.limit === "number" && Number.isFinite(input.limit)
+                ? Math.max(1, Math.min(200, Math.trunc(input.limit)))
+                : 100;
+            const rows = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_deliveries as d")
+                .join("gateway_messages as m", "m.message_uuid", "d.message_uuid")
+                .join("gateway_sessions as s_from", "s_from.session_uuid", "m.from_session_uuid")
+                .where("s_from.client_uuid", clientUuid)
+                .whereIn("d.status", ["delivered", "failed"])
+                .select("d.delivery_uuid", "d.status", "d.delivered_at", "d.acked_at", this.db.raw(`coalesce(m.meta->>'share_id', '') as share_id`))
+                .orderBy("d.acked_at", "desc")
+                .limit(limit);
+            return {
+                deliveries: rows.map((row) => ({
+                    delivery_uuid: row.delivery_uuid,
+                    share_id: String(row.share_id || ""),
+                    status: row.status,
+                    ...(row.delivered_at ? { delivered_at: String(row.delivered_at) } : {}),
+                    ...(row.acked_at ? { acked_at: String(row.acked_at) } : {}),
+                })),
+            };
+        },
+        async listSessionHistoryRecord(input) {
+            const clientUuid = this.requireText?.(input.client_uuid, "client_uuid");
+            const localSessionId = this.requireText?.(input.local_session_id, "local_session_id");
+            const limit = typeof input.limit === "number" && Number.isFinite(input.limit)
+                ? Math.max(1, Math.min(20, Math.trunc(input.limit)))
+                : 5;
+            const sessionRows = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_sessions")
+                .where({
+                client_uuid: clientUuid,
+                local_session_id: localSessionId,
+                status: "active",
+            })
+                .select("session_uuid");
+            const sessionUuids = sessionRows
+                .map((row) => this.normalizeOptionalText?.(row.session_uuid))
+                .filter((row) => Boolean(row));
+            if (sessionUuids.length === 0) {
+                return { history: [] };
+            }
+            const rows = await this.db
+                .withSchema(MCP_SCHEMA)
+                .table("gateway_messages as m")
+                .join("gateway_sessions as s_from", "s_from.session_uuid", "m.from_session_uuid")
+                .join("gateway_sessions as s_to", "s_to.session_uuid", "m.to_session_uuid")
+                .leftJoin("gateway_projects as p", "p.project_uuid", "m.project_uuid")
+                .leftJoin("gateway_deliveries as d", "d.message_uuid", "m.message_uuid")
+                .where((builder) => {
+                builder
+                    .whereIn("m.from_session_uuid", sessionUuids)
+                    .orWhereIn("m.to_session_uuid", sessionUuids);
+            })
+                .select("m.message_uuid", "m.kind", "m.summary", "m.created_at", "p.project_uuid", "p.name as project_name", "s_from.session_uuid as from_session_uuid", "s_from.local_session_id as from_local_session_id", "s_from.label as from_session_label", "s_to.session_uuid as to_session_uuid", "s_to.local_session_id as to_local_session_id", "s_to.label as to_session_label", "d.status as delivery_status")
+                .orderBy("m.created_at", "desc")
+                .limit(limit);
+            const currentSessionSet = new Set(sessionUuids);
+            return {
+                history: rows.map((row) => {
+                    const outgoing = currentSessionSet.has(String(row.from_session_uuid));
+                    return {
+                        message_uuid: String(row.message_uuid),
+                        kind: String(row.kind),
+                        summary: String(row.summary || ""),
+                        created_at: String(row.created_at),
+                        direction: outgoing ? "outgoing" : "incoming",
+                        ...(row.project_uuid ? { project_uuid: String(row.project_uuid) } : {}),
+                        ...(row.project_name ? { project_name: String(row.project_name) } : {}),
+                        from_session_id: String(row.from_local_session_id),
+                        from_label: String(row.from_session_label || row.from_local_session_id),
+                        to_session_id: String(row.to_local_session_id),
+                        to_label: String(row.to_session_label || row.to_local_session_id),
+                        ...(row.delivery_status
+                            ? { delivery_status: String(row.delivery_status) }
+                            : {}),
+                    };
+                }),
+            };
+        },
+    },
+    actions: {
+        registerClient: {
+            async handler(ctx) {
+                if (!GATEWAY_ENABLED) {
+                    throw new Error("Gateway service is disabled in client mode");
+                }
+                return this.registerClientRecord?.(ctx.params);
+            },
+        },
+        createProject: {
+            async handler(ctx) {
+                if (!GATEWAY_ENABLED) {
+                    throw new Error("Gateway service is disabled in client mode");
+                }
+                return this.createProjectRecord?.(ctx.params);
+            },
+        },
+        joinProject: {
+            async handler(ctx) {
+                if (!GATEWAY_ENABLED) {
+                    throw new Error("Gateway service is disabled in client mode");
+                }
+                return this.joinProjectRecord?.(ctx.params);
+            },
+        },
+        registerSession: {
+            async handler(ctx) {
+                if (!GATEWAY_ENABLED) {
+                    throw new Error("Gateway service is disabled in client mode");
+                }
+                return this.registerSessionRecord?.(ctx.params);
+            },
+        },
+        unregisterSession: {
+            async handler(ctx) {
+                if (!GATEWAY_ENABLED) {
+                    throw new Error("Gateway service is disabled in client mode");
+                }
+                return this.unregisterSessionRecord?.(ctx.params);
+            },
+        },
+        listProjects: {
+            async handler(ctx) {
+                if (!GATEWAY_ENABLED) {
+                    throw new Error("Gateway service is disabled in client mode");
+                }
+                return this.listProjectsRecord?.(ctx.params);
+            },
+        },
+        leaveProject: {
+            async handler(ctx) {
+                if (!GATEWAY_ENABLED) {
+                    throw new Error("Gateway service is disabled in client mode");
+                }
+                return this.leaveProjectRecord?.(ctx.params);
+            },
+        },
+        deleteProject: {
+            async handler(ctx) {
+                if (!GATEWAY_ENABLED) {
+                    throw new Error("Gateway service is disabled in client mode");
+                }
+                return this.deleteProjectRecord?.(ctx.params);
+            },
+        },
+        listProjectSessions: {
+            async handler(ctx) {
+                if (!GATEWAY_ENABLED) {
+                    throw new Error("Gateway service is disabled in client mode");
+                }
+                return this.listProjectSessionsRecord?.(ctx.params);
+            },
+        },
+        listSessionHistory: {
+            async handler(ctx) {
+                if (!GATEWAY_ENABLED) {
+                    throw new Error("Gateway service is disabled in client mode");
+                }
+                return this.listSessionHistoryRecord?.(ctx.params);
+            },
+        },
+        sendPartnerNote: {
+            async handler(ctx) {
+                if (!GATEWAY_ENABLED) {
+                    throw new Error("Gateway service is disabled in client mode");
+                }
+                return this.sendPartnerNoteRecord?.(ctx.params);
+            },
+        },
+        pollDeliveries: {
+            async handler(ctx) {
+                if (!GATEWAY_ENABLED) {
+                    throw new Error("Gateway service is disabled in client mode");
+                }
+                return this.pollDeliveriesRecord?.(ctx.params);
+            },
+        },
+        ackDeliveries: {
+            async handler(ctx) {
+                if (!GATEWAY_ENABLED) {
+                    throw new Error("Gateway service is disabled in client mode");
+                }
+                return this.ackDeliveriesRecord?.(ctx.params);
+            },
+        },
+        failDeliveries: {
+            async handler(ctx) {
+                if (!GATEWAY_ENABLED) {
+                    throw new Error("Gateway service is disabled in client mode");
+                }
+                return this.failDeliveriesRecord?.(ctx.params);
+            },
+        },
+        listSenderDeliveryStatuses: {
+            async handler(ctx) {
+                if (!GATEWAY_ENABLED) {
+                    throw new Error("Gateway service is disabled in client mode");
+                }
+                return this.listSenderDeliveryStatusesRecord?.(ctx.params);
+            },
+        },
+    },
+};
+exports.default = TelegramMcpGatewayService;