@deadragdoll/tellymcp 0.0.10 → 0.0.11

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

@@ -4,6 +4,8 @@ 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");
+const relay_1 = require("../../../app/webapp/relay");
+const versionHandshake_1 = require("../../../shared/lib/version/versionHandshake");
 function readHeader(req, headerName) {
     const value = req.headers[headerName];
     return Array.isArray(value) ? value[0] : value;
@@ -18,6 +20,28 @@ function writeText(res, statusCode, message) {
     res.setHeader("content-type", "text/plain; charset=utf-8");
     res.end(message);
 }
+function isBackendErrorLike(value) {
+    return Boolean(value &&
+        typeof value === "object" &&
+        typeof value.statusCode === "number" &&
+        typeof value.code === "string");
+}
+function parseCanonicalGatewaySessionId(value) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const separatorIndex = trimmed.indexOf(":");
+    if (separatorIndex <= 0 || separatorIndex === trimmed.length - 1) {
+        return null;
+    }
+    const clientUuid = trimmed.slice(0, separatorIndex).trim();
+    const localSessionId = trimmed.slice(separatorIndex + 1).trim();
+    if (!clientUuid || !localSessionId) {
+        return null;
+    }
+    return { clientUuid, localSessionId };
+}
 function unwrapLiveRelayResult(response) {
     if (!response || typeof response !== "object") {
         return null;
@@ -48,50 +72,20 @@ function normalizeLiveRelayBootstrapResult(response) {
     return {
         session_id: sessionId,
         session_label: typeof record.session_label === "string" ? record.session_label : null,
-        tmux_target: record.tmux_target === true,
+        terminal_target: record.terminal_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")),
-    };
+function slugifyGatewayFilenamePart(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/gu, "-")
+        .replace(/-+/gu, "-")
+        .replace(/^-|-$/gu, "");
 }
 class GatewayHttpService {
     config;
@@ -207,6 +201,27 @@ class GatewayHttpService {
         }
         return fallback;
     }
+    async resolveConnectedConsoleTarget(sessionId) {
+        const relayTarget = (0, relay_1.parseLiveRelaySessionId)(sessionId);
+        if (relayTarget) {
+            return {
+                clientUuid: relayTarget.clientUuid,
+                localSessionId: relayTarget.localSessionId,
+            };
+        }
+        const trimmedSessionId = sessionId.trim();
+        if (!trimmedSessionId) {
+            throw new Error("relay or canonical session_id is required");
+        }
+        const resolved = await this.callBroker("telegramMcp.gatewaySocket.resolveConnectedSessionTarget", { sessionId: trimmedSessionId }, { meta: { internal_call: true } });
+        if (!resolved) {
+            throw new Error(`Could not resolve live console target for session_id '${trimmedSessionId}'.`);
+        }
+        return {
+            clientUuid: resolved.client_uuid,
+            localSessionId: resolved.local_session_id,
+        };
+    }
     async readJsonBody(req) {
         const knownBody = req.body;
         if (knownBody !== undefined) {
@@ -258,7 +273,11 @@ class GatewayHttpService {
                 return true;
             }
             try {
-                const toolsPath = (0, node_path_1.join)(process.cwd(), "TOOLS.md");
+                const packageRoot = (0, versionHandshake_1.getTellyMcpPackageRoot)(__dirname);
+                if (!packageRoot) {
+                    throw new Error("Could not resolve installed package root for TOOLS.md.");
+                }
+                const toolsPath = (0, node_path_1.join)(packageRoot, "TOOLS.md");
                 res.statusCode = 200;
                 res.setHeader("content-type", "text/markdown; charset=utf-8");
                 res.end((0, node_fs_1.readFileSync)(toolsPath, "utf8"));
@@ -279,16 +298,90 @@ class GatewayHttpService {
             try {
                 const body = await this.readJsonBody(req);
                 const input = schema_1.sendPartnerNoteInputSchema.parse(body);
-                const useQueuedGatewayDelivery = typeof body?.client_uuid === "string" &&
+                const canonicalSource = parseCanonicalGatewaySessionId(input.session_id);
+                const relaySource = (0, relay_1.parseLiveRelaySessionId)(input.session_id);
+                const resolvedSourceClientUuid = canonicalSource?.clientUuid ||
+                    relaySource?.clientUuid ||
+                    (typeof body?.client_uuid === "string"
+                        ? String(body.client_uuid).trim()
+                        : "");
+                const resolvedSourceLocalSessionId = canonicalSource?.localSessionId ||
+                    relaySource?.localSessionId ||
+                    input.session_id?.trim() ||
+                    "";
+                const explicitTargetClientUuid = typeof body?.target_client_uuid ===
+                    "string"
+                    ? String(body.target_client_uuid).trim()
+                    : "";
+                const explicitTargetLocalSessionId = typeof body
+                    ?.target_local_session_id === "string"
+                    ? String(body.target_local_session_id).trim()
+                    : "";
+                const canonicalTarget = parseCanonicalGatewaySessionId(input.target_session_id);
+                const resolvedTargetClientUuid = explicitTargetClientUuid || canonicalTarget?.clientUuid || "";
+                const resolvedTargetLocalSessionId = explicitTargetLocalSessionId || canonicalTarget?.localSessionId || "";
+                const useDirectGatewayDelivery = Boolean(resolvedSourceClientUuid) &&
+                    Boolean(resolvedSourceLocalSessionId) &&
+                    Boolean(resolvedTargetClientUuid) &&
+                    Boolean(resolvedTargetLocalSessionId);
+                const useQueuedGatewayDelivery = !useDirectGatewayDelivery &&
+                    Boolean(resolvedSourceClientUuid) &&
+                    Boolean(resolvedSourceLocalSessionId) &&
                     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.");
-                        })();
+                const output = useDirectGatewayDelivery
+                    ? await this.callBroker("telegramMcp.gatewaySocket.sendDirectPartnerNote", {
+                        clientUuid: resolvedSourceClientUuid,
+                        localSessionId: resolvedSourceLocalSessionId,
+                        targetClientUuid: resolvedTargetClientUuid,
+                        targetLocalSessionId: resolvedTargetLocalSessionId,
+                        kind: input.kind,
+                        summary: input.summary,
+                        message: input.message,
+                        ...(input.expected_reply?.trim()
+                            ? { expectedReply: input.expected_reply.trim() }
+                            : {}),
+                        ...(typeof input.requires_reply === "boolean"
+                            ? { requiresReply: input.requires_reply }
+                            : {}),
+                        ...(input.in_reply_to?.trim()
+                            ? { inReplyTo: input.in_reply_to.trim() }
+                            : {}),
+                        ...(Array.isArray(input.artifact_refs)
+                            ? { artifactRefs: input.artifact_refs }
+                            : {}),
+                    }, { meta: { internal_call: true } })
+                    : useQueuedGatewayDelivery
+                        ? await this.callBroker("telegramMcp.gateway.sendPartnerNote", {
+                            ...body,
+                            client_uuid: resolvedSourceClientUuid,
+                            session_id: resolvedSourceLocalSessionId,
+                        }, { meta: { internal_call: true } })
+                        : this.partnerNoteRelayHandler
+                            ? await this.partnerNoteRelayHandler(input)
+                            : (() => {
+                                throw new Error("Gateway partner relay handler is not configured.");
+                            })();
+                if (isBackendErrorLike(output)) {
+                    const detail = typeof output.data !== "undefined"
+                        ? (() => {
+                            try {
+                                return JSON.stringify(output.data);
+                            }
+                            catch {
+                                return String(output.data);
+                            }
+                        })()
+                        : "";
+                    throw new Error([
+                        typeof output.message === "string" && output.message.trim()
+                            ? output.message.trim()
+                            : `${output.name ?? "BackendError"} (${output.code})`,
+                        `code=${output.code}`,
+                        `statusCode=${output.statusCode}`,
+                        ...(detail ? [`data=${detail}`] : []),
+                    ].join("\n"));
+                }
                 if (useQueuedGatewayDelivery &&
                     output &&
                     typeof output === "object" &&
@@ -309,22 +402,22 @@ class GatewayHttpService {
                 }
                 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);
+                    writeJson(res, 500, {
+                        error: useQueuedGatewayDelivery
+                            ? "Invalid queued gateway partner-note response"
+                            : "Invalid direct gateway partner-note response",
+                        details: parsedOutput.error.issues,
+                        output,
+                    });
                     return true;
                 }
                 writeJson(res, 200, parsedOutput.data);
                 return true;
             }
             catch (error) {
+                console.error("Gateway partner-note request failed", {
+                    error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                });
                 writeJson(res, 400, {
                     error: error instanceof Error ? error.message : String(error),
                 });
@@ -354,6 +447,111 @@ class GatewayHttpService {
                 return true;
             }
             catch (error) {
+                console.error("Gateway live approval request failed", {
+                    error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                });
+                writeJson(res, 400, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
+        if (pathname === "/gateway/storage/list") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const sessionId = typeof body.session_id === "string" ? body.session_id.trim() : "";
+                const source = typeof body.source === "string" ? body.source.trim() : "";
+                const target = await this.resolveConnectedConsoleTarget(sessionId);
+                const output = await this.callBroker("telegramMcp.gatewaySocket.requestClientAction", {
+                    clientUuid: target.clientUuid,
+                    actionName: "telegramMcp.xchange.listFileMetasRemote",
+                    params: {
+                        session_id: target.localSessionId,
+                        ...(source ? { source } : {}),
+                    },
+                }, { meta: { internal_call: true } });
+                if (isBackendErrorLike(output)) {
+                    throw new Error(this.extractActionErrorMessage(output, "Storage list failed"));
+                }
+                writeJson(res, 200, output);
+                return true;
+            }
+            catch (error) {
+                console.error("Gateway storage list request failed", {
+                    error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                });
+                writeJson(res, 400, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
+        if (pathname === "/gateway/storage/meta") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const sessionId = typeof body.session_id === "string" ? body.session_id.trim() : "";
+                const filePath = typeof body.file_path === "string" ? body.file_path.trim() : "";
+                const target = await this.resolveConnectedConsoleTarget(sessionId);
+                const output = await this.callBroker("telegramMcp.gatewaySocket.requestClientAction", {
+                    clientUuid: target.clientUuid,
+                    actionName: "telegramMcp.xchange.getFileMetaRemote",
+                    params: {
+                        session_id: target.localSessionId,
+                        file_path: filePath,
+                    },
+                }, { meta: { internal_call: true } });
+                if (isBackendErrorLike(output)) {
+                    throw new Error(this.extractActionErrorMessage(output, "Storage meta fetch failed"));
+                }
+                writeJson(res, 200, output);
+                return true;
+            }
+            catch (error) {
+                console.error("Gateway storage meta request failed", {
+                    error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                });
+                writeJson(res, 400, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
+        if (pathname === "/gateway/storage/delete-meta") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const sessionId = typeof body.session_id === "string" ? body.session_id.trim() : "";
+                const filePath = typeof body.file_path === "string" ? body.file_path.trim() : "";
+                const target = await this.resolveConnectedConsoleTarget(sessionId);
+                const output = await this.callBroker("telegramMcp.gatewaySocket.requestClientAction", {
+                    clientUuid: target.clientUuid,
+                    actionName: "telegramMcp.xchange.deleteFileMetaRemote",
+                    params: {
+                        session_id: target.localSessionId,
+                        file_path: filePath,
+                    },
+                }, { meta: { internal_call: true } });
+                if (isBackendErrorLike(output)) {
+                    throw new Error(this.extractActionErrorMessage(output, "Storage meta delete failed"));
+                }
+                writeJson(res, 200, output);
+                return true;
+            }
+            catch (error) {
+                console.error("Gateway storage delete-meta request failed", {
+                    error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                });
                 writeJson(res, 400, {
                     error: error instanceof Error ? error.message : String(error),
                 });
@@ -385,12 +583,99 @@ class GatewayHttpService {
                 return true;
             }
             catch (error) {
+                console.error("Gateway live approval resolution failed", {
+                    error: error instanceof Error ? (error.stack ?? error.message) : String(error),
+                });
                 writeJson(res, 400, {
                     error: error instanceof Error ? error.message : String(error),
                 });
                 return true;
             }
         }
+        if (pathname === "/gateway/live/capture-buffer") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const sessionId = typeof body.session_id === "string" ? body.session_id.trim() : "";
+                const relayTarget = (0, relay_1.parseLiveRelaySessionId)(sessionId);
+                const scope = body.scope && typeof body.scope === "object"
+                    ? body.scope
+                    : null;
+                if (!relayTarget || !scope) {
+                    writeJson(res, 400, {
+                        error: "relay session_id and scope are required",
+                    });
+                    return true;
+                }
+                if (scope.mode === "visible") {
+                    const rawResponse = await this.callBroker("telegramMcp.gatewaySocket.requestLiveRelay", {
+                        clientUuid: relayTarget.clientUuid,
+                        localSessionId: relayTarget.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");
+                    }
+                    const capturedAt = new Date().toISOString();
+                    const titleBase = typeof response.session_label === "string" && response.session_label.trim()
+                        ? response.session_label.trim()
+                        : relayTarget.localSessionId;
+                    const filenameBase = slugifyGatewayFilenamePart(titleBase) || "session-buffer";
+                    const timestamp = capturedAt.replace(/[:.]/g, "-");
+                    writeJson(res, 200, {
+                        session_id: sessionId,
+                        ...(typeof response.session_label === "string" &&
+                            response.session_label.trim()
+                            ? { session_label: response.session_label.trim() }
+                            : {}),
+                        terminal_target: `relay:${relayTarget.clientUuid}/${relayTarget.localSessionId}`,
+                        filename: `${filenameBase}-${timestamp}.md`,
+                        markdown_content: [
+                            "# Terminal Buffer",
+                            "",
+                            `- Session: ${titleBase}`,
+                            `- Session ID: ${sessionId}`,
+                            `- terminal target: relay:${relayTarget.clientUuid}/${relayTarget.localSessionId}`,
+                            "- Capture scope: visible pane",
+                            `- Captured at: ${capturedAt}`,
+                            "",
+                            "```text",
+                            response.content.replaceAll("\u0000", ""),
+                            "```",
+                            "",
+                        ].join("\n"),
+                        capture_mode: "visible",
+                        scope_description: "visible pane",
+                    });
+                    return true;
+                }
+                const result = await this.callBroker("telegramMcp.gatewaySocket.requestClientAction", {
+                    clientUuid: relayTarget.clientUuid,
+                    actionName: "telegramMcp.terminalBuffer.captureBufferRemote",
+                    params: {
+                        session_id: relayTarget.localSessionId,
+                        scope,
+                    },
+                }, { meta: { internal_call: true } });
+                writeJson(res, 200, result);
+                return true;
+            }
+            catch (error) {
+                writeJson(res, 400, {
+                    error: error instanceof Error
+                        ? error.message
+                        : `Failed to capture remote buffer. Update the client agent if it is not on the latest build. Cause: ${String(error)}`,
+                });
+                return true;
+            }
+        }
         if (pathname === "/gateway/client/register") {
             if (req.method !== "POST") {
                 writeText(res, 405, "Method not allowed");
@@ -409,6 +694,298 @@ class GatewayHttpService {
                 return true;
             }
         }
+        if (pathname === "/gateway/user/auth") {
+            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.upsertGatewayUser", 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/user/route") {
+            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.resolveGatewayUserRoute", 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/admin/prune-state") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const result = await this.callBroker("telegramMcp.gateway.pruneGatewayState", {}, { 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/relay/console-message") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const targetClientUuid = typeof body.target_client_uuid === "string"
+                    ? body.target_client_uuid.trim()
+                    : "";
+                const targetLocalSessionId = typeof body.target_local_session_id === "string"
+                    ? body.target_local_session_id.trim()
+                    : "";
+                const text = typeof body.message === "string" ? body.message.trim() : "";
+                const attachments = Array.isArray(body.attachments)
+                    ? body.attachments.filter((item) => typeof item === "string" && item.trim().length > 0)
+                    : [];
+                const sourceLabel = typeof body.source_actor_label === "string"
+                    ? body.source_actor_label.trim()
+                    : undefined;
+                if (!targetClientUuid || !targetLocalSessionId || !text) {
+                    writeJson(res, 400, {
+                        error: "target_client_uuid, target_local_session_id, and message are required",
+                    });
+                    return true;
+                }
+                const submittedText = attachments.length > 0
+                    ? `${text} [attachments saved: ${attachments.join(", ")}]`.trim()
+                    : text;
+                await this.requestLiveRelayAction({
+                    clientUuid: targetClientUuid,
+                    localSessionId: targetLocalSessionId,
+                    action: "text",
+                    text: submittedText,
+                });
+                await this.requestLiveRelayAction({
+                    clientUuid: targetClientUuid,
+                    localSessionId: targetLocalSessionId,
+                    action: "enter",
+                });
+                writeJson(res, 200, {
+                    ok: true,
+                    session_id: targetLocalSessionId,
+                    submitted_text: submittedText,
+                    ...(sourceLabel ? { source_label: sourceLabel } : {}),
+                });
+                return true;
+            }
+            catch (error) {
+                writeJson(res, 400, {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                return true;
+            }
+        }
+        if (pathname === "/gateway/transport/notify") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = await this.readJsonBody(req);
+                const output = await this.callBroker("telegramMcp.notify.sendForGatewaySession", body, { meta: { internal_call: true } });
+                writeJson(res, 200, output);
+            }
+            catch (error) {
+                writeText(res, 500, error instanceof Error ? error.message : String(error));
+            }
+            return true;
+        }
+        if (pathname === "/gateway/transport/document") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = await this.readJsonBody(req);
+                const output = await this.callBroker("telegramMcp.notify.sendDocumentForGatewaySession", body, { meta: { internal_call: true } });
+                writeJson(res, 200, output);
+            }
+            catch (error) {
+                writeText(res, 500, error instanceof Error ? error.message : String(error));
+            }
+            return true;
+        }
+        if (pathname === "/gateway/transport/send-file") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const sessionId = typeof body.session_id === "string" ? body.session_id.trim() : "";
+                const filePath = typeof body.file_path === "string" ? body.file_path.trim() : "";
+                const caption = typeof body.caption === "string" && body.caption.trim()
+                    ? body.caption.trim()
+                    : undefined;
+                const target = await this.resolveConnectedConsoleTarget(sessionId);
+                const output = await this.callBroker("telegramMcp.gatewaySocket.requestClientAction", {
+                    clientUuid: target.clientUuid,
+                    actionName: "telegramMcp.notify.sendDocumentRemote",
+                    params: {
+                        session_id: target.localSessionId,
+                        file_path: filePath,
+                        ...(caption ? { caption } : {}),
+                    },
+                }, { meta: { internal_call: true } });
+                if (isBackendErrorLike(output)) {
+                    throw new Error(this.extractActionErrorMessage(output, "Storage file send failed"));
+                }
+                writeJson(res, 200, output);
+            }
+            catch (error) {
+                writeText(res, 500, error instanceof Error ? error.message : String(error));
+            }
+            return true;
+        }
+        if (pathname === "/gateway/transport/request") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = await this.readJsonBody(req);
+                const output = await this.callBroker("telegramMcp.notify.sendRequestForGatewaySession", body, { meta: { internal_call: true } });
+                writeJson(res, 200, output);
+            }
+            catch (error) {
+                writeText(res, 500, error instanceof Error ? error.message : String(error));
+            }
+            return true;
+        }
+        if (pathname === "/gateway/transport/reply") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = await this.readJsonBody(req);
+                const output = await this.callBroker("telegramMcp.gatewaySocket.notifyTransportReply", body, { meta: { internal_call: true } });
+                writeJson(res, 200, output);
+            }
+            catch (error) {
+                writeText(res, 500, error instanceof Error ? error.message : String(error));
+            }
+            return true;
+        }
+        if (pathname === "/gateway/clients/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.listClients", 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/clients/connected") {
+            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.listLiveClients", 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/known") {
+            if (req.method !== "POST") {
+                writeText(res, 405, "Method not allowed");
+                return true;
+            }
+            try {
+                const body = (await this.readJsonBody(req));
+                const filterClientUuid = typeof body.client_uuid === "string" && body.client_uuid.trim()
+                    ? body.client_uuid.trim()
+                    : null;
+                const ownerUserUuid = typeof body.owner_user_uuid === "string" && body.owner_user_uuid.trim()
+                    ? body.owner_user_uuid.trim()
+                    : null;
+                const telegramUserId = typeof body.telegram_user_id === "number"
+                    ? String(body.telegram_user_id)
+                    : typeof body.telegram_user_id === "string" && body.telegram_user_id.trim()
+                        ? body.telegram_user_id.trim()
+                        : null;
+                const connectedOnly = typeof body.connected_only === "boolean"
+                    ? body.connected_only
+                    : false;
+                const [liveResult, scopedClientsResult] = await Promise.all([
+                    this.callBroker("telegramMcp.gateway.listLiveConsoles", body, { meta: { internal_call: true } }),
+                    this.callBroker("telegramMcp.gateway.listClients", body, { meta: { internal_call: true } }),
+                ]);
+                const allowedClientUuids = ownerUserUuid || telegramUserId
+                    ? new Set((Array.isArray(scopedClientsResult.clients)
+                        ? scopedClientsResult.clients
+                        : [])
+                        .map((client) => typeof client.client_uuid === "string"
+                        ? client.client_uuid.trim()
+                        : "")
+                        .filter(Boolean))
+                    : null;
+                const sessions = (Array.isArray(liveResult.sessions) ? liveResult.sessions : [])
+                    .filter((session) => allowedClientUuids ? allowedClientUuids.has(session.client_uuid) : true)
+                    .filter((session) => filterClientUuid ? session.client_uuid === filterClientUuid : true)
+                    .filter((session) => (connectedOnly ? session.connected : true))
+                    .sort((left, right) => {
+                    const leftLabel = left.session_label?.trim() || left.local_session_id;
+                    const rightLabel = right.session_label?.trim() || right.local_session_id;
+                    return `${left.client_uuid}:${leftLabel}`.localeCompare(`${right.client_uuid}:${rightLabel}`);
+                });
+                writeJson(res, 200, {
+                    total: sessions.length,
+                    sessions,
+                });
+                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");
@@ -417,6 +994,11 @@ class GatewayHttpService {
             try {
                 const body = (await this.readJsonBody(req));
                 const result = await this.callBroker("telegramMcp.gateway.createProject", body, { meta: { internal_call: true } });
+                if (isBackendErrorLike(result)) {
+                    throw new Error(result.message
+                        ? `${result.message}${result.code ? ` [${result.code}]` : ""}`
+                        : `Gateway createProject failed [${result.code}]`);
+                }
                 writeJson(res, 200, result);
                 return true;
             }
@@ -435,6 +1017,11 @@ class GatewayHttpService {
             try {
                 const body = (await this.readJsonBody(req));
                 const result = await this.callBroker("telegramMcp.gateway.joinProject", body, { meta: { internal_call: true } });
+                if (isBackendErrorLike(result)) {
+                    throw new Error(result.message
+                        ? `${result.message}${result.code ? ` [${result.code}]` : ""}`
+                        : `Gateway joinProject failed [${result.code}]`);
+                }
                 if (Array.isArray(result.notify_client_uuids) &&
                     result.notify_client_uuids.length > 0 &&
                     typeof result.project_uuid === "string" &&
@@ -482,24 +1069,11 @@ class GatewayHttpService {
             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 } });
+                if (isBackendErrorLike(result)) {
+                    throw new Error(result.message
+                        ? `${result.message}${result.code ? ` [${result.code}]` : ""}`
+                        : `Gateway registerSession failed [${result.code}]`);
+                }
                 writeJson(res, 200, result);
                 return true;
             }