@deadragdoll/tellymcp 0.0.1

package/dist/services/features/telegram-mcp/src/features/distributed-gateway/model/gatewayHttpService.js

@@ -0,0 +1,657 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewayHttpService = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const schema_1 = require("../../../entities/request/model/schema");
+function readHeader(req, headerName) {
+    const value = req.headers[headerName];
+    return Array.isArray(value) ? value[0] : value;
+}
+function writeJson(res, statusCode, payload) {
+    res.statusCode = statusCode;
+    res.setHeader("content-type", "application/json");
+    res.end(JSON.stringify(payload));
+}
+function writeText(res, statusCode, message) {
+    res.statusCode = statusCode;
+    res.setHeader("content-type", "text/plain; charset=utf-8");
+    res.end(message);
+}
+function unwrapLiveRelayResult(response) {
+    if (!response || typeof response !== "object") {
+        return null;
+    }
+    if ("result" in response) {
+        const wrapped = response;
+        if (wrapped.result && typeof wrapped.result === "object") {
+            return wrapped.result;
+        }
+    }
+    return response;
+}
+function normalizeLiveRelayBootstrapResult(response) {
+    if (!response || typeof response !== "object") {
+        return null;
+    }
+    const record = response;
+    const sessionId = typeof record.session_id === "string" ? record.session_id.trim() : "";
+    const telegramUserId = typeof record.telegram_user_id === "number"
+        ? record.telegram_user_id
+        : typeof record.telegram_user_id === "string" &&
+            /^\d+$/u.test(record.telegram_user_id.trim())
+            ? Number(record.telegram_user_id.trim())
+            : NaN;
+    if (!sessionId || !Number.isFinite(telegramUserId)) {
+        return null;
+    }
+    return {
+        session_id: sessionId,
+        session_label: typeof record.session_label === "string" ? record.session_label : null,
+        tmux_target: record.tmux_target === true,
+        poll_interval_ms: typeof record.poll_interval_ms === "number" && record.poll_interval_ms > 0
+            ? record.poll_interval_ms
+            : 2000,
+        telegram_user_id: telegramUserId,
+    };
+}
+function buildPartnerNoteOutputFallback(input, rawOutput) {
+    const outputRecord = rawOutput && typeof rawOutput === "object"
+        ? rawOutput
+        : {};
+    return {
+        session_id: typeof outputRecord.session_id === "string"
+            ? outputRecord.session_id
+            : input.session_id ?? "unknown-session",
+        partner_session_id: typeof outputRecord.partner_session_id === "string"
+            ? outputRecord.partner_session_id
+            : input.target_session_id ?? "unknown-partner-session",
+        kind: typeof outputRecord.kind === "string"
+            ? outputRecord.kind
+            : input.kind,
+        share_id: typeof outputRecord.share_id === "string"
+            ? outputRecord.share_id
+            : `gateway-${Date.now()}`,
+        delivery_status: outputRecord.delivery_status === "delivered" ? "delivered" : "queued",
+        note_path: typeof outputRecord.note_path === "string"
+            ? outputRecord.note_path
+            : "gateway://shares/pending.md",
+        share_index_path: typeof outputRecord.share_index_path === "string"
+            ? outputRecord.share_index_path
+            : "gateway://SHARED_INDEX.md",
+        copied_artifacts: Array.isArray(outputRecord.copied_artifacts)
+            ? outputRecord.copied_artifacts.filter((item) => typeof item === "string")
+            : [
+                ...(input.artifact_refs?.map((item) => item.original_name ?? item.relative_path ?? item.file_path) ?? []),
+                ...(input.artifacts ?? []),
+            ],
+        inbox_message_id: typeof outputRecord.inbox_message_id === "string"
+            ? outputRecord.inbox_message_id
+            : `gateway-${Date.now()}`,
+        requires_reply: typeof outputRecord.requires_reply === "boolean"
+            ? outputRecord.requires_reply
+            : Boolean(input.requires_reply ?? (input.kind === "question" || input.kind === "request")),
+    };
+}
+class GatewayHttpService {
+    config;
+    callBroker;
+    constructor(config, callBroker) {
+        this.config = config;
+        this.callBroker = callBroker;
+    }
+    partnerNoteRelayHandler = null;
+    setPartnerNoteRelayHandler(handler) {
+        this.partnerNoteRelayHandler = handler;
+    }
+    isEnabled() {
+        return (this.config.distributed.mode === "gateway" ||
+            this.config.distributed.mode === "both");
+    }
+    matches(pathname) {
+        return pathname === "/gateway/healthz" || pathname.startsWith("/gateway/");
+    }
+    async requestLiveRelayBootstrap(input) {
+        const payload = typeof input.telegramUserId === "number"
+            ? {
+                telegramUserId: input.telegramUserId,
+                ...(input.allowForeignBinding ? { allowForeignBinding: true } : {}),
+            }
+            : {
+                initDataRaw: input.initDataRaw,
+                initDataUnsafe: input.initDataUnsafe,
+            };
+        const rawResponse = await this.callBroker("telegramMcp.gatewaySocket.requestLiveRelay", {
+            clientUuid: input.clientUuid,
+            localSessionId: input.localSessionId,
+            requestType: "bootstrap",
+            payload,
+        }, { meta: { internal_call: true } });
+        const response = normalizeLiveRelayBootstrapResult(unwrapLiveRelayResult(rawResponse));
+        if (!response) {
+            throw new Error(`Invalid live relay bootstrap response: ${JSON.stringify(rawResponse)}`);
+        }
+        return response;
+    }
+    async requestLiveRelayBootstrapValidation(input) {
+        const rawResponse = await this.callBroker("telegramMcp.gatewaySocket.requestLiveRelay", {
+            clientUuid: input.clientUuid,
+            localSessionId: "",
+            requestType: "bootstrap_validate",
+            payload: {
+                initDataRaw: input.initDataRaw,
+                initDataUnsafe: input.initDataUnsafe,
+            },
+        }, { meta: { internal_call: true } });
+        const response = unwrapLiveRelayResult(rawResponse);
+        if (!response ||
+            typeof response !== "object" ||
+            typeof response.telegram_user_id !== "number") {
+            throw new Error(`Invalid live relay bootstrap validation response: ${JSON.stringify(rawResponse)}`);
+        }
+        return response;
+    }
+    async requestLiveRelayView(input) {
+        const rawResponse = await this.callBroker("telegramMcp.gatewaySocket.requestLiveRelay", {
+            clientUuid: input.clientUuid,
+            localSessionId: input.localSessionId,
+            requestType: "view",
+            payload: {},
+        }, { meta: { internal_call: true } });
+        const response = unwrapLiveRelayResult(rawResponse);
+        if (!response ||
+            typeof response !== "object" ||
+            typeof response.content !== "string") {
+            throw new Error("Invalid live relay view response");
+        }
+        return response;
+    }
+    async requestLiveRelayAction(input) {
+        const rawResponse = await this.callBroker("telegramMcp.gatewaySocket.requestLiveRelay", {
+            clientUuid: input.clientUuid,
+            localSessionId: input.localSessionId,
+            requestType: "action",
+            payload: {
+                action: input.action,
+            },
+        }, { meta: { internal_call: true } });
+        const response = unwrapLiveRelayResult(rawResponse);
+        if (!response ||
+            typeof response !== "object" ||
+            response.ok !== true) {
+            throw new Error("Invalid live relay action response");
+        }
+        return response;
+    }
+    isAuthorized(req) {
+        if (!this.config.distributed.gatewayAuthToken) {
+            return true;
+        }
+        const authorization = readHeader(req, "authorization");
+        return authorization === `Bearer ${this.config.distributed.gatewayAuthToken}`;
+    }
+    extractActionErrorMessage(value, fallback) {
+        if (value && typeof value === "object") {
+            const record = value;
+            if (typeof record.message === "string" && record.message.trim()) {
+                return record.message;
+            }
+            const extensions = record.extensions;
+            if (extensions && typeof extensions === "object") {
+                const extRecord = extensions;
+                if (typeof extRecord.message === "string" && extRecord.message.trim()) {
+                    return extRecord.message;
+                }
+            }
+        }
+        return fallback;
+    }
+    async readJsonBody(req) {
+        const knownBody = req.body;
+        if (knownBody !== undefined) {
+            return knownBody;
+        }
+        const knownParams = req.$params;
+        if (knownParams &&
+            typeof knownParams === "object" &&
+            ("kind" in knownParams ||
+                "summary" in knownParams ||
+                "message" in knownParams ||
+                "session_id" in knownParams)) {
+            return knownParams;
+        }
+        const chunks = [];
+        for await (const chunk of req) {
+            chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+        }
+        if (chunks.length === 0) {
+            return undefined;
+        }
+        const raw = Buffer.concat(chunks).toString("utf8").trim();
+        if (!raw) {
+            return undefined;
+        }
+        return JSON.parse(raw);
+    }
+    async handleRequest(req, res, pathname) {
+        if (!this.isEnabled() || !this.matches(pathname)) {
+            return false;
+        }
+        if (pathname === "/gateway/healthz") {
+            writeJson(res, 200, {
+                ok: true,
+                service: "telegram-human-mcp-gateway",
+                mode: this.config.distributed.mode,
+                databaseConfigured: Boolean(process.env.DB_HOST && process.env.DB_NAME),
+                s3Configured: Boolean(this.config.distributed.gatewayS3Bucket),
+            });
+            return true;
+        }
+        if (!this.isAuthorized(req)) {
+            writeText(res, 401, "Unauthorized");
+            return true;
+        }
+        if (pathname === "/gateway/tools-md") {
+            if (req.method !== "GET") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const toolsPath = (0, node_path_1.join)(process.cwd(), "TOOLS.md");
+                res.statusCode = 200;
+                res.setHeader("content-type", "text/markdown; charset=utf-8");
+                res.end((0, node_fs_1.readFileSync)(toolsPath, "utf8"));
+                return true;
+            }
+            catch (error) {
+                writeJson(res, 404, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
+        if (pathname === "/gateway/partner-note") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = await this.readJsonBody(req);
+                const input = schema_1.sendPartnerNoteInputSchema.parse(body);
+                const useQueuedGatewayDelivery = typeof body?.client_uuid === "string" &&
+                    typeof input.target_session_id === "string" &&
+                    input.target_session_id.trim().length > 0;
+                const output = useQueuedGatewayDelivery
+                    ? await this.callBroker("telegramMcp.gateway.sendPartnerNote", body, { meta: { internal_call: true } })
+                    : this.partnerNoteRelayHandler
+                        ? await this.partnerNoteRelayHandler(input)
+                        : (() => {
+                            throw new Error("Gateway partner relay handler is not configured.");
+                        })();
+                if (useQueuedGatewayDelivery &&
+                    output &&
+                    typeof output === "object" &&
+                    typeof output.target_client_uuid ===
+                        "string" &&
+                    output.delivery &&
+                    typeof output.delivery === "object") {
+                    const publishResult = await this.callBroker("telegramMcp.gatewayRmq.publishDeliveryQueued", {
+                        clientUuid: output.target_client_uuid,
+                        delivery: output.delivery,
+                    }, { meta: { internal_call: true } });
+                    if (!publishResult?.published) {
+                        await this.callBroker("telegramMcp.gatewaySocket.notifyDeliveryQueued", {
+                            clientUuid: output.target_client_uuid,
+                            delivery: output.delivery,
+                        }, { meta: { internal_call: true } });
+                    }
+                }
+                const parsedOutput = schema_1.sendPartnerNoteOutputSchema.safeParse(output);
+                if (!parsedOutput.success) {
+                    if (useQueuedGatewayDelivery) {
+                        writeJson(res, 500, {
+                            error: "Invalid queued gateway partner-note response",
+                            details: parsedOutput.error.issues,
+                            output,
+                        });
+                        return true;
+                    }
+                    const fallback = buildPartnerNoteOutputFallback(input, output);
+                    writeJson(res, 200, fallback);
+                    return true;
+                }
+                writeJson(res, 200, parsedOutput.data);
+                return true;
+            }
+            catch (error) {
+                writeJson(res, 400, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
+        if (pathname === "/gateway/live/request-approval") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const clientUuid = typeof body.client_uuid === "string" ? body.client_uuid.trim() : "";
+                const payload = body.payload && typeof body.payload === "object"
+                    ? body.payload
+                    : null;
+                if (!clientUuid || !payload) {
+                    writeJson(res, 400, { error: "client_uuid and payload are required" });
+                    return true;
+                }
+                const result = await this.callBroker("telegramMcp.gatewaySocket.notifyLiveApprovalRequest", {
+                    clientUuid,
+                    payload,
+                }, { meta: { internal_call: true } });
+                writeJson(res, 200, { delivered: Boolean(result?.delivered) });
+                return true;
+            }
+            catch (error) {
+                writeJson(res, 400, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
+        if (pathname === "/gateway/live/resolve-approval") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const clientUuid = typeof body.client_uuid === "string" ? body.client_uuid.trim() : "";
+                const approved = body.approved === true;
+                const payload = body.payload && typeof body.payload === "object"
+                    ? body.payload
+                    : null;
+                if (!clientUuid || !payload) {
+                    writeJson(res, 400, { error: "client_uuid and payload are required" });
+                    return true;
+                }
+                const result = await this.callBroker("telegramMcp.gatewaySocket.notifyLiveApprovalResolved", {
+                    clientUuid,
+                    approved,
+                    payload,
+                }, { meta: { internal_call: true } });
+                writeJson(res, 200, { delivered: Boolean(result?.delivered) });
+                return true;
+            }
+            catch (error) {
+                writeJson(res, 400, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
+        if (pathname === "/gateway/client/register") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const result = await this.callBroker("telegramMcp.gateway.registerClient", body, { meta: { internal_call: true } });
+                writeJson(res, 200, result);
+                return true;
+            }
+            catch (error) {
+                writeJson(res, 400, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
+        if (pathname === "/gateway/projects/create") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const result = await this.callBroker("telegramMcp.gateway.createProject", body, { meta: { internal_call: true } });
+                writeJson(res, 200, result);
+                return true;
+            }
+            catch (error) {
+                writeJson(res, 400, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
+        if (pathname === "/gateway/projects/join") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const result = await this.callBroker("telegramMcp.gateway.joinProject", body, { meta: { internal_call: true } });
+                if (Array.isArray(result.notify_client_uuids) &&
+                    result.notify_client_uuids.length > 0 &&
+                    typeof result.project_uuid === "string" &&
+                    typeof result.name === "string") {
+                    const publishResult = await this.callBroker("telegramMcp.gatewayRmq.publishProjectMemberJoined", {
+                        clientUuids: result.notify_client_uuids,
+                        projectUuid: result.project_uuid,
+                        projectName: result.name,
+                        memberDisplayName: typeof result.member_display_name === "string"
+                            ? result.member_display_name
+                            : undefined,
+                        memberTelegramUsername: typeof result.member_telegram_username === "string"
+                            ? result.member_telegram_username
+                            : undefined,
+                    }, { meta: { internal_call: true } });
+                    if (!publishResult?.published) {
+                        await this.callBroker("telegramMcp.gatewaySocket.notifyProjectMemberJoined", {
+                            clientUuids: result.notify_client_uuids,
+                            projectUuid: result.project_uuid,
+                            projectName: result.name,
+                            memberDisplayName: typeof result.member_display_name === "string"
+                                ? result.member_display_name
+                                : undefined,
+                            memberTelegramUsername: typeof result.member_telegram_username === "string"
+                                ? result.member_telegram_username
+                                : undefined,
+                        }, { meta: { internal_call: true } });
+                    }
+                }
+                writeJson(res, 200, result);
+                return true;
+            }
+            catch (error) {
+                writeJson(res, 400, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
+        if (pathname === "/gateway/sessions/register") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const result = await this.callBroker("telegramMcp.gateway.registerSession", body, { meta: { internal_call: true } });
+                writeJson(res, 200, result);
+                return true;
+            }
+            catch (error) {
+                writeJson(res, 400, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
+        if (pathname === "/gateway/sessions/unregister") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const result = await this.callBroker("telegramMcp.gateway.unregisterSession", body, { meta: { internal_call: true } });
+                writeJson(res, 200, result);
+                return true;
+            }
+            catch (error) {
+                writeJson(res, 400, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
+        if (pathname === "/gateway/projects/list") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const result = await this.callBroker("telegramMcp.gateway.listProjects", body, { meta: { internal_call: true } });
+                writeJson(res, 200, result);
+                return true;
+            }
+            catch (error) {
+                writeJson(res, 400, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
+        if (pathname === "/gateway/history/list") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const result = await this.callBroker("telegramMcp.gateway.listSessionHistory", body, { meta: { internal_call: true } });
+                writeJson(res, 200, result);
+                return true;
+            }
+            catch (error) {
+                writeJson(res, 400, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
+        if (pathname === "/gateway/projects/leave") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const result = await this.callBroker("telegramMcp.gateway.leaveProject", body, { meta: { internal_call: true } });
+                if (result.left === true &&
+                    Array.isArray(result.notify_client_uuids) &&
+                    result.notify_client_uuids.length > 0 &&
+                    typeof result.project_uuid === "string" &&
+                    typeof result.project_name === "string") {
+                    const publishResult = await this.callBroker("telegramMcp.gatewayRmq.publishProjectMemberLeft", {
+                        clientUuids: result.notify_client_uuids,
+                        projectUuid: result.project_uuid,
+                        projectName: result.project_name,
+                        memberDisplayName: typeof result.member_display_name === "string"
+                            ? result.member_display_name
+                            : undefined,
+                        memberTelegramUsername: typeof result.member_telegram_username === "string"
+                            ? result.member_telegram_username
+                            : undefined,
+                    }, { meta: { internal_call: true } });
+                    if (!publishResult?.published) {
+                        await this.callBroker("telegramMcp.gatewaySocket.notifyProjectMemberLeft", {
+                            clientUuids: result.notify_client_uuids,
+                            projectUuid: result.project_uuid,
+                            projectName: result.project_name,
+                            memberDisplayName: typeof result.member_display_name === "string"
+                                ? result.member_display_name
+                                : undefined,
+                            memberTelegramUsername: typeof result.member_telegram_username === "string"
+                                ? result.member_telegram_username
+                                : undefined,
+                        }, { meta: { internal_call: true } });
+                    }
+                }
+                writeJson(res, 200, result);
+                return true;
+            }
+            catch (error) {
+                writeJson(res, 400, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
+        if (pathname === "/gateway/projects/delete") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const result = await this.callBroker("telegramMcp.gateway.deleteProject", body, { meta: { internal_call: true } });
+                if (result.deleted === true &&
+                    Array.isArray(result.notify_client_uuids) &&
+                    result.notify_client_uuids.length > 0 &&
+                    typeof result.project_uuid === "string" &&
+                    typeof result.project_name === "string") {
+                    const publishResult = await this.callBroker("telegramMcp.gatewayRmq.publishProjectDeleted", {
+                        clientUuids: result.notify_client_uuids,
+                        projectUuid: result.project_uuid,
+                        projectName: result.project_name,
+                    }, { meta: { internal_call: true } });
+                    if (!publishResult?.published) {
+                        await this.callBroker("telegramMcp.gatewaySocket.notifyProjectDeleted", {
+                            clientUuids: result.notify_client_uuids,
+                            projectUuid: result.project_uuid,
+                            projectName: result.project_name,
+                        }, { meta: { internal_call: true } });
+                    }
+                }
+                writeJson(res, 200, result);
+                return true;
+            }
+            catch (error) {
+                writeJson(res, 400, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
+        if (pathname === "/gateway/projects/sessions") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const result = await this.callBroker("telegramMcp.gateway.listProjectSessions", body, { meta: { internal_call: true } });
+                writeJson(res, 200, result);
+                return true;
+            }
+            catch (error) {
+                writeJson(res, 400, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
+        writeJson(res, 501, {
+            error: "Distributed gateway relay is scaffolded but not implemented yet in this build.",
+            mode: this.config.distributed.mode,
+        });
+        return true;
+    }
+}
+exports.GatewayHttpService = GatewayHttpService;

package/dist/services/features/telegram-mcp/src/features/distributed-gateway/model/gatewayReplyResolution.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGatewayInReplyTo = resolveGatewayInReplyTo;
+function normalizeOptionalText(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+async function resolveGatewayInReplyTo(inReplyTo, deps) {
+    const candidate = normalizeOptionalText(inReplyTo);
+    if (!candidate) {
+        return undefined;
+    }
+    const direct = normalizeOptionalText(await deps.findMessageUuidByMessageUuid(candidate));
+    if (direct) {
+        return direct;
+    }
+    return normalizeOptionalText(await deps.findMessageUuidByShareId(candidate));
+}