@deadragdoll/tellymcp 0.0.10 → 0.0.11

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

@@ -4,10 +4,12 @@ exports.TELEGRAM_MCP_GATEWAY_SOCKET_SERVICE_NAME = void 0;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
+const node_util_1 = require("node:util");
 const runtime_service_1 = require("./runtime.service");
 const standalone_http_service_1 = require("./standalone-http.service");
 const auth_1 = require("./src/app/webapp/auth");
-const tmux_1 = require("./src/app/webapp/tmux");
+const terminal_1 = require("./src/app/webapp/terminal");
+const client_1 = require("./src/shared/integrations/terminal/client");
 const gateway_loopback_1 = require("./gateway-loopback");
 const versionHandshake_1 = require("./src/shared/lib/version/versionHandshake");
 const wsLib = require("ws");
@@ -17,6 +19,39 @@ const CLIENT_RECONNECT_DELAY_MS = 3000;
 const LIVE_REQUEST_TIMEOUT_MS = 20000;
 const TOOLS_SYNC_CHECK_INTERVAL_MS = 15000;
 const WS_HEARTBEAT_INTERVAL_MS = 10000;
+const HTTP_SERVER_WAIT_TIMEOUT_MS = 15000;
+const HTTP_SERVER_WAIT_STEP_MS = 100;
+function requireTelegramBotToken(runtime, purpose) {
+    const token = runtime.config.telegram.botToken?.trim();
+    if (!token) {
+        throw new Error(`Telegram bot token is unavailable on this node; cannot ${purpose}.`);
+    }
+    return token;
+}
+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 = (0, node_path_1.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 normalizeWebSocketUrl(value, defaultPath) {
     const url = new URL(value);
     if (url.protocol === "https:") {
@@ -30,9 +65,9 @@ function normalizeWebSocketUrl(value, defaultPath) {
     }
     return url.toString();
 }
-function formatTmuxRelayError(error) {
-    if ((0, tmux_1.isTmuxUnavailableError)(error)) {
-        return "tmux is unavailable";
+function formatTerminalRelayError(error) {
+    if ((0, terminal_1.isTerminalUnavailableError)(error)) {
+        return "terminal runtime is unavailable";
     }
     return error instanceof Error ? error.message : String(error);
 }
@@ -44,6 +79,90 @@ function computeToolsHashForDir(workspaceDir) {
     const content = (0, node_fs_1.readFileSync)(toolsPath, "utf8");
     return (0, node_crypto_1.createHash)("sha256").update(content).digest("hex");
 }
+function computePackageToolsHash(currentDir) {
+    const packageRoot = (0, versionHandshake_1.getTellyMcpPackageRoot)(currentDir);
+    if (!packageRoot) {
+        return null;
+    }
+    return computeToolsHashForDir(packageRoot);
+}
+function isBackendErrorLike(value) {
+    return Boolean(value &&
+        typeof value === "object" &&
+        typeof value.statusCode === "number" &&
+        typeof value.code === "string" &&
+        (typeof value.name === "string" ||
+            typeof value.message === "string"));
+}
+function formatBackendErrorLike(value) {
+    const details = [];
+    if (typeof value.code === "string" && value.code.trim()) {
+        details.push(`code=${value.code.trim()}`);
+    }
+    if (typeof value.statusCode === "number") {
+        details.push(`statusCode=${value.statusCode}`);
+    }
+    if (value.data !== undefined) {
+        try {
+            details.push(`data=${JSON.stringify(value.data)}`);
+        }
+        catch {
+            details.push(`data=${String(value.data)}`);
+        }
+    }
+    const base = typeof value.message === "string" && value.message.trim()
+        ? value.message.trim()
+        : `${value.name ?? "BackendError"} (${value.code})`;
+    return details.length > 0 ? `${base}\n${details.join("\n")}` : base;
+}
+function formatRemoteActionError(error) {
+    if (isBackendErrorLike(error)) {
+        return formatBackendErrorLike(error);
+    }
+    if (!(error instanceof Error)) {
+        return (0, node_util_1.inspect)(error, { depth: 6, breakLength: 140 });
+    }
+    const details = [];
+    const named = error;
+    const ownProps = Object.fromEntries(Object.getOwnPropertyNames(error).map((key) => [
+        key,
+        error[key],
+    ]));
+    if (typeof named.code === "string" && named.code.trim()) {
+        details.push(`code=${named.code.trim()}`);
+    }
+    if (typeof named.type === "string" && named.type.trim()) {
+        details.push(`type=${named.type.trim()}`);
+    }
+    if (named.data !== undefined) {
+        try {
+            details.push(`data=${JSON.stringify(named.data)}`);
+        }
+        catch {
+            details.push(`data=${String(named.data)}`);
+        }
+    }
+    if (named.fields !== undefined) {
+        try {
+            details.push(`fields=${JSON.stringify(named.fields)}`);
+        }
+        catch {
+            details.push(`fields=${String(named.fields)}`);
+        }
+    }
+    if (Object.keys(ownProps).length > 0) {
+        try {
+            details.push(`props=${JSON.stringify(ownProps)}`);
+        }
+        catch {
+            details.push(`props=${(0, node_util_1.inspect)(ownProps, { depth: 6, breakLength: 140 })}`);
+        }
+    }
+    const baseMessage = error.stack ?? error.message;
+    return details.length > 0
+        ? `${baseMessage}\n${details.join("\n")}`
+        : baseMessage;
+}
 function normalizeGatewayBaseUrl(value) {
     const url = new URL(value);
     url.pathname = url.pathname.replace(/\/+$/u, "");
@@ -52,6 +171,34 @@ function normalizeGatewayBaseUrl(value) {
     }
     return url;
 }
+function listConnectedSocketsForClient(carrier, clientUuid) {
+    const sockets = [];
+    for (const [socket, hello] of carrier.connectedClients?.entries() ?? []) {
+        if (hello?.client_uuid !== clientUuid) {
+            continue;
+        }
+        if (socket?.readyState !== undefined && socket.readyState !== 1) {
+            continue;
+        }
+        sockets.push(socket);
+    }
+    return sockets;
+}
+function findConnectedSocketForSession(carrier, params) {
+    for (const [socket, hello] of carrier.connectedClients?.entries() ?? []) {
+        if (hello?.client_uuid !== params.clientUuid ||
+            (socket?.readyState !== undefined && socket.readyState !== 1)) {
+            continue;
+        }
+        const hasSession = Array.isArray(hello.session_tools)
+            ? hello.session_tools.some((item) => item.local_session_id === params.localSessionId)
+            : false;
+        if (hasSession) {
+            return socket;
+        }
+    }
+    return null;
+}
 const TelegramMcpGatewaySocketService = {
     name: exports.TELEGRAM_MCP_GATEWAY_SOCKET_SERVICE_NAME,
     dependencies: [
@@ -59,13 +206,29 @@ const TelegramMcpGatewaySocketService = {
         standalone_http_service_1.TELEGRAM_MCP_STANDALONE_HTTP_SERVICE_NAME,
     ],
     actions: {
+        refreshClientHello: {
+            async handler() {
+                if (!this.wsClient || this.wsClient.readyState !== 1) {
+                    return { sent: false };
+                }
+                await this.sendClientHello?.(this.wsClient);
+                return { sent: true };
+            },
+        },
         requestLiveRelay: {
             params: {
                 clientUuid: "string",
                 localSessionId: "string",
                 requestType: {
                     type: "enum",
-                    values: ["bootstrap", "bootstrap_validate", "view", "action"],
+                    values: [
+                        "bootstrap",
+                        "bootstrap_validate",
+                        "view",
+                        "action",
+                        "stream_subscribe",
+                        "stream_unsubscribe",
+                    ],
                 },
                 payload: { type: "object", optional: true },
             },
@@ -78,6 +241,32 @@ const TelegramMcpGatewaySocketService = {
                 });
             },
         },
+        requestClientAction: {
+            params: {
+                clientUuid: "string",
+                actionName: "string",
+                params: { type: "object", optional: true },
+            },
+            async handler(ctx) {
+                return await this.requestClientAction?.({
+                    clientUuid: String(ctx.params.clientUuid),
+                    actionName: String(ctx.params.actionName),
+                    payload: ctx.params.params && typeof ctx.params.params === "object"
+                        ? ctx.params.params
+                        : {},
+                });
+            },
+        },
+        resolveConnectedSessionTarget: {
+            params: {
+                sessionId: "string",
+            },
+            async handler(ctx) {
+                return await this.resolveConnectedSessionTarget?.({
+                    sessionId: String(ctx.params.sessionId),
+                });
+            },
+        },
         notifyProjectMemberJoined: {
             params: {
                 clientUuids: { type: "array", items: "string" },
@@ -153,6 +342,45 @@ const TelegramMcpGatewaySocketService = {
                 return await this.notifyDeliveryStatus?.(ctx.params);
             },
         },
+        notifyTransportReply: {
+            params: {
+                client_uuid: "string",
+                request_id: "string",
+                answer: "string",
+                received_at: "string",
+            },
+            async handler(ctx) {
+                return {
+                    delivered: await this.notifyTransportReply?.({
+                        clientUuid: String(ctx.params.client_uuid),
+                        payload: {
+                            request_id: String(ctx.params.request_id),
+                            answer: String(ctx.params.answer),
+                            received_at: String(ctx.params.received_at),
+                        },
+                    }),
+                };
+            },
+        },
+        sendDirectPartnerNote: {
+            params: {
+                clientUuid: "string",
+                localSessionId: "string",
+                sourceActorLabel: { type: "string", optional: true },
+                targetClientUuid: "string",
+                targetLocalSessionId: "string",
+                kind: "string",
+                summary: "string",
+                message: "string",
+                expectedReply: { type: "string", optional: true },
+                requiresReply: { type: "boolean", optional: true },
+                inReplyTo: { type: "string", optional: true },
+                artifactRefs: { type: "array", optional: true, items: "object" },
+            },
+            async handler(ctx) {
+                return await this.sendDirectPartnerNote?.(ctx.params);
+            },
+        },
     },
     created() {
         this.runtimeService = null;
@@ -174,6 +402,9 @@ const TelegramMcpGatewaySocketService = {
         this.connectedClientsByUuid = new Map();
         this.connectedClientToolsAlerts = new Map();
         this.pendingLiveRequests = new Map();
+        this.pendingActionRequests = new Map();
+        this.liveStreamHandlers = new Map();
+        this.localLiveStreamSubscriptions = new Map();
     },
     methods: {
         getRuntimeOrThrow() {
@@ -194,21 +425,43 @@ const TelegramMcpGatewaySocketService = {
             this.standaloneHttpService = standaloneHttpService;
             return standaloneHttpService.httpServer;
         },
+        async waitForHttpServer() {
+            const startedAt = Date.now();
+            while (Date.now() - startedAt < HTTP_SERVER_WAIT_TIMEOUT_MS) {
+                const standaloneHttpService = this.standaloneHttpService ??
+                    this.broker.getLocalService(standalone_http_service_1.TELEGRAM_MCP_STANDALONE_HTTP_SERVICE_NAME);
+                if (standaloneHttpService?.httpServer) {
+                    this.standaloneHttpService = standaloneHttpService;
+                    return standaloneHttpService.httpServer;
+                }
+                await new Promise((resolve) => setTimeout(resolve, HTTP_SERVER_WAIT_STEP_MS));
+            }
+            throw new Error(`Local Moleculer service '${standalone_http_service_1.TELEGRAM_MCP_STANDALONE_HTTP_SERVICE_NAME}' HTTP server is unavailable`);
+        },
         async collectSessionTools() {
             const runtime = this.getRuntimeOrThrow();
-            const sessions = await runtime.sessionStore.listSessions();
-            const boundSessions = (await Promise.all(sessions.map(async (session) => (await runtime.bindingStore.getBinding(session.sessionId))
-                ? session
-                : null))).filter((session) => Boolean(session));
-            const sessionTools = boundSessions
+            const sessionsForHello = runtime.config.distributed.mode === "client"
+                ? await (async () => {
+                    const resolved = runtime.projectIdentityResolver.resolveSessionDefaults({
+                        cwd: process.cwd(),
+                    });
+                    const session = await runtime.sessionStore.getSession(resolved.sessionId);
+                    if (!session) {
+                        throw new Error(`Current console '${resolved.sessionId}' is missing from session store during gateway hello.`);
+                    }
+                    return [session];
+                })()
+                : (await Promise.all((await runtime.sessionStore.listSessions()).map(async (session) => (await runtime.bindingStore.getBinding(session.sessionId))
+                    ? session
+                    : null))).filter((session) => Boolean(session));
+            const sessionTools = sessionsForHello
                 .map((session) => {
-                const toolsHash = session.cwd
-                    ? computeToolsHashForDir(session.cwd)
-                    : null;
+                const effectiveHash = session.lastSeenToolsHash?.trim() ?? null;
                 return {
                     local_session_id: session.sessionId,
                     ...(session.label ? { session_label: session.label } : {}),
-                    ...(toolsHash ? { tools_hash: toolsHash } : {}),
+                    ...(effectiveHash ? { tools_hash: effectiveHash } : {}),
+                    ...(session.cwd ? { cwd: session.cwd } : {}),
                 };
             })
                 .sort((left, right) => left.local_session_id.localeCompare(right.local_session_id));
@@ -218,7 +471,7 @@ const TelegramMcpGatewaySocketService = {
             };
         },
         getGatewayToolsHash() {
-            return computeToolsHashForDir(process.cwd());
+            return computePackageToolsHash(__dirname);
         },
         getLocalVersionInfo() {
             return {
@@ -227,6 +480,147 @@ const TelegramMcpGatewaySocketService = {
                 capabilities: [...versionHandshake_1.TELLYMCP_CAPABILITIES],
             };
         },
+        findConnectedSessionTool(params) {
+            for (const hello of this.connectedClients?.values() ?? []) {
+                if (hello?.client_uuid !== params.clientUuid) {
+                    continue;
+                }
+                const sessionTool = Array.isArray(hello.session_tools)
+                    ? hello.session_tools.find((item) => item.local_session_id === params.localSessionId)
+                    : null;
+                if (!sessionTool) {
+                    continue;
+                }
+                return {
+                    ...(sessionTool.session_label
+                        ? { session_label: sessionTool.session_label }
+                        : {}),
+                    ...(hello.node_id ? { node_id: hello.node_id } : {}),
+                    ...(hello.package_version
+                        ? { package_version: hello.package_version }
+                        : {}),
+                };
+            }
+            return null;
+        },
+        async resolveConnectedSessionTarget(params) {
+            const sessionId = params.sessionId.trim();
+            if (!sessionId || sessionId.startsWith("relay~")) {
+                return null;
+            }
+            const resolved = await this.broker.call("telegramMcp.gateway.resolveLiveConsole", { sessionId }, { meta: { internal_call: true } });
+            if (!resolved) {
+                return null;
+            }
+            return {
+                client_uuid: resolved.client_uuid,
+                local_session_id: resolved.local_session_id,
+                ...(resolved.session_label ? { session_label: resolved.session_label } : {}),
+            };
+        },
+        async sendDirectPartnerNote(params) {
+            const sourceInfo = this.findConnectedSessionTool?.({
+                clientUuid: params.clientUuid,
+                localSessionId: params.localSessionId,
+            });
+            const targetInfo = this.findConnectedSessionTool?.({
+                clientUuid: params.targetClientUuid,
+                localSessionId: params.targetLocalSessionId,
+            });
+            const targetIsLocal = await this.isLocalGatewayClientUuid?.(params.targetClientUuid);
+            if (!targetInfo && !targetIsLocal) {
+                throw new Error(`Target gateway session '${params.targetClientUuid}/${params.targetLocalSessionId}' is not connected.`);
+            }
+            const requiresReply = typeof params.requiresReply === "boolean"
+                ? params.requiresReply
+                : params.kind === "question" || params.kind === "request";
+            const shareId = (0, node_crypto_1.randomUUID)();
+            const messageUuid = (0, node_crypto_1.randomUUID)();
+            const deliveryUuid = (0, node_crypto_1.randomUUID)();
+            const createdAt = new Date().toISOString();
+            const usedArtifactNames = new Set();
+            const artifacts = (Array.isArray(params.artifactRefs)
+                ? params.artifactRefs
+                : []).map((artifact) => {
+                const originalName = typeof artifact.original_name === "string" && artifact.original_name.trim()
+                    ? artifact.original_name.trim()
+                    : typeof artifact.relative_path === "string" &&
+                        artifact.relative_path.trim()
+                        ? artifact.relative_path.trim()
+                        : typeof artifact.file_path === "string" && artifact.file_path.trim()
+                            ? artifact.file_path.trim()
+                            : "file";
+                return {
+                    artifact_uuid: (0, node_crypto_1.randomUUID)(),
+                    original_name: (0, node_path_1.basename)(originalName),
+                    ...(typeof artifact.mime_type === "string" && artifact.mime_type.trim()
+                        ? { mime_type: artifact.mime_type.trim() }
+                        : {}),
+                    ...(typeof artifact.size_bytes === "number"
+                        ? { size_bytes: artifact.size_bytes }
+                        : {}),
+                    ...(typeof artifact.storage_ref === "string" && artifact.storage_ref.trim()
+                        ? { storage_ref: artifact.storage_ref.trim() }
+                        : {}),
+                    relative_path: allocateArtifactRelativePath(shareId, (0, node_path_1.basename)(originalName), usedArtifactNames),
+                    ...(typeof artifact.content_base64 === "string" &&
+                        artifact.content_base64.trim()
+                        ? { content_base64: artifact.content_base64.trim() }
+                        : {}),
+                };
+            });
+            const delivery = {
+                delivery_uuid: deliveryUuid,
+                message_uuid: messageUuid,
+                share_id: shareId,
+                route_mode: "direct",
+                source_actor_label: params.sourceActorLabel?.trim() ||
+                    sourceInfo?.session_label ||
+                    params.localSessionId,
+                source_client_uuid: params.clientUuid,
+                target_client_uuid: params.targetClientUuid,
+                kind: params.kind,
+                summary: params.summary,
+                message: params.message,
+                ...(params.expectedReply ? { expected_reply: params.expectedReply } : {}),
+                requires_reply: requiresReply,
+                ...(params.inReplyTo ? { in_reply_to: params.inReplyTo } : {}),
+                source_session_uuid: `${params.clientUuid}:${params.localSessionId}`,
+                source_session_label: params.sourceActorLabel?.trim() ||
+                    sourceInfo?.session_label ||
+                    params.localSessionId,
+                source_local_session_id: params.localSessionId,
+                target_session_uuid: `${params.targetClientUuid}:${params.targetLocalSessionId}`,
+                target_local_session_id: params.targetLocalSessionId,
+                target_session_label: targetInfo?.session_label ?? params.targetLocalSessionId,
+                created_at: createdAt,
+                note_relative_path: `shares/${shareId}.md`,
+                artifacts,
+            };
+            const delivered = await this.notifyDeliveryQueued?.({
+                clientUuid: params.targetClientUuid,
+                delivery,
+            });
+            if (!delivered) {
+                throw new Error(`Target gateway session '${params.targetClientUuid}/${params.targetLocalSessionId}' is not connected.`);
+            }
+            return {
+                session_id: params.localSessionId,
+                partner_session_id: `${params.targetClientUuid}:${params.targetLocalSessionId}`,
+                target_client_uuid: params.targetClientUuid,
+                target_local_session_id: params.targetLocalSessionId,
+                target_session_label: targetInfo?.session_label ?? params.targetLocalSessionId,
+                kind: params.kind,
+                share_id: shareId,
+                delivery_status: "delivered",
+                note_path: `gateway://shares/${shareId}.md`,
+                xchange_record_id: shareId,
+                copied_artifacts: artifacts.map((artifact) => artifact.original_name),
+                inbox_message_id: deliveryUuid,
+                requires_reply: requiresReply,
+                delivery_uuid: deliveryUuid,
+            };
+        },
         async fetchGatewayToolsHashForClient() {
             const runtime = this.getRuntimeOrThrow();
             if (runtime.config.distributed.mode === "gateway" ||
@@ -276,9 +670,7 @@ const TelegramMcpGatewaySocketService = {
                 : null))).filter((session) => Boolean(session));
             let delivered = 0;
             for (const session of boundSessions) {
-                const localHash = session.cwd
-                    ? computeToolsHashForDir(session.cwd)
-                    : null;
+                const localHash = session.lastSeenToolsHash?.trim() ?? null;
                 if (localHash === gatewayToolsHash) {
                     continue;
                 }
@@ -292,7 +684,7 @@ const TelegramMcpGatewaySocketService = {
                     ...(localHash ? { client_tools_hash: localHash } : {}),
                     gateway_tools_hash: gatewayToolsHash,
                     reason: localHash ? "outdated" : "missing",
-                    instruction: "Call refresh_tools_markdown for this session, then re-read the local TOOLS.md and apply it before continuing.",
+                    instruction: "Call refresh_tools_markdown with the current known_hash for this session. If changed=true, read and apply the returned content before continuing.",
                 });
                 delivered += 1;
             }
@@ -333,7 +725,7 @@ const TelegramMcpGatewaySocketService = {
                         ...(clientToolsHash ? { client_tools_hash: clientToolsHash } : {}),
                         gateway_tools_hash: gatewayToolsHash,
                         reason: clientToolsHash ? "outdated" : "missing",
-                        instruction: "Call refresh_tools_markdown for this session, then re-read the local TOOLS.md and apply it before continuing.",
+                        instruction: "Call refresh_tools_markdown with the current known_hash for this session. If changed=true, read and apply the returned content before continuing.",
                     },
                 }));
                 alerted.set(sessionTool.local_session_id, gatewayToolsHash);
@@ -361,9 +753,21 @@ const TelegramMcpGatewaySocketService = {
                 connection_id: this.wsConnectionId || (0, node_crypto_1.randomUUID)(),
                 role: "client",
                 ...(clientUuid ? { client_uuid: clientUuid } : {}),
+                ...(runtime.config.distributed.gatewayUserUuid
+                    ? { gateway_user_uuid: runtime.config.distributed.gatewayUserUuid }
+                    : {}),
+                ...(runtime.config.project.name
+                    ? { client_label: runtime.config.project.name }
+                    : {}),
+                ...(process.env.USER?.trim()
+                    ? { system_username: process.env.USER.trim() }
+                    : process.env.LOGNAME?.trim()
+                        ? { system_username: process.env.LOGNAME.trim() }
+                        : {}),
                 ...(runtime.config.project.name
                     ? { project_name: runtime.config.project.name }
                     : {}),
+                ...(this.broker.namespace ? { namespace: this.broker.namespace } : {}),
                 ...(this.broker.nodeID ? { node_id: this.broker.nodeID } : {}),
                 package_version: versionInfo.packageVersion,
                 protocol_version: versionInfo.protocolVersion,
@@ -462,7 +866,7 @@ const TelegramMcpGatewaySocketService = {
                     if (!initDataRaw || !initDataUnsafe) {
                         throw new Error("initDataRaw and initDataUnsafe are required");
                     }
-                    const validated = (0, auth_1.validateTelegramWebAppInitData)(initDataRaw, initDataUnsafe, runtime.config.telegram.botToken, runtime.config.webapp.initDataTtlSeconds);
+                    const validated = (0, auth_1.validateTelegramWebAppInitData)(initDataRaw, initDataUnsafe, requireTelegramBotToken(runtime, "validate Telegram WebApp relay bootstrap"), runtime.config.webapp.initDataTtlSeconds);
                     const launchRecord = runtime.webAppLaunchRegistry.getByUserId(validated.user.id);
                     if (!launchRecord) {
                         throw new Error("No pending Telegram WebApp launch was found");
@@ -492,6 +896,7 @@ const TelegramMcpGatewaySocketService = {
                             payload.telegramUserId.trim()
                             ? Number(payload.telegramUserId)
                             : null;
+                    let launchRecord = null;
                     let telegramUserId = trustedTelegramUserId;
                     if (telegramUserId !== null &&
                         (!Number.isFinite(telegramUserId) || telegramUserId <= 0)) {
@@ -505,8 +910,9 @@ const TelegramMcpGatewaySocketService = {
                         if (!initDataRaw || !initDataUnsafe) {
                             throw new Error("initDataRaw and initDataUnsafe are required");
                         }
-                        const validated = (0, auth_1.validateTelegramWebAppInitData)(initDataRaw, initDataUnsafe, runtime.config.telegram.botToken, runtime.config.webapp.initDataTtlSeconds);
+                        const validated = (0, auth_1.validateTelegramWebAppInitData)(initDataRaw, initDataUnsafe, requireTelegramBotToken(runtime, "validate Telegram WebApp relay bootstrap"), runtime.config.webapp.initDataTtlSeconds);
                         telegramUserId = validated.user.id;
+                        launchRecord = runtime.webAppLaunchRegistry.getByUserId(validated.user.id);
                     }
                     const sessionId = request.local_session_id.trim();
                     if (!sessionId) {
@@ -518,6 +924,15 @@ const TelegramMcpGatewaySocketService = {
                         throw new Error("This Telegram user is not bound to the requested session.");
                     }
                     const session = await runtime.sessionStore.getSession(sessionId);
+                    if (trustedTelegramUserId === null && telegramUserId !== null) {
+                        runtime.webAppLaunchRegistry.deleteByUserId(telegramUserId);
+                    }
+                    if (launchRecord?.telegramChatId !== undefined &&
+                        launchRecord?.telegramMessageId !== undefined) {
+                        void runtime.telegramTransport
+                            .deleteMessage(launchRecord.telegramChatId, launchRecord.telegramMessageId)
+                            .catch(() => undefined);
+                    }
                     return {
                         type: "live_response",
                         request_id: request.request_id,
@@ -525,7 +940,7 @@ const TelegramMcpGatewaySocketService = {
                         result: {
                             session_id: sessionId,
                             session_label: session?.label ?? null,
-                            tmux_target: Boolean(session?.tmuxTarget),
+                            terminal_target: Boolean(session?.terminalTarget),
                             poll_interval_ms: runtime.config.webapp.pollIntervalMs,
                             telegram_user_id: telegramUserId,
                         },
@@ -534,10 +949,12 @@ const TelegramMcpGatewaySocketService = {
                 if (request.request_type === "view") {
                     const sessionId = request.local_session_id.trim();
                     const session = await runtime.sessionStore.getSession(sessionId);
-                    if (!session?.tmuxTarget) {
-                        throw new Error("tmux target is not configured for this session");
+                    if (!session?.terminalTarget) {
+                        throw new Error("terminal target is not configured for this session");
                     }
-                    const content = await (0, tmux_1.captureVisibleTmuxPane)(runtime.config.tmux, session.tmuxTarget, runtime.config.tmux.captureLines, runtime.config.webapp.visibleScreens);
+                    const terminalSize = await (0, terminal_1.getTerminalWindowSize)(runtime.config.terminal, session.terminalTarget);
+                    const content = await (0, terminal_1.captureVisibleTerminal)(runtime.config.terminal, session.terminalTarget, runtime.config.terminal.captureLines, runtime.config.webapp.visibleScreens);
+                    const ansi = await (0, terminal_1.captureVisibleTerminalAnsi)(runtime.config.terminal, session.terminalTarget, runtime.config.terminal.captureLines, runtime.config.webapp.visibleScreens);
                     return {
                         type: "live_response",
                         request_id: request.request_id,
@@ -547,6 +964,8 @@ const TelegramMcpGatewaySocketService = {
                             session_label: session.label ?? null,
                             captured_at: new Date().toISOString(),
                             content,
+                            ansi,
+                            ...(terminalSize ? terminalSize : {}),
                         },
                     };
                 }
@@ -565,14 +984,14 @@ const TelegramMcpGatewaySocketService = {
                     }
                     const sessionId = request.local_session_id.trim();
                     const session = await runtime.sessionStore.getSession(sessionId);
-                    if (!session?.tmuxTarget) {
-                        throw new Error("tmux target is not configured for this session");
+                    if (!session?.terminalTarget) {
+                        throw new Error("terminal target is not configured for this session");
                     }
                     if (action === "text") {
-                        await (0, tmux_1.sendTmuxLiteralText)(runtime.config.tmux, session.tmuxTarget, text);
+                        await (0, terminal_1.sendTerminalLiteralText)(runtime.config.terminal, session.terminalTarget, text);
                     }
                     else {
-                        await (0, tmux_1.sendAllowedTmuxAction)(runtime.config.tmux, session.tmuxTarget, action);
+                        await (0, terminal_1.sendAllowedTerminalAction)(runtime.config.terminal, session.terminalTarget, action);
                     }
                     return {
                         type: "live_response",
@@ -583,6 +1002,89 @@ const TelegramMcpGatewaySocketService = {
                         },
                     };
                 }
+                if (request.request_type === "stream_subscribe") {
+                    const streamId = typeof request.payload?.stream_id === "string"
+                        ? request.payload.stream_id.trim()
+                        : "";
+                    if (!streamId) {
+                        throw new Error("stream_id is required");
+                    }
+                    const sessionId = request.local_session_id.trim();
+                    const session = await runtime.sessionStore.getSession(sessionId);
+                    if (!session?.terminalTarget) {
+                        throw new Error("terminal target is not configured for this session");
+                    }
+                    if (!(0, client_1.isStreamableTerminalTarget)(session.terminalTarget)) {
+                        throw new Error("Live stream is supported only for PTY-backed terminals");
+                    }
+                    this.localLiveStreamSubscriptions?.get(streamId)?.();
+                    this.localLiveStreamSubscriptions?.delete(streamId);
+                    const terminalSize = await (0, terminal_1.getTerminalWindowSize)(runtime.config.terminal, session.terminalTarget);
+                    const content = await (0, terminal_1.captureVisibleTerminal)(runtime.config.terminal, session.terminalTarget, runtime.config.terminal.captureLines, runtime.config.webapp.visibleScreens);
+                    const ansi = await (0, terminal_1.captureVisibleTerminalAnsi)(runtime.config.terminal, session.terminalTarget, runtime.config.terminal.captureLines, runtime.config.webapp.visibleScreens);
+                    this.wsClient?.send(JSON.stringify({
+                        type: "live_stream_event",
+                        stream_id: streamId,
+                        event: "snapshot",
+                        payload: {
+                            session_id: session.sessionId,
+                            session_label: session.label ?? null,
+                            captured_at: new Date().toISOString(),
+                            content,
+                            ansi,
+                            ...(terminalSize ? terminalSize : {}),
+                        },
+                    }));
+                    const unsubscribe = (0, client_1.subscribeForegroundTerminal)(session.terminalTarget, {
+                        onData: (data) => {
+                            this.wsClient?.send(JSON.stringify({
+                                type: "live_stream_event",
+                                stream_id: streamId,
+                                event: "data",
+                                payload: { data },
+                            }));
+                        },
+                        onExit: (info) => {
+                            this.wsClient?.send(JSON.stringify({
+                                type: "live_stream_event",
+                                stream_id: streamId,
+                                event: "exit",
+                                payload: {
+                                    exitCode: typeof info.exitCode === "number" ? info.exitCode : null,
+                                    signal: typeof info.signal === "number" ? info.signal : null,
+                                },
+                            }));
+                        },
+                    });
+                    this.localLiveStreamSubscriptions?.set(streamId, unsubscribe);
+                    return {
+                        type: "live_response",
+                        request_id: request.request_id,
+                        ok: true,
+                        result: {
+                            ok: true,
+                            stream_id: streamId,
+                        },
+                    };
+                }
+                if (request.request_type === "stream_unsubscribe") {
+                    const streamId = typeof request.payload?.stream_id === "string"
+                        ? request.payload.stream_id.trim()
+                        : "";
+                    if (streamId) {
+                        this.localLiveStreamSubscriptions?.get(streamId)?.();
+                        this.localLiveStreamSubscriptions?.delete(streamId);
+                    }
+                    return {
+                        type: "live_response",
+                        request_id: request.request_id,
+                        ok: true,
+                        result: {
+                            ok: true,
+                            ...(streamId ? { stream_id: streamId } : {}),
+                        },
+                    };
+                }
                 throw new Error(`Unsupported live request type '${request.request_type}'`);
             }
             catch (error) {
@@ -590,7 +1092,7 @@ const TelegramMcpGatewaySocketService = {
                     type: "live_response",
                     request_id: request.request_id,
                     ok: false,
-                    error: formatTmuxRelayError(error),
+                    error: formatTerminalRelayError(error),
                 };
             }
         },
@@ -607,6 +1109,17 @@ const TelegramMcpGatewaySocketService = {
                     ...(typeof parsed.client_uuid === "string" && parsed.client_uuid.trim()
                         ? { client_uuid: parsed.client_uuid.trim() }
                         : {}),
+                    ...(typeof parsed.client_label === "string" && parsed.client_label.trim()
+                        ? { client_label: parsed.client_label.trim() }
+                        : {}),
+                    ...(typeof parsed.gateway_user_uuid === "string" &&
+                        parsed.gateway_user_uuid.trim()
+                        ? { gateway_user_uuid: parsed.gateway_user_uuid.trim() }
+                        : {}),
+                    ...(typeof parsed.system_username === "string" &&
+                        parsed.system_username.trim()
+                        ? { system_username: parsed.system_username.trim() }
+                        : {}),
                     ...(typeof parsed.project_name === "string" && parsed.project_name.trim()
                         ? { project_name: parsed.project_name.trim() }
                         : {}),
@@ -654,6 +1167,12 @@ const TelegramMcpGatewaySocketService = {
                                             tools_hash: item.tools_hash.trim(),
                                         }
                                         : {}),
+                                    ...(typeof item.cwd === "string" &&
+                                        item.cwd.trim()
+                                        ? {
+                                            cwd: item.cwd.trim(),
+                                        }
+                                        : {}),
                                 }
                                 : null)
                                 .filter((item) => Boolean(item?.local_session_id)),
@@ -661,6 +1180,12 @@ const TelegramMcpGatewaySocketService = {
                         : {}),
                 };
                 const previous = this.connectedClients?.get(socket);
+                const previousByClientUuid = hello.client_uuid
+                    ? this.connectedClientsByUuid?.get(hello.client_uuid)
+                    : null;
+                const previousHelloForClient = previousByClientUuid && previousByClientUuid !== socket
+                    ? this.connectedClients?.get(previousByClientUuid)
+                    : previous;
                 if (previous?.client_uuid) {
                     this.connectedClientsByUuid?.delete(previous.client_uuid);
                 }
@@ -669,6 +1194,39 @@ const TelegramMcpGatewaySocketService = {
                     this.connectedClientsByUuid?.set(hello.client_uuid, socket);
                 }
                 runtime.logger.info("Gateway WS hello received", hello);
+                if (hello.client_uuid) {
+                    await this.broker.call("telegramMcp.gateway.syncLiveConsoles", {
+                        client_uuid: hello.client_uuid,
+                        connection_id: hello.connection_id,
+                        ...(hello.gateway_user_uuid
+                            ? { gateway_user_uuid: hello.gateway_user_uuid }
+                            : {}),
+                        ...(hello.client_label ? { client_label: hello.client_label } : {}),
+                        ...(hello.system_username
+                            ? { system_username: hello.system_username }
+                            : {}),
+                        ...(hello.namespace ? { namespace: hello.namespace } : {}),
+                        ...(hello.node_id ? { node_id: hello.node_id } : {}),
+                        ...(hello.package_version
+                            ? { package_version: hello.package_version }
+                            : {}),
+                        ...(hello.protocol_version
+                            ? { protocol_version: hello.protocol_version }
+                            : {}),
+                        session_tools: Array.isArray(hello.session_tools)
+                            ? hello.session_tools.map((sessionTool) => ({
+                                local_session_id: sessionTool.local_session_id,
+                                ...(sessionTool.session_label
+                                    ? { session_label: sessionTool.session_label }
+                                    : {}),
+                                ...(sessionTool.tools_hash
+                                    ? { tools_hash: sessionTool.tools_hash }
+                                    : {}),
+                                ...(sessionTool.cwd ? { cwd: sessionTool.cwd } : {}),
+                            }))
+                            : [],
+                    }, { meta: { internal_call: true } });
+                }
                 const localVersionInfo = this.getLocalVersionInfo?.() ?? {
                     packageVersion: "0.0.0-unknown",
                     protocolVersion: versionHandshake_1.TELLYMCP_PROTOCOL_VERSION,
@@ -718,6 +1276,34 @@ const TelegramMcpGatewaySocketService = {
                     }, 50);
                     return;
                 }
+                if (hello.client_uuid) {
+                    const previousSessionIds = new Set(Array.isArray(previousHelloForClient?.session_tools)
+                        ? previousHelloForClient.session_tools
+                            .map((session) => session.local_session_id)
+                            .filter((sessionId) => typeof sessionId === "string" && sessionId.trim().length > 0)
+                        : []);
+                    const currentSessions = Array.isArray(hello.session_tools)
+                        ? hello.session_tools.filter((session) => typeof session?.local_session_id === "string" &&
+                            session.local_session_id.trim().length > 0)
+                        : [];
+                    const newSessions = currentSessions.filter((session) => !previousSessionIds.has(session.local_session_id));
+                    const isNewClient = !previousHelloForClient;
+                    if (isNewClient || newSessions.length > 0) {
+                        await runtime.telegramTransport.sendAdminGatewayRegistrationNotifications({
+                            clientUuid: hello.client_uuid,
+                            ...(hello.gateway_user_uuid
+                                ? { gatewayUserUuid: hello.gateway_user_uuid }
+                                : {}),
+                            ...(hello.node_id ? { nodeId: hello.node_id } : {}),
+                            ...(hello.package_version
+                                ? { packageVersion: hello.package_version }
+                                : {}),
+                            totalSessions: currentSessions.length,
+                            isNewClient,
+                            newSessions,
+                        });
+                    }
+                }
                 await this.notifyToolsMismatchForSocket?.(socket, hello);
                 if (hello.client_uuid) {
                     const queued = await this.broker.call("telegramMcp.gateway.pollDeliveries", {
@@ -778,6 +1364,51 @@ const TelegramMcpGatewaySocketService = {
                 }
                 return;
             }
+            if (parsed.type === "live_stream_event") {
+                const streamId = typeof parsed.stream_id === "string" ? parsed.stream_id.trim() : "";
+                if (!streamId) {
+                    return;
+                }
+                const handler = this.liveStreamHandlers?.get(streamId);
+                if (!handler) {
+                    return;
+                }
+                handler.onEvent(parsed);
+                return;
+            }
+            if (parsed.type === "action_response") {
+                const requestId = typeof parsed.request_id === "string" ? parsed.request_id.trim() : "";
+                if (!requestId) {
+                    return;
+                }
+                const pending = this.pendingActionRequests?.get(requestId);
+                if (!pending) {
+                    return;
+                }
+                clearTimeout(pending.timeout);
+                this.pendingActionRequests?.delete(requestId);
+                runtime.logger.info("Gateway WS action response received", {
+                    requestId,
+                    clientUuid: pending.clientUuid,
+                    ok: parsed.ok === true,
+                    ...(parsed.ok === true
+                        ? {}
+                        : {
+                            error: typeof parsed.error === "string" && parsed.error.trim()
+                                ? parsed.error
+                                : "Remote action request failed",
+                        }),
+                });
+                if (parsed.ok === true) {
+                    pending.resolve(parsed.result);
+                }
+                else {
+                    pending.reject(new Error(typeof parsed.error === "string" && parsed.error.trim()
+                        ? parsed.error
+                        : "Remote action request failed"));
+                }
+                return;
+            }
             if (parsed.type === "delivery_ack" || parsed.type === "delivery_fail") {
                 const hello = this.connectedClients?.get(socket);
                 const clientUuid = hello?.client_uuid?.trim();
@@ -903,6 +1534,58 @@ const TelegramMcpGatewaySocketService = {
                 await runtime.telegramTransport.handleToolsUpdatedEvent(parsed.payload);
                 return;
             }
+            if (parsed.type === "action_request") {
+                const requestId = typeof parsed.request_id === "string" ? parsed.request_id.trim() : "";
+                const actionName = typeof parsed.action_name === "string" ? parsed.action_name.trim() : "";
+                if (!requestId || !actionName) {
+                    return;
+                }
+                runtime.logger.info("Gateway WS action request received on client", {
+                    requestId,
+                    actionName,
+                    sessionId: typeof parsed.payload?.session_id === "string"
+                        ? parsed.payload.session_id
+                        : null,
+                });
+                try {
+                    const result = await this.broker.call(actionName, parsed.payload ?? {}, { meta: { internal_call: true } });
+                    if (isBackendErrorLike(result)) {
+                        this.wsClient?.send(JSON.stringify({
+                            type: "action_response",
+                            request_id: requestId,
+                            ok: false,
+                            error: formatBackendErrorLike(result),
+                        }));
+                        return;
+                    }
+                    runtime.logger.info("Gateway WS action request completed on client", {
+                        requestId,
+                        actionName,
+                    });
+                    this.wsClient?.send(JSON.stringify({
+                        type: "action_response",
+                        request_id: requestId,
+                        ok: true,
+                        result,
+                    }));
+                }
+                catch (error) {
+                    const formattedError = formatRemoteActionError(error);
+                    runtime.logger.error("Gateway WS action request failed on client", {
+                        requestId,
+                        actionName,
+                        error: formattedError,
+                        payload: parsed.payload ?? {},
+                    });
+                    this.wsClient?.send(JSON.stringify({
+                        type: "action_response",
+                        request_id: requestId,
+                        ok: false,
+                        error: formattedError,
+                    }));
+                }
+                return;
+            }
             if (parsed.type === "project_event") {
                 if (parsed.event === "member_joined" &&
                     parsed.payload &&
@@ -937,6 +1620,12 @@ const TelegramMcpGatewaySocketService = {
                     return;
                 }
             }
+            if (parsed.type === "transport_event" && parsed.payload) {
+                if (parsed.event === "request_reply") {
+                    await runtime.telegramTransport.handleGatewayTransportReplyEvent(parsed.payload);
+                    return;
+                }
+            }
             if (parsed.type === "delivery_event") {
                 const delivery = parsed.payload;
                 if (!delivery) {
@@ -979,9 +1668,12 @@ const TelegramMcpGatewaySocketService = {
         },
         async requestLiveRelay(params) {
             const runtime = this.getRuntimeOrThrow();
-            const socket = this.connectedClientsByUuid?.get(params.clientUuid);
+            const socket = findConnectedSocketForSession(this, {
+                clientUuid: params.clientUuid,
+                localSessionId: params.localSessionId,
+            });
             if (!socket || socket.readyState !== 1) {
-                throw new Error(`Gateway WS client '${params.clientUuid}' is not connected`);
+                throw new Error(`Gateway WS console '${params.clientUuid}/${params.localSessionId}' is not connected`);
             }
             const requestId = (0, node_crypto_1.randomUUID)();
             const response = await new Promise((resolve, reject) => {
@@ -1011,6 +1703,83 @@ const TelegramMcpGatewaySocketService = {
             });
             return response;
         },
+        async openLiveRelayStream(params) {
+            const streamId = (0, node_crypto_1.randomUUID)();
+            this.liveStreamHandlers?.set(streamId, {
+                clientUuid: params.clientUuid,
+                onEvent: params.onEvent,
+            });
+            try {
+                await this.requestLiveRelay?.({
+                    clientUuid: params.clientUuid,
+                    localSessionId: params.localSessionId,
+                    requestType: "stream_subscribe",
+                    payload: { stream_id: streamId },
+                });
+            }
+            catch (error) {
+                this.liveStreamHandlers?.delete(streamId);
+                throw error;
+            }
+            return {
+                streamId,
+                close: async () => {
+                    this.liveStreamHandlers?.delete(streamId);
+                    try {
+                        await this.requestLiveRelay?.({
+                            clientUuid: params.clientUuid,
+                            localSessionId: params.localSessionId,
+                            requestType: "stream_unsubscribe",
+                            payload: { stream_id: streamId },
+                        });
+                    }
+                    catch {
+                        // best-effort unsubscribe during stream shutdown
+                    }
+                },
+            };
+        },
+        async requestClientAction(params) {
+            const localSessionId = typeof params.payload?.session_id === "string" && params.payload.session_id.trim()
+                ? params.payload.session_id.trim()
+                : null;
+            const socket = localSessionId
+                ? findConnectedSocketForSession(this, {
+                    clientUuid: params.clientUuid,
+                    localSessionId,
+                })
+                : (this.connectedClientsByUuid?.get(params.clientUuid) ?? null);
+            if (!socket || socket.readyState !== 1) {
+                throw new Error(localSessionId
+                    ? `Gateway WS console '${params.clientUuid}/${localSessionId}' is not connected`
+                    : `Gateway WS client '${params.clientUuid}' is not connected`);
+            }
+            const requestId = (0, node_crypto_1.randomUUID)();
+            return await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    this.pendingActionRequests?.delete(requestId);
+                    reject(new Error("Remote action WS request timed out"));
+                }, LIVE_REQUEST_TIMEOUT_MS);
+                this.pendingActionRequests?.set(requestId, {
+                    clientUuid: params.clientUuid,
+                    resolve,
+                    reject,
+                    timeout,
+                });
+                this.getRuntimeOrThrow().logger.info("Gateway WS action request sent", {
+                    requestId,
+                    clientUuid: params.clientUuid,
+                    actionName: params.actionName,
+                    localSessionId,
+                });
+                socket.send(JSON.stringify({
+                    type: "action_request",
+                    request_id: requestId,
+                    action_name: params.actionName,
+                    payload: params.payload ?? {},
+                }));
+            });
+        },
         async notifyProjectMemberJoined(params) {
             const message = {
                 type: "project_event",
@@ -1034,12 +1803,14 @@ const TelegramMcpGatewaySocketService = {
                     delivered += 1;
                     continue;
                 }
-                const socket = this.connectedClientsByUuid?.get(clientUuid);
-                if (!socket || socket.readyState !== 1) {
+                const sockets = listConnectedSocketsForClient(this, clientUuid);
+                if (sockets.length === 0) {
                     continue;
                 }
-                socket.send(JSON.stringify(message));
-                delivered += 1;
+                for (const socket of sockets) {
+                    socket.send(JSON.stringify(message));
+                    delivered += 1;
+                }
             }
             return delivered;
         },
@@ -1066,12 +1837,14 @@ const TelegramMcpGatewaySocketService = {
                     delivered += 1;
                     continue;
                 }
-                const socket = this.connectedClientsByUuid?.get(clientUuid);
-                if (!socket || socket.readyState !== 1) {
+                const sockets = listConnectedSocketsForClient(this, clientUuid);
+                if (sockets.length === 0) {
                     continue;
                 }
-                socket.send(JSON.stringify(message));
-                delivered += 1;
+                for (const socket of sockets) {
+                    socket.send(JSON.stringify(message));
+                    delivered += 1;
+                }
             }
             return delivered;
         },
@@ -1092,57 +1865,38 @@ const TelegramMcpGatewaySocketService = {
                     delivered += 1;
                     continue;
                 }
-                const socket = this.connectedClientsByUuid?.get(clientUuid);
-                if (!socket || socket.readyState !== 1) {
+                const sockets = listConnectedSocketsForClient(this, clientUuid);
+                if (sockets.length === 0) {
                     continue;
                 }
-                socket.send(JSON.stringify(message));
-                delivered += 1;
+                for (const socket of sockets) {
+                    socket.send(JSON.stringify(message));
+                    delivered += 1;
+                }
             }
             return delivered;
         },
         async notifyLiveApprovalRequest(params) {
-            if (await this.isLocalGatewayClientUuid?.(params.clientUuid)) {
-                const runtime = this.getRuntimeOrThrow();
-                await runtime.telegramTransport.handleLiveViewApprovalRequestEvent(params.payload);
-                return true;
-            }
-            const socket = this.connectedClientsByUuid?.get(params.clientUuid);
-            if (!socket || socket.readyState !== 1) {
-                return false;
-            }
-            socket.send(JSON.stringify({
-                type: "live_event",
-                event: "approval_request",
-                payload: params.payload,
-            }));
+            const runtime = this.getRuntimeOrThrow();
+            await runtime.telegramTransport.handleLiveViewApprovalRequestEvent(params.payload);
             return true;
         },
         async notifyLiveApprovalResolved(params) {
-            if (await this.isLocalGatewayClientUuid?.(params.clientUuid)) {
-                const runtime = this.getRuntimeOrThrow();
-                await runtime.telegramTransport.handleLiveViewApprovalResolvedEvent({
-                    approved: params.approved,
-                    ...params.payload,
-                });
-                return true;
-            }
-            const socket = this.connectedClientsByUuid?.get(params.clientUuid);
-            if (!socket || socket.readyState !== 1) {
-                return false;
-            }
-            socket.send(JSON.stringify({
-                type: "live_event",
-                event: params.approved ? "approval_granted" : "approval_denied",
-                payload: params.payload,
-            }));
+            const runtime = this.getRuntimeOrThrow();
+            await runtime.telegramTransport.handleLiveViewApprovalResolvedEvent({
+                approved: params.approved,
+                ...params.payload,
+            });
             return true;
         },
         async notifyDeliveryQueued(params) {
             if (await this.handleLocalIncomingDelivery?.(params)) {
                 return true;
             }
-            const socket = this.connectedClientsByUuid?.get(params.clientUuid);
+            const socket = findConnectedSocketForSession(this, {
+                clientUuid: params.clientUuid,
+                localSessionId: params.delivery.target_local_session_id,
+            });
             if (!socket || socket.readyState !== 1) {
                 return false;
             }
@@ -1157,14 +1911,35 @@ const TelegramMcpGatewaySocketService = {
             if (await this.handleLocalDeliveryStatus?.(params)) {
                 return true;
             }
-            const socket = this.connectedClientsByUuid?.get(params.clientUuid);
-            if (!socket || socket.readyState !== 1) {
+            const sockets = listConnectedSocketsForClient(this, params.clientUuid);
+            if (sockets.length === 0) {
                 return false;
             }
-            socket.send(JSON.stringify({
-                type: "delivery_status_event",
-                payload: params.status,
-            }));
+            for (const socket of sockets) {
+                socket.send(JSON.stringify({
+                    type: "delivery_status_event",
+                    payload: params.status,
+                }));
+            }
+            return true;
+        },
+        async notifyTransportReply(params) {
+            if (await this.isLocalGatewayClientUuid?.(params.clientUuid)) {
+                const runtime = this.getRuntimeOrThrow();
+                await runtime.telegramTransport.handleGatewayTransportReplyEvent(params.payload);
+                return true;
+            }
+            const sockets = listConnectedSocketsForClient(this, params.clientUuid);
+            if (sockets.length === 0) {
+                return false;
+            }
+            for (const socket of sockets) {
+                socket.send(JSON.stringify({
+                    type: "transport_event",
+                    event: "request_reply",
+                    payload: params.payload,
+                }));
+            }
             return true;
         },
         async startGatewayWsServer() {
@@ -1172,7 +1947,7 @@ const TelegramMcpGatewaySocketService = {
             if (!runtime || this.wsServer) {
                 return;
             }
-            const httpServer = this.getHttpServerOrThrow?.();
+            const httpServer = await this.waitForHttpServer?.();
             const wsPath = runtime.config.distributed.gatewayWsPath.replace(/\/+$/u, "") || "/";
             const wsServer = new WebSocketServer({ noServer: true });
             wsServer.on("connection", (socket, req) => {
@@ -1197,8 +1972,35 @@ const TelegramMcpGatewaySocketService = {
                 });
                 socket.on("close", () => {
                     const hello = this.connectedClients?.get(socket);
+                    if (hello?.connection_id) {
+                        void this.broker
+                            .call("telegramMcp.gateway.removeLiveConsoles", {
+                            connection_id: hello.connection_id,
+                            ...(hello.client_uuid ? { client_uuid: hello.client_uuid } : {}),
+                        }, { meta: { internal_call: true } })
+                            .catch((error) => {
+                            runtime.logger.warn("Failed to remove gateway live consoles on disconnect", {
+                                connectionId: hello.connection_id,
+                                clientUuid: hello?.client_uuid ?? null,
+                                error: error instanceof Error ? error.message : String(error),
+                            });
+                        });
+                    }
                     if (hello?.client_uuid) {
-                        this.connectedClientsByUuid?.delete(hello.client_uuid);
+                        if (this.connectedClientsByUuid?.get(hello.client_uuid) === socket) {
+                            const replacement = listConnectedSocketsForClient(this, hello.client_uuid).find((candidate) => candidate !== socket) ?? null;
+                            if (replacement) {
+                                this.connectedClientsByUuid?.set(hello.client_uuid, replacement);
+                            }
+                            else {
+                                this.connectedClientsByUuid?.delete(hello.client_uuid);
+                            }
+                        }
+                        for (const [streamId, handler] of this.liveStreamHandlers?.entries() ?? []) {
+                            if (handler.clientUuid === hello.client_uuid) {
+                                this.liveStreamHandlers?.delete(streamId);
+                            }
+                        }
                     }
                     this.connectedClientToolsAlerts?.delete(socket);
                     this.connectedClients?.delete(socket);
@@ -1426,6 +2228,16 @@ const TelegramMcpGatewaySocketService = {
                 pending.reject(new Error("Gateway WS transport is shutting down"));
             }
             this.pendingLiveRequests?.clear();
+            for (const pending of this.pendingActionRequests?.values() ?? []) {
+                clearTimeout(pending.timeout);
+                pending.reject(new Error("Gateway WS transport is shutting down"));
+            }
+            this.pendingActionRequests?.clear();
+            for (const unsubscribe of this.localLiveStreamSubscriptions?.values() ?? []) {
+                unsubscribe();
+            }
+            this.localLiveStreamSubscriptions?.clear();
+            this.liveStreamHandlers?.clear();
             if (this.wsClient) {
                 const socket = this.wsClient;
                 this.wsClient = null;