@deadragdoll/tellymcp 0.0.13 → 0.0.15

package/dist/envMigration.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateEnvironmentContent = migrateEnvironmentContent;
+const dotenv_1 = require("dotenv");
+const environmentContract_1 = require("./services/features/telegram-mcp/src/app/config/environmentContract");
+const allRoles = ["client", "gateway", "both"];
+const gatewayRoles = ["gateway", "both"];
+const clientRoles = ["client", "both"];
+const environmentSections = [
+    {
+        title: "Runtime role and request policy",
+        roles: allRoles,
+        keys: ["DISTRIBUTED_MODE", "TELEGRAM_REQUEST_MODE"],
+    },
+    {
+        title: "Workspace identity",
+        roles: clientRoles,
+        keys: [
+            "PROJECT_NAME",
+            "TELLYMCP_SESSION_ID",
+            "TELLYMCP_SESSION_LABEL",
+            "GATEWAY_USER_UUID",
+        ],
+    },
+    {
+        title: "Gateway connection and scope",
+        roles: allRoles,
+        keys: [
+            "GATEWAY_PUBLIC_URL",
+            "GATEWAY_WS_URL",
+            "GATEWAY_WS_PATH",
+            "GATEWAY_SCOPE_TOKEN",
+            "GATEWAY_AUTH_TOKEN",
+        ],
+    },
+    {
+        title: "Telegram gateway",
+        roles: gatewayRoles,
+        keys: [
+            "TELEGRAM_BOT_TOKEN",
+            "TELEGRAM_BOT_USERNAME",
+            "ADMIN_TOKEN",
+            "DEBUG_LANGUAGE",
+            "TELEGRAM_POLL_INTERVAL_MS",
+            "TELEGRAM_DEFAULT_TIMEOUT_SECONDS",
+            "TELEGRAM_MAX_CONTEXT_CHARS",
+            "TELEGRAM_MAX_QUESTION_CHARS",
+            "TELEGRAM_MAX_MESSAGE_CHARS",
+            "TELEGRAM_MENU_PAYLOAD_TTL_SECONDS",
+            "TELEGRAM_WEBHOOK_ENABLED",
+            "TELEGRAM_WEBHOOK_PATH",
+            "TELEGRAM_WEBHOOK_PUBLIC_URL",
+            "TELEGRAM_WEBHOOK_SECRET",
+            "TELEGRAM_WEBHOOK_TRACE",
+            "TELEGRAM_WEBHOOK_DROP_PENDING_UPDATES",
+        ],
+    },
+    {
+        title: "Redis",
+        roles: gatewayRoles,
+        keys: [
+            "REDIS_HOST",
+            "REDIS_PORT",
+            "REDIS_DB",
+            "REDIS_USERNAME",
+            "REDIS_PASSWORD",
+        ],
+    },
+    {
+        title: "PostgreSQL gateway metadata",
+        roles: gatewayRoles,
+        keys: [
+            "DB_HOST",
+            "DB_PORT",
+            "DB_USER",
+            "DB_PASSWORD",
+            "DB_NAME",
+            "DB_SCHEMA",
+        ],
+    },
+    {
+        title: "Standalone HTTP and MCP",
+        roles: allRoles,
+        keys: [
+            "ROOT_PREFIX",
+            "PORT",
+            "MCP_HTTP_HOST",
+            "MCP_HTTP_PORT",
+            "MCP_HTTP_PATH",
+            "MCP_HTTP_BEARER_TOKEN",
+            "MCP_HTTP_ENABLE_DEBUG_ROUTES",
+            "MCP_HTTP_ENABLE_PRUNE_ROUTE",
+            "MCP_XCHANGE_DIR",
+        ],
+    },
+    {
+        title: "Chat connector OAuth",
+        roles: gatewayRoles,
+        keys: [
+            "TELLYMCP_PUBLIC_URL",
+            "TELLYMCP_OAUTH_ISSUER",
+            "TELLYMCP_OAUTH_AUDIENCE",
+            "TELLYMCP_MAGIC_TOKEN",
+            "TELLYMCP_MAGIC_TOKEN_HASH",
+            "TELLYMCP_OAUTH_CLIENT_ID",
+            "TELLYMCP_OAUTH_CLIENT_SECRET",
+            "TELLYMCP_ALLOWED_REDIRECT_URIS",
+            "TELLYMCP_OAUTH_PRIVATE_KEY_PEM",
+            "TELLYMCP_AUTH_CODE_TTL_SECONDS",
+            "TELLYMCP_OAUTH_SCOPES",
+            "TELLYMCP_OAUTH_KEY_ID",
+        ],
+    },
+    {
+        title: "RabbitMQ fanout",
+        roles: gatewayRoles,
+        keys: [
+            "RMQ_HOST",
+            "RMQ_PORT",
+            "RMQ_USER",
+            "RMQ_PASSWORD",
+            "RMQ_VHOST",
+            "RMQ_EXCHANGE",
+        ],
+    },
+    {
+        title: "Telegram Mini App",
+        roles: gatewayRoles,
+        keys: [
+            "WEBAPP_ENABLED",
+            "WEBAPP_BASE_PATH",
+            "WEBAPP_PUBLIC_URL",
+            "WEBAPP_INITDATA_TTL_SECONDS",
+            "WEBAPP_SESSION_TTL_SECONDS",
+            "WEBAPP_LAUNCH_MODE",
+            "WEBAPP_VISIBLE_SCREENS",
+            "WEBAPP_ACTION_COOLDOWN_MS",
+        ],
+    },
+    {
+        title: "Built-in PTY terminal",
+        roles: clientRoles,
+        keys: [
+            "TERMINAL_SHELL",
+            "TERMINAL_COLS",
+            "TERMINAL_ROWS",
+            "TERMINAL_SCROLLBACK_LINES",
+            "TERMINAL_NUDGE_ENABLED",
+            "TERMINAL_NUDGE_DEBOUNCE_SECONDS",
+            "TERMINAL_NUDGE_COOLDOWN_SECONDS",
+            "TERMINAL_NUDGE_MESSAGE",
+            "TERMINAL_PARTNER_NUDGE_MESSAGE",
+            "TERMINAL_PARTNER_REPLY_NUDGE_MESSAGE",
+            "TERMINAL_CAPTURE_MODE",
+            "TERMINAL_CAPTURE_LINES",
+            "TERMINAL_PROMPT_SCAN_ENABLED",
+            "TERMINAL_PROMPT_SCAN_INTERVAL_SECONDS",
+            "TERMINAL_PROMPT_SCAN_COOLDOWN_SECONDS",
+            "TERMINAL_PROMPT_SCAN_STRATEGY",
+            "TERMINAL_PROMPT_SCAN_MIN_SCORE",
+        ],
+    },
+    {
+        title: "Gateway-side prompt detection",
+        roles: ["gateway"],
+        keys: [
+            "TERMINAL_PROMPT_SCAN_ENABLED",
+            "TERMINAL_PROMPT_SCAN_INTERVAL_SECONDS",
+            "TERMINAL_PROMPT_SCAN_COOLDOWN_SECONDS",
+            "TERMINAL_PROMPT_SCAN_STRATEGY",
+            "TERMINAL_PROMPT_SCAN_MIN_SCORE",
+        ],
+    },
+    {
+        title: "Browser automation",
+        roles: clientRoles,
+        keys: [
+            "BROWSER_ENABLED",
+            "BROWSER_HEADLESS",
+            "BROWSER_DEVTOOLS",
+            "BROWSER_ADDRESS",
+            "BROWSER_TIMEOUT_MS",
+            "BROWSER_MAX_EVENTS",
+            "BROWSER_WAIT_UNTIL",
+            "BROWSER_EXECUTABLE_PATH",
+            "BROWSER_CHANNEL",
+            "BROWSER_SLOW_MO_MS",
+            "BROWSER_ATTACH_ENABLED",
+            "BROWSER_ATTACH_WS_HOST",
+            "BROWSER_ATTACH_WS_PORT",
+            "BROWSER_ATTACH_WS_PATH",
+        ],
+    },
+    {
+        title: "Outbound proxy",
+        roles: allRoles,
+        keys: ["PROXY_USE", "HTTP_PROXY", "SOCKS5_PROXY", "NO_PROXY"],
+    },
+    {
+        title: "Moleculer identity and diagnostics",
+        roles: allRoles,
+        keys: [
+            "NAMESPACE",
+            "NODE_ID",
+            "TRANSPORT",
+            "MOLECULER_TRACE",
+            "MOLECULER_METRICS",
+            "METRICS_PORT",
+            "METRICS_PATH",
+        ],
+    },
+    {
+        title: "Logging",
+        roles: allRoles,
+        keys: [
+            "LOG_LEVEL",
+            "LOG_STDERR_LEVEL",
+            "LOG_FILE_ENABLED",
+            "LOG_FILE_LEVEL",
+            "LOG_FILE_PATH",
+            "LOGFEED_ENABLED",
+            "LOGFEED_LEVEL",
+            "LOGFEED_BUFFER_SIZE",
+        ],
+    },
+];
+function inferRole(environment) {
+    const configuredMode = environment.DISTRIBUTED_MODE?.trim();
+    if (configuredMode === "client" ||
+        configuredMode === "gateway" ||
+        configuredMode === "both") {
+        return configuredMode;
+    }
+    if (configuredMode) {
+        throw new Error(`DISTRIBUTED_MODE must be client, gateway, or both; received ${configuredMode}.`);
+    }
+    return environment.TELEGRAM_BOT_TOKEN ||
+        environment.DB_HOST ||
+        environment.ROOT_PREFIX ||
+        environment.PORT
+        ? "gateway"
+        : "client";
+}
+function formatEnvironmentValue(value) {
+    if (/^[A-Za-z0-9_./:@%+,?&=-]*$/u.test(value)) {
+        return value;
+    }
+    return JSON.stringify(value);
+}
+function migrateEnvironmentContent(source) {
+    const parsed = (0, dotenv_1.parse)(source);
+    const normalized = { ...parsed };
+    const renamedKeys = [];
+    const handledLegacyKeys = new Set();
+    for (const [from, to] of Object.entries(environmentContract_1.LEGACY_ENV_RENAMES)) {
+        if (!(from in parsed)) {
+            continue;
+        }
+        if (!(to in parsed)) {
+            normalized[to] = parsed[from] ?? "";
+        }
+        delete normalized[from];
+        handledLegacyKeys.add(from);
+        renamedKeys.push({ from, to });
+    }
+    for (const [name, value] of Object.entries(parsed)) {
+        if (!name.startsWith("TMUX_")) {
+            continue;
+        }
+        const replacement = (0, environmentContract_1.getTmuxReplacement)(name);
+        if (replacement && !(replacement in parsed)) {
+            normalized[replacement] = value;
+            renamedKeys.push({ from: name, to: replacement });
+        }
+        delete normalized[name];
+        handledLegacyKeys.add(name);
+    }
+    for (const name of environmentContract_1.REMOVED_ENV_KEYS) {
+        delete normalized[name];
+    }
+    const role = inferRole(normalized);
+    normalized.DISTRIBUTED_MODE = role;
+    const emitted = new Set();
+    const keptKeys = [];
+    const output = [
+        "# Generated by tellymcp migrate-env.",
+        `# Role: ${role}`,
+        "",
+    ];
+    for (const section of environmentSections) {
+        if (!section.roles.includes(role)) {
+            continue;
+        }
+        const sectionKeys = section.keys.filter((key) => key in normalized && !emitted.has(key));
+        if (sectionKeys.length === 0) {
+            continue;
+        }
+        output.push(`# ${section.title}`);
+        for (const key of sectionKeys) {
+            output.push(`${key}=${formatEnvironmentValue(normalized[key] ?? "")}`);
+            emitted.add(key);
+            keptKeys.push(key);
+        }
+        output.push("");
+    }
+    const droppedKeys = Object.keys(parsed)
+        .filter((key) => !emitted.has(key) && !handledLegacyKeys.has(key))
+        .sort();
+    return {
+        role,
+        content: `${output.join("\n").trimEnd()}\n`,
+        keptKeys,
+        renamedKeys,
+        droppedKeys,
+    };
+}

package/dist/moleculer.config.js

@@ -67,9 +67,7 @@ const logger = [
 const metricsEnabled = process.env.MOLECULER_METRICS === "true";
 const metricsPort = +(process.env.METRICS_PORT || 3030);
 const metricsPath = process.env.METRICS_PATH || "/metrics";
-const logFeedEnabled = process.env.ENABLE_LOGFEED != null
-    ? !["0", "false", "no", "off"].includes(process.env.ENABLE_LOGFEED.toLowerCase())
-    : process.env.LOGFEED_ENABLED !== "false";
+const logFeedEnabled = !["0", "false", "no", "off"].includes((process.env.LOGFEED_ENABLED ?? "true").toLowerCase());
 if (logFeedEnabled) {
     logger.push(new logfeed_1.LogFeedLogger({
         level: process.env.LOGFEED_LEVEL || process.env.LOG_LEVEL || "info",

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

@@ -26,7 +26,7 @@ const TelegramMcpApprovalService = {
         }
         const runtime = await runtimeService.waitUntilReady();
         this.logger.info("Starting telegram_mcp approval service");
-        this.approvalOrchestrator = new orchestrator_1.HumanApprovalOrchestrator(runtime.config, runtime.stateStore, runtime.stateStore, runtime.stateStore, runtime.telegramTransport, runtime.logger, runtime.projectIdentityResolver);
+        this.approvalOrchestrator = new orchestrator_1.HumanApprovalOrchestrator(runtime.config, runtime.sessionStore, runtime.stateStore, runtime.stateStore, runtime.telegramTransport, runtime.logger, runtime.projectIdentityResolver);
         this.logger.info("telegram_mcp approval service is ready");
     },
 };

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

@@ -33,6 +33,24 @@ const TelegramMcpBrowserService = {
                 return this.getBrowserService().listTabs(ctx.params);
             },
         },
+        attachActiveTabRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().attachActiveTab(ctx.params);
+            },
+        },
+        attachTabRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().attachTab(ctx.params);
+            },
+        },
+        detachTabRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().detachTab(ctx.params);
+            },
+        },
         startRecordingRemote: {
             params: { $$strict: false },
             async handler(ctx) {

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

@@ -78,11 +78,11 @@ const TelegramMcpCollaborationService = {
             return localBackend.sendPartnerNote(input, resolved);
         });
         const backend = runtime.config.distributed.gatewayPublicUrl
-            ? new gatewayCollaborationBackend_1.GatewayCollaborationBackend(runtime.logger, runtime.stateStore, runtime.config.distributed.gatewayPublicUrl, runtime.config.distributed.gatewayAuthToken, runtime.config.distributed.gatewayToken, runtime.config.distributed.gatewayUserUuid, runtime.config.project.name, runtime.config.telegram.botUsername)
+            ? new gatewayCollaborationBackend_1.GatewayCollaborationBackend(runtime.logger, runtime.stateStore, runtime.config.distributed.gatewayPublicUrl, runtime.config.distributed.gatewayAuthToken, runtime.config.distributed.gatewayScopeToken, runtime.config.distributed.gatewayUserUuid, runtime.config.project.name, runtime.config.telegram.botUsername)
             : localBackend;
         this.collaborationService = new collaborationService_1.CollaborationService(backend, runtime.logger, runtime.projectIdentityResolver);
         this.sendPartnerFileService = new sendPartnerFileService_1.SendPartnerFileService(runtime.config, runtime.sessionStore, runtime.stateStore, runtime.logger, runtime.projectIdentityResolver, this.collaborationService, new remoteConsoleActionClient_1.RemoteConsoleActionClient((actionName, params) => this.broker.call(actionName, params, { meta: { internal_call: true } })));
-        this.gatewaySessionsService = new gatewaySessionsService_1.GatewaySessionsService(runtime.logger, runtime.stateStore, runtime.config.distributed.gatewayPublicUrl, runtime.config.distributed.gatewayAuthToken, runtime.config.distributed.gatewayToken, runtime.config.distributed.gatewayUserUuid, runtime.config.project.name, runtime.config.telegram.botUsername);
+        this.gatewaySessionsService = new gatewaySessionsService_1.GatewaySessionsService(runtime.logger, runtime.stateStore, runtime.config.distributed.gatewayPublicUrl, runtime.config.distributed.gatewayAuthToken, runtime.config.distributed.gatewayScopeToken, runtime.config.distributed.gatewayUserUuid, runtime.config.project.name, runtime.config.telegram.botUsername);
         runtime.telegramTransport.setCollaborationService(this.collaborationService);
         this.logger.info("telegram_mcp collaboration service is ready");
     },

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

@@ -5,7 +5,7 @@ const db_1 = require("../../../lib/mixins/db");
 exports.TELEGRAM_MCP_ENSUREDB_SERVICE_NAME = "telegramMcp.ensuredb";
 const DISTRIBUTED_MODE = process.env.DISTRIBUTED_MODE || "client";
 const GATEWAY_ENABLED = DISTRIBUTED_MODE === "gateway" || DISTRIBUTED_MODE === "both";
-const MCP_SCHEMA = process.env.DB_SCHEME || "mcp";
+const MCP_SCHEMA = process.env.DB_SCHEMA || "mcp";
 const TelegramMcpEnsureDbService = {
     name: exports.TELEGRAM_MCP_ENSUREDB_SERVICE_NAME,
     mixins: [db_1.DBMixin],

package/dist/services/features/telegram-mcp/file-content.service.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEGRAM_MCP_FILE_CONTENT_SERVICE_NAME = void 0;
+const runtime_service_1 = require("./runtime.service");
+const remoteConsoleActionClient_1 = require("./src/features/distributed-gateway/model/remoteConsoleActionClient");
+const getFileService_1 = require("./src/features/file-content/model/getFileService");
+exports.TELEGRAM_MCP_FILE_CONTENT_SERVICE_NAME = "telegramMcp.fileContent";
+const TelegramMcpFileContentService = {
+    name: exports.TELEGRAM_MCP_FILE_CONTENT_SERVICE_NAME,
+    dependencies: [runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME],
+    actions: {
+        listFilesRemote: {
+            params: {
+                $$strict: false,
+                session_id: { type: "string", optional: true, trim: true, min: 1 },
+                source: {
+                    type: "enum",
+                    optional: true,
+                    values: ["telegram-upload", "browser-screenshot", "partner-artifact"],
+                },
+                limit: {
+                    type: "number",
+                    optional: true,
+                    integer: true,
+                    positive: true,
+                    max: 200,
+                },
+            },
+            async handler(ctx) {
+                return this.getGetFileService().list(ctx.params);
+            },
+        },
+        getFileRemote: {
+            params: {
+                $$strict: false,
+                session_id: { type: "string", optional: true, trim: true, min: 1 },
+                file_path: { type: "string", optional: true, trim: true, min: 1 },
+                selector: {
+                    type: "enum",
+                    optional: true,
+                    values: ["latest_screenshot"],
+                },
+                type: {
+                    type: "enum",
+                    optional: true,
+                    values: ["text", "base64"],
+                },
+            },
+            async handler(ctx) {
+                return this.getGetFileService().get(ctx.params);
+            },
+        },
+        uploadFileRemote: {
+            params: {
+                $$strict: false,
+                session_id: { type: "string", optional: true, trim: true, min: 1 },
+                file_path: { type: "string", optional: true, trim: true, min: 1 },
+                selector: {
+                    type: "enum",
+                    optional: true,
+                    values: ["latest_screenshot"],
+                },
+                type: { type: "enum", values: ["url"] },
+                upload_url: { type: "string", trim: true, min: 1 },
+            },
+            async handler(ctx) {
+                return this.getGetFileService().upload(ctx.params);
+            },
+        },
+    },
+    created() {
+        this.getFileService = null;
+    },
+    methods: {
+        getGetFileService() {
+            if (!this.getFileService) {
+                throw new Error("telegram_mcp file content service is not initialized yet");
+            }
+            return this.getFileService;
+        },
+    },
+    async started() {
+        await this.broker.waitForServices([runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME]);
+        const runtimeService = this.broker.getLocalService(runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME);
+        if (!runtimeService) {
+            throw new Error(`Local Moleculer service '${runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME}' is unavailable`);
+        }
+        const runtime = await runtimeService.waitUntilReady();
+        this.logger.info("Starting telegram_mcp file content service");
+        this.getFileService = new getFileService_1.GetFileService(runtime.config, runtime.sessionStore, runtime.stateStore, runtime.stateStore, runtime.logger, runtime.projectIdentityResolver, new remoteConsoleActionClient_1.RemoteConsoleActionClient((actionName, params) => this.broker.call(actionName, params, { meta: { internal_call: true } })), runtime.temporaryFileLinkStore);
+        this.logger.info("telegram_mcp file content service is ready");
+    },
+};
+exports.default = TelegramMcpFileContentService;

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

@@ -9,6 +9,7 @@ const runtime_service_1 = require("./runtime.service");
 const xchangeRecordHints_1 = require("./src/shared/lib/xchangeRecordHints");
 const client_1 = require("./src/shared/integrations/terminal/client");
 const sqliteRecordStore_1 = require("./src/shared/integrations/xchange/sqliteRecordStore");
+const bodyLimits_1 = require("./src/shared/lib/bodyLimits");
 exports.TELEGRAM_MCP_GATEWAY_DELIVERY_SERVICE_NAME = "telegramMcp.gatewayDelivery";
 function renderYamlArray(values) {
     if (values.length === 0) {
@@ -319,7 +320,10 @@ const TelegramMcpGatewayDeliveryService = {
                     `shares/files/${delivery.share_id}/${artifact.original_name}`;
                 let localArtifactPath;
                 if (artifact.content_base64) {
-                    localArtifactPath = await (0, client_1.writeXchangeRelativeFile)(runtime.config.terminal, workspaceDir, runtime.config.exchange.dir, relativePath, Buffer.from(artifact.content_base64, "base64"));
+                    (0, bodyLimits_1.assertStringBodySize)(artifact.content_base64);
+                    const decodedContent = Buffer.from(artifact.content_base64, "base64");
+                    (0, bodyLimits_1.assertBodySize)(decodedContent.byteLength);
+                    localArtifactPath = await (0, client_1.writeXchangeRelativeFile)(runtime.config.terminal, workspaceDir, runtime.config.exchange.dir, relativePath, decodedContent);
                 }
                 else {
                     localArtifactPath = await runtime.objectStore.ensureLocalFile({

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

@@ -11,6 +11,8 @@ const auth_1 = require("./src/app/webapp/auth");
 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 gatewayAuth_1 = require("./src/shared/lib/gatewayAuth");
+const bodyLimits_1 = require("./src/shared/lib/bodyLimits");
 const versionHandshake_1 = require("./src/shared/lib/version/versionHandshake");
 const wsLib = require("ws");
 const WebSocketServer = wsLib.WebSocketServer;
@@ -226,6 +228,7 @@ const TelegramMcpGatewaySocketService = {
                         "bootstrap_validate",
                         "view",
                         "action",
+                        "resize",
                         "stream_subscribe",
                         "stream_unsubscribe",
                     ],
@@ -941,7 +944,6 @@ const TelegramMcpGatewaySocketService = {
                             session_id: sessionId,
                             session_label: session?.label ?? null,
                             terminal_target: Boolean(session?.terminalTarget),
-                            poll_interval_ms: runtime.config.webapp.pollIntervalMs,
                             telegram_user_id: telegramUserId,
                         },
                     };
@@ -1002,6 +1004,25 @@ const TelegramMcpGatewaySocketService = {
                         },
                     };
                 }
+                if (request.request_type === "resize") {
+                    const cols = typeof request.payload?.cols === "number" ? request.payload.cols : NaN;
+                    const rows = typeof request.payload?.rows === "number" ? request.payload.rows : NaN;
+                    if (!Number.isFinite(cols) || !Number.isFinite(rows)) {
+                        throw new Error("Terminal cols and rows are required");
+                    }
+                    const sessionId = request.local_session_id.trim();
+                    const session = await runtime.sessionStore.getSession(sessionId);
+                    if (!session?.terminalTarget || !(0, client_1.isStreamableTerminalTarget)(session.terminalTarget)) {
+                        throw new Error("Terminal target does not support resize");
+                    }
+                    (0, client_1.resizeForegroundTerminal)(session.terminalTarget, Math.max(20, Math.min(400, Math.round(cols))), Math.max(5, Math.min(200, Math.round(rows))));
+                    return {
+                        type: "live_response",
+                        request_id: request.request_id,
+                        ok: true,
+                        result: { ok: true },
+                    };
+                }
                 if (request.request_type === "stream_subscribe") {
                     const streamId = typeof request.payload?.stream_id === "string"
                         ? request.payload.stream_id.trim()
@@ -1582,7 +1603,9 @@ const TelegramMcpGatewaySocketService = {
                         requestId,
                         actionName,
                         error: formattedError,
-                        payload: parsed.payload ?? {},
+                        payload: actionName === "telegramMcp.fileContent.uploadFileRemote"
+                            ? { ...(parsed.payload ?? {}), upload_url: "[redacted]" }
+                            : (parsed.payload ?? {}),
                     });
                     this.wsClient?.send(JSON.stringify({
                         type: "action_response",
@@ -1956,16 +1979,11 @@ const TelegramMcpGatewaySocketService = {
             }
             const httpServer = await this.waitForHttpServer?.();
             const wsPath = runtime.config.distributed.gatewayWsPath.replace(/\/+$/u, "") || "/";
-            const wsServer = new WebSocketServer({ noServer: true });
+            const wsServer = new WebSocketServer({
+                noServer: true,
+                maxPayload: bodyLimits_1.MAX_BODY_SIZE_BYTES,
+            });
             wsServer.on("connection", (socket, req) => {
-                if (runtime.config.distributed.gatewayAuthToken) {
-                    const authorization = req.headers?.authorization;
-                    if (authorization !==
-                        `Bearer ${runtime.config.distributed.gatewayAuthToken}`) {
-                        socket.close(1008, "Unauthorized");
-                        return;
-                    }
-                }
                 runtime.logger.warn("Gateway WS client connected", {
                     remoteAddress: req.socket.remoteAddress,
                     path: req.url,
@@ -1977,6 +1995,11 @@ const TelegramMcpGatewaySocketService = {
                         });
                     });
                 });
+                socket.on("error", (error) => {
+                    runtime.logger.warn("Gateway WS server socket error", {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                });
                 socket.on("close", () => {
                     const hello = this.connectedClients?.get(socket);
                     if (hello?.connection_id) {
@@ -2026,6 +2049,14 @@ const TelegramMcpGatewaySocketService = {
                 if (requestPath !== wsPath) {
                     return;
                 }
+                if (!(0, gatewayAuth_1.isGatewayAuthorizationValid)(req.headers.authorization, runtime.config.distributed.gatewayAuthToken)) {
+                    socket.write("HTTP/1.1 401 Unauthorized\r\n" +
+                        "Connection: close\r\n" +
+                        "Content-Length: 0\r\n" +
+                        "\r\n");
+                    socket.destroy();
+                    return;
+                }
                 wsServer.handleUpgrade(req, socket, head, (clientSocket) => {
                     wsServer.emit("connection", clientSocket, req);
                 });
@@ -2082,6 +2113,7 @@ const TelegramMcpGatewaySocketService = {
             const normalizedUrl = normalizeWebSocketUrl(wsUrl, runtime.config.distributed.gatewayWsPath);
             this.wsConnectionId = (0, node_crypto_1.randomUUID)();
             const socket = new wsLib.WebSocket(normalizedUrl, {
+                maxPayload: bodyLimits_1.MAX_BODY_SIZE_BYTES,
                 headers: runtime.config.distributed.gatewayAuthToken
                     ? {
                         authorization: `Bearer ${runtime.config.distributed.gatewayAuthToken}`,

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

@@ -11,7 +11,7 @@ const gatewayReplyResolution_1 = require("./src/features/distributed-gateway/mod
 const gatewayScope_1 = require("./src/shared/lib/gatewayScope");
 const ensuredb_service_1 = require("./ensuredb.service");
 exports.TELEGRAM_MCP_GATEWAY_SERVICE_NAME = "telegramMcp.gateway";
-const MCP_SCHEMA = process.env.DB_SCHEME || "mcp";
+const MCP_SCHEMA = process.env.DB_SCHEMA || "mcp";
 const DISTRIBUTED_MODE = process.env.DISTRIBUTED_MODE || "client";
 const GATEWAY_ENABLED = DISTRIBUTED_MODE === "gateway" || DISTRIBUTED_MODE === "both";
 function trimOptionalText(value) {

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

@@ -69,6 +69,7 @@ const TelegramMcpHttpService = {
             path: runtime.config.mcp.httpPath,
             webappBasePath: runtime.config.webapp.basePath,
             bearerAuthEnabled: Boolean(runtime.config.mcp.bearerToken),
+            oauthConnectorEnabled: Boolean(runtime.config.oauth),
         });
     },
     async stopped() {