@deadragdoll/tellymcp 0.0.10 → 0.0.12

package/dist/codexPluginInstaller.js

@@ -0,0 +1,215 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCodexPluginStatus = getCodexPluginStatus;
+exports.installCodexPlugin = installCodexPlugin;
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const PLUGIN_NAME = "telly-workflows";
+const MARKETPLACE_NAME = "personal";
+const MARKETPLACE_RELATIVE_PLUGIN_PATH = "./.codex/local-plugins/telly-workflows";
+function readJsonFile(filePath) {
+    return JSON.parse((0, node_fs_1.readFileSync)(filePath, "utf8"));
+}
+function getBundledPluginDir(packageRoot) {
+    return node_path_1.default.join(packageRoot, "config", "codex", "plugins", PLUGIN_NAME);
+}
+function getBundledPluginManifest(packageRoot) {
+    return readJsonFile(node_path_1.default.join(getBundledPluginDir(packageRoot), ".codex-plugin", "plugin.json"));
+}
+function getMarketplaceRoot(homeDir) {
+    return homeDir;
+}
+function getMarketplaceFile(homeDir) {
+    return node_path_1.default.join(homeDir, ".agents", "plugins", "marketplace.json");
+}
+function getManagedPluginDir(homeDir) {
+    return node_path_1.default.join(homeDir, ".codex", "local-plugins", PLUGIN_NAME);
+}
+function commandExists(command) {
+    const result = (0, node_child_process_1.spawnSync)(command, ["--version"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    return result.status === 0;
+}
+function parseMarketplaceRegistered(stdout, rootPath) {
+    return stdout
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .some((line) => {
+        if (line === "MARKETPLACE     ROOT" ||
+            line.startsWith("Added marketplace ") ||
+            line.startsWith("Installed marketplace root:")) {
+            return false;
+        }
+        const columns = line.split(/\s{2,}/u);
+        return columns[0] === MARKETPLACE_NAME && columns[1] === rootPath;
+    });
+}
+function parseInstalledPluginVersion(stdout) {
+    for (const rawLine of stdout.split(/\r?\n/u)) {
+        const line = rawLine.trim();
+        if (!line.startsWith(`${PLUGIN_NAME}@${MARKETPLACE_NAME}`)) {
+            continue;
+        }
+        const columns = line.split(/\s{2,}/u);
+        if (columns.length < 3) {
+            continue;
+        }
+        const version = columns[2]?.trim();
+        return version || null;
+    }
+    return null;
+}
+function ensureMarketplaceManifest(homeDir) {
+    const marketplaceFile = getMarketplaceFile(homeDir);
+    (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(marketplaceFile), { recursive: true });
+    const payload = (0, node_fs_1.existsSync)(marketplaceFile)
+        ? readJsonFile(marketplaceFile)
+        : {
+            name: MARKETPLACE_NAME,
+            interface: { displayName: "Personal" },
+            plugins: [],
+        };
+    const plugins = Array.isArray(payload.plugins) ? payload.plugins : [];
+    const existingIndex = plugins.findIndex((plugin) => String(plugin.name ?? "") === PLUGIN_NAME);
+    const nextEntry = {
+        name: PLUGIN_NAME,
+        source: {
+            source: "local",
+            path: MARKETPLACE_RELATIVE_PLUGIN_PATH,
+        },
+        policy: {
+            installation: "AVAILABLE",
+            authentication: "ON_INSTALL",
+        },
+        category: "Productivity",
+    };
+    if (existingIndex >= 0) {
+        plugins[existingIndex] = nextEntry;
+    }
+    else {
+        plugins.push(nextEntry);
+    }
+    const nextPayload = {
+        name: typeof payload.name === "string" && payload.name.trim()
+            ? payload.name.trim()
+            : MARKETPLACE_NAME,
+        interface: payload.interface &&
+            typeof payload.interface === "object" &&
+            typeof payload.interface.displayName === "string" &&
+            payload.interface.displayName.trim()
+            ? { displayName: payload.interface.displayName.trim() }
+            : { displayName: "Personal" },
+        plugins,
+    };
+    (0, node_fs_1.writeFileSync)(marketplaceFile, `${JSON.stringify(nextPayload, null, 2)}\n`, "utf8");
+    return marketplaceFile;
+}
+function syncBundledPlugin(packageRoot, homeDir) {
+    const bundledPluginDir = getBundledPluginDir(packageRoot);
+    if (!(0, node_fs_1.existsSync)(bundledPluginDir)) {
+        throw new Error(`Bundled Codex plugin is missing: ${bundledPluginDir}`);
+    }
+    const managedPluginDir = getManagedPluginDir(homeDir);
+    (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(managedPluginDir), { recursive: true });
+    (0, node_fs_1.rmSync)(managedPluginDir, { recursive: true, force: true });
+    (0, node_fs_1.cpSync)(bundledPluginDir, managedPluginDir, { recursive: true });
+    return managedPluginDir;
+}
+function ensureMarketplaceRegistered(homeDir) {
+    if (!commandExists("codex")) {
+        return false;
+    }
+    const marketplaceRoot = getMarketplaceRoot(homeDir);
+    const listed = (0, node_child_process_1.spawnSync)("codex", ["plugin", "marketplace", "list"], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (listed.status === 0 && parseMarketplaceRegistered(listed.stdout || "", marketplaceRoot)) {
+        return true;
+    }
+    const added = (0, node_child_process_1.spawnSync)("codex", ["plugin", "marketplace", "add", marketplaceRoot], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (added.status !== 0) {
+        throw new Error((added.stderr || added.stdout || "Failed to add Codex marketplace.").trim());
+    }
+    return true;
+}
+function getCodexPluginStatus(packageRoot) {
+    const homeDir = node_os_1.default.homedir();
+    const bundledManifest = getBundledPluginManifest(packageRoot);
+    const managedPluginDir = getManagedPluginDir(homeDir);
+    const sourceVersion = (0, node_fs_1.existsSync)(node_path_1.default.join(managedPluginDir, ".codex-plugin", "plugin.json"))
+        ? readJsonFile(node_path_1.default.join(managedPluginDir, ".codex-plugin", "plugin.json")).version
+        : null;
+    const codexAvailable = commandExists("codex");
+    const marketplaceRoot = getMarketplaceRoot(homeDir);
+    let marketplaceRegistered = false;
+    let installedVersion = null;
+    if (codexAvailable) {
+        const listedMarketplaces = (0, node_child_process_1.spawnSync)("codex", ["plugin", "marketplace", "list"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        marketplaceRegistered =
+            listedMarketplaces.status === 0 &&
+                parseMarketplaceRegistered(listedMarketplaces.stdout || "", marketplaceRoot);
+        const listedPlugins = (0, node_child_process_1.spawnSync)("codex", ["plugin", "list"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        if (listedPlugins.status === 0) {
+            installedVersion = parseInstalledPluginVersion(listedPlugins.stdout || "");
+        }
+    }
+    return {
+        pluginName: bundledManifest.name,
+        marketplaceName: MARKETPLACE_NAME,
+        bundledVersion: bundledManifest.version,
+        sourceVersion,
+        installedVersion,
+        codexAvailable,
+        marketplaceRegistered,
+        upToDate: installedVersion === bundledManifest.version,
+        bundledPluginDir: getBundledPluginDir(packageRoot),
+        managedPluginDir,
+        marketplaceFile: getMarketplaceFile(homeDir),
+        marketplaceRoot,
+    };
+}
+function installCodexPlugin(packageRoot) {
+    const homeDir = node_os_1.default.homedir();
+    ensureMarketplaceManifest(homeDir);
+    syncBundledPlugin(packageRoot, homeDir);
+    const afterSync = getCodexPluginStatus(packageRoot);
+    if (!afterSync.codexAvailable) {
+        return {
+            ...afterSync,
+            marketplaceRegistered: false,
+            installedVersion: null,
+            upToDate: false,
+        };
+    }
+    ensureMarketplaceRegistered(homeDir);
+    const beforeInstall = getCodexPluginStatus(packageRoot);
+    if (beforeInstall.installedVersion === beforeInstall.bundledVersion) {
+        return beforeInstall;
+    }
+    const installed = (0, node_child_process_1.spawnSync)("codex", ["plugin", "add", `${PLUGIN_NAME}@${MARKETPLACE_NAME}`], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (installed.status !== 0) {
+        throw new Error((installed.stderr || installed.stdout || "Failed to install Codex plugin.").trim());
+    }
+    return getCodexPluginStatus(packageRoot);
+}

package/dist/lib/mixins/session.errors.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlaygroundDisabledError = exports.SessionIdleTimeoutExceededError = exports.TokenInvalidError = exports.TokenNotFoundError = exports.SessionTokenSignatureInvalidError = exports.SessionTokenInvalidFormatError = exports.SessionTokenMismatchError = exports.SessionTokenNotFoundError = exports.SessionTokenRevokedError = exports.SessionTokenNotActiveError = exports.SessionTokenExpiredError = exports.SessionTokenInvalidError = exports.SessionValidationError = exports.SessionRefreshError = exports.SessionMaxLifetimeExceededError = exports.SessionStealedError = exports.SessionInvalidError = exports.SessionExpiredError = exports.SessionNotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.wrapUnhandledBackendError = exports.buildUnhandledBackendErrorCode = exports.BackendError = void 0;
+exports.extractErrorDetails = extractErrorDetails;
 class BackendError extends Error {
     statusCode;
     code;
@@ -14,9 +15,41 @@ class BackendError extends Error {
     }
 }
 exports.BackendError = BackendError;
+function collectOwnProps(err) {
+    try {
+        return Object.fromEntries(Object.getOwnPropertyNames(err).map((key) => [
+            key,
+            err[key],
+        ]));
+    }
+    catch {
+        return {};
+    }
+}
+function extractErrorDetails(err) {
+    if (!(err instanceof Error)) {
+        return undefined;
+    }
+    const named = err;
+    const ownProps = collectOwnProps(err);
+    return {
+        name: err.name,
+        message: err.message,
+        ...(typeof named.code === "string" || typeof named.code === "number"
+            ? { code: named.code }
+            : {}),
+        ...(typeof named.type === "string" ? { type: named.type } : {}),
+        ...(typeof named.statusCode === "number" ? { statusCode: named.statusCode } : {}),
+        ...(named.data !== undefined ? { data: named.data } : {}),
+        ...(named.fields !== undefined ? { fields: named.fields } : {}),
+        ...(typeof named.retryable === "boolean" ? { retryable: named.retryable } : {}),
+        ...(err.stack ? { stack: err.stack } : {}),
+        ...(Object.keys(ownProps).length > 0 ? { props: ownProps } : {}),
+    };
+}
 const buildUnhandledBackendErrorCode = (rawName) => `XC_${rawName.toUpperCase()}`;
 exports.buildUnhandledBackendErrorCode = buildUnhandledBackendErrorCode;
-const wrapUnhandledBackendError = (err, rawName) => new BackendError(err.message, 502, (0, exports.buildUnhandledBackendErrorCode)(rawName));
+const wrapUnhandledBackendError = (err, rawName) => new BackendError(err.message, 502, (0, exports.buildUnhandledBackendErrorCode)(rawName), extractErrorDetails(err));
 exports.wrapUnhandledBackendError = wrapUnhandledBackendError;
 class UnauthorizedError extends BackendError {
     constructor(message = "Unauthorized", data) {

package/dist/lib/pinoTargets.js

@@ -5,7 +5,7 @@ function createPinoTargets(config) {
     const targets = [
         {
             target: "pino-pretty",
-            level: config.level,
+            level: config.stderrLevel || config.level,
             options: {
                 destination: 2,
                 colorize: true,
@@ -18,7 +18,7 @@ function createPinoTargets(config) {
     if (config.fileEnabled) {
         targets.unshift({
             target: "pino/file",
-            level: config.level,
+            level: config.fileLevel || config.level,
             options: {
                 destination: config.filePath,
                 mkdir: true,

package/dist/moleculer.config.js

@@ -39,11 +39,14 @@ dotenv_1.default.config({ path: process.env.ENV_FILE ?? ".env" });
  *  }
  */
 process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+const configuredTransport = process.env.TRANSPORT?.trim();
 const pinoTransport = pino_1.default.transport({
     targets: (0, pinoTargets_1.createPinoTargets)({
         level: process.env.LOG_LEVEL || "info",
+        stderrLevel: process.env.LOG_STDERR_LEVEL || process.env.LOG_LEVEL || "info",
         fileEnabled: process.env.LOG_FILE_ENABLED === "true",
         filePath: process.env.LOG_FILE_PATH || ".tellymcp/log.jsonl",
+        fileLevel: process.env.LOG_FILE_LEVEL || process.env.LOG_LEVEL || "info",
     }),
 });
 const logger = [
@@ -85,11 +88,10 @@ const brokerConfig = {
     // Default log level for built-in console logger. It can be overwritten in logger options above.
     // Available values: trace, debug, info, warn, error, fatal
     logLevel: process.env.LOG_LEVEL || "info",
-    // Define transporter.
-    // More info: https://moleculer.services/docs/0.14/networking.html
-    // Note: During the development, you don't need to define it because all services will be loaded locally.
-    // In production you can set it via `TRANSPORTER=nats://localhost:4222` environment variable.
-    transporter: process.env.TRANSPORT ?? "TCP", // "NATS"
+    // Define transporter only when explicitly requested.
+    // For TellyMCP gateway/client nodes we use our own WS/HTTP control plane,
+    // so Moleculer UDP/TCP discovery is unnecessary and only adds noisy multicast warnings.
+    ...(configuredTransport ? { transporter: configuredTransport } : {}),
     // Define a cacher.
     // More info: https://moleculer.services/docs/0.14/caching.html
     // cacher:false,

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

@@ -2,11 +2,104 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TELEGRAM_MCP_BROWSER_SERVICE_NAME = void 0;
 const runtime_service_1 = require("./runtime.service");
+const remoteConsoleActionClient_1 = require("./src/features/distributed-gateway/model/remoteConsoleActionClient");
 const browserService_1 = require("./src/features/browser/model/browserService");
 exports.TELEGRAM_MCP_BROWSER_SERVICE_NAME = "telegramMcp.browser";
 const TelegramMcpBrowserService = {
     name: exports.TELEGRAM_MCP_BROWSER_SERVICE_NAME,
     dependencies: [runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME],
+    actions: {
+        openRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().open(ctx.params);
+            },
+        },
+        getConsoleRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().getConsole(ctx.params);
+            },
+        },
+        clickRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().click(ctx.params);
+            },
+        },
+        fillRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().fill(ctx.params);
+            },
+        },
+        pressRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().press(ctx.params);
+            },
+        },
+        reloadRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().reload(ctx.params);
+            },
+        },
+        waitForRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().waitFor(ctx.params);
+            },
+        },
+        waitForUrlRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().waitForUrl(ctx.params);
+            },
+        },
+        getErrorsRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().getErrors(ctx.params);
+            },
+        },
+        getNetworkFailuresRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().getNetworkFailures(ctx.params);
+            },
+        },
+        clearLogsRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().clearLogs(ctx.params);
+            },
+        },
+        getDomRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().getDom(ctx.params);
+            },
+        },
+        getComputedStyleRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().getComputedStyle(ctx.params);
+            },
+        },
+        screenshotRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().screenshot(ctx.params);
+            },
+        },
+        closeRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().close(ctx.params);
+            },
+        },
+    },
     created() {
         this.browserService = null;
     },
@@ -26,7 +119,7 @@ const TelegramMcpBrowserService = {
         }
         const runtime = await runtimeService.waitUntilReady();
         this.logger.info("Starting telegram_mcp browser service");
-        this.browserService = new browserService_1.BrowserService(runtime.config, runtime.stateStore, runtime.stateStore, runtime.stateStore, runtime.objectStore, runtime.telegramTransport, runtime.logger, runtime.projectIdentityResolver);
+        this.browserService = new browserService_1.BrowserService(runtime.config, runtime.sessionStore, runtime.maintenanceStore, runtime.stateStore, runtime.stateStore, runtime.objectStore, runtime.telegramTransport, runtime.logger, runtime.projectIdentityResolver, new remoteConsoleActionClient_1.RemoteConsoleActionClient((actionName, params) => this.broker.call(actionName, params, { meta: { internal_call: true } })));
         this.logger.info("telegram_mcp browser service is ready");
     },
     async stopped() {

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

@@ -4,15 +4,45 @@ exports.TELEGRAM_MCP_COLLABORATION_SERVICE_NAME = void 0;
 const runtime_service_1 = require("./runtime.service");
 const collaborationService_1 = require("./src/features/collaboration/model/collaborationService");
 const sendPartnerFileService_1 = require("./src/features/collaboration/model/sendPartnerFileService");
+const gatewaySessionsService_1 = require("./src/features/collaboration/model/gatewaySessionsService");
 const gatewayCollaborationBackend_1 = require("./src/features/distributed-client/model/gatewayCollaborationBackend");
+const remoteConsoleActionClient_1 = require("./src/features/distributed-gateway/model/remoteConsoleActionClient");
 const localCollaborationBackend_1 = require("./src/features/collaboration/model/localCollaborationBackend");
 exports.TELEGRAM_MCP_COLLABORATION_SERVICE_NAME = "telegramMcp.collaboration";
 const TelegramMcpCollaborationService = {
     name: exports.TELEGRAM_MCP_COLLABORATION_SERVICE_NAME,
     dependencies: [runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME],
+    actions: {
+        sendPartnerFileRemote: {
+            params: {
+                $$strict: false,
+                session_id: { type: "string", optional: true, trim: true, min: 1 },
+                target_session_id: { type: "string", optional: true, trim: true, min: 1 },
+                target_client_uuid: { type: "string", optional: true, trim: true, min: 1 },
+                target_local_session_id: { type: "string", optional: true, trim: true, min: 1 },
+                project_uuid: { type: "string", optional: true, trim: true, min: 1 },
+                cwd: { type: "string", optional: true, trim: true, min: 1 },
+                file_path: { type: "string", trim: true, min: 1 },
+                kind: {
+                    type: "enum",
+                    optional: true,
+                    values: ["share", "question", "reply", "request", "handoff"],
+                },
+                summary: { type: "string", optional: true, trim: true, min: 1 },
+                message: { type: "string", optional: true, trim: true, min: 1 },
+                expected_reply: { type: "string", optional: true, trim: true, min: 1 },
+                requires_reply: { type: "boolean", optional: true },
+                in_reply_to: { type: "string", optional: true, trim: true, min: 1 },
+            },
+            async handler(ctx) {
+                return this.getSendPartnerFileService().send(ctx.params);
+            },
+        },
+    },
     created() {
         this.collaborationService = null;
         this.sendPartnerFileService = null;
+        this.gatewaySessionsService = null;
     },
     methods: {
         getCollaborationService() {
@@ -27,6 +57,12 @@ const TelegramMcpCollaborationService = {
             }
             return this.sendPartnerFileService;
         },
+        getGatewaySessionsService() {
+            if (!this.gatewaySessionsService) {
+                throw new Error("telegram_mcp gateway sessions service is not initialized yet");
+            }
+            return this.gatewaySessionsService;
+        },
     },
     async started() {
         await this.broker.waitForServices([runtime_service_1.TELEGRAM_MCP_RUNTIME_SERVICE_NAME]);
@@ -36,16 +72,17 @@ const TelegramMcpCollaborationService = {
         }
         const runtime = await runtimeService.waitUntilReady();
         this.logger.info("Starting telegram_mcp collaboration service");
-        const localBackend = new localCollaborationBackend_1.LocalCollaborationBackend(runtime.config, runtime.stateStore, runtime.stateStore, runtime.stateStore, runtime.stateStore, runtime.objectStore, runtime.telegramTransport, runtime.logger);
+        const localBackend = new localCollaborationBackend_1.LocalCollaborationBackend(runtime.config, runtime.sessionStore, runtime.stateStore, runtime.stateStore, runtime.objectStore, runtime.telegramTransport, runtime.logger);
         runtime.gatewayHttpService.setPartnerNoteRelayHandler(async (input) => {
             const resolved = runtime.projectIdentityResolver.resolveSessionDefaults(input);
             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)
+            ? 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)
             : localBackend;
         this.collaborationService = new collaborationService_1.CollaborationService(backend, runtime.logger, runtime.projectIdentityResolver);
-        this.sendPartnerFileService = new sendPartnerFileService_1.SendPartnerFileService(runtime.config, runtime.sessionStore, runtime.logger, runtime.projectIdentityResolver, this.collaborationService);
+        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);
         runtime.telegramTransport.setCollaborationService(this.collaborationService);
         this.logger.info("telegram_mcp collaboration service is ready");
     },