@deadragdoll/tellymcp 0.0.10 → 0.0.12

package/dist/services/features/telegram-mcp/src/features/browser/model/browserService.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BrowserService = void 0;
 const node_path_1 = __importDefault(require("node:path"));
+const gatewayClientAccess_1 = require("../../distributed-client/model/gatewayClientAccess");
 function pushBounded(list, entry, max) {
     list.push(entry);
     if (list.length > max) {
@@ -46,38 +47,66 @@ function formatConsoleLocation(message) {
 function escapeCssAttributeValue(value) {
     return value.replace(/\\/gu, "\\\\").replace(/"/gu, '\\"');
 }
+const DEFAULT_BROWSER_VIEWPORT_WIDTH = 1720;
+const DEFAULT_BROWSER_VIEWPORT_HEIGHT = 980;
 class BrowserService {
     config;
     sessionStore;
+    maintenanceStore;
     bindingStore;
     xchangeFileMetaStore;
     objectStore;
     telegramTransport;
     logger;
     projectIdentityResolver;
+    remoteConsoleInvoker;
     playwrightModulePromise;
     browserPromise;
     sessionStates = new Map();
-    constructor(config, sessionStore, bindingStore, xchangeFileMetaStore, objectStore, telegramTransport, logger, projectIdentityResolver) {
+    constructor(config, sessionStore, maintenanceStore, bindingStore, xchangeFileMetaStore, objectStore, telegramTransport, logger, projectIdentityResolver, remoteConsoleInvoker) {
         this.config = config;
         this.sessionStore = sessionStore;
+        this.maintenanceStore = maintenanceStore;
         this.bindingStore = bindingStore;
         this.xchangeFileMetaStore = xchangeFileMetaStore;
         this.objectStore = objectStore;
         this.telegramTransport = telegramTransport;
         this.logger = logger;
         this.projectIdentityResolver = projectIdentityResolver;
+        this.remoteConsoleInvoker = remoteConsoleInvoker;
     }
     async open(input) {
-        this.ensureEnabled();
         const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
-        const existingState = this.sessionStates.get(resolved.sessionId);
-        const shouldReset = input.reset_context === true;
+        const normalizedSessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const remote = await this.invokeRemote(normalizedSessionId, "telegramMcp.browser.openRemote", {
+            ...input,
+            session_id: normalizedSessionId,
+        });
+        if (remote) {
+            return remote;
+        }
+        this.ensureEnabled();
+        const existingState = this.sessionStates.get(normalizedSessionId);
+        const requestedViewport = this.resolveRequestedViewport(input);
+        const shouldUpgradeLegacyViewport = this.config.browser.headless === false &&
+            input.reset_context !== true &&
+            !requestedViewport &&
+            Boolean(existingState?.page.viewportSize());
+        const shouldReset = input.reset_context === true || shouldUpgradeLegacyViewport;
         const targetUrl = this.resolveBrowserUrl(input.url);
         if (shouldReset && existingState) {
-            await this.closeState(resolved.sessionId, existingState);
+            await this.closeState(normalizedSessionId, existingState);
+        }
+        const { state, createdContext } = await this.ensureSessionState(normalizedSessionId, shouldReset, input);
+        if (requestedViewport) {
+            await state.page.setViewportSize(requestedViewport);
+        }
+        else if (this.config.browser.headless !== false) {
+            await state.page.setViewportSize({
+                width: DEFAULT_BROWSER_VIEWPORT_WIDTH,
+                height: DEFAULT_BROWSER_VIEWPORT_HEIGHT,
+            });
         }
-        const { state, createdContext } = await this.ensureSessionState(resolved.sessionId, shouldReset);
         const waitUntil = (input.wait_until ??
             this.config.browser.waitUntil);
         await state.page.goto(targetUrl, {
@@ -89,21 +118,36 @@ class BrowserService {
         state.lastUsedAt = new Date().toISOString();
         this.logger.info("Browser page opened", {
             sessionId: resolved.sessionId,
+            normalizedSessionId,
             url: state.currentUrl,
             title: state.title,
             createdContext,
             waitUntil,
             headless: this.config.browser.headless,
+            viewportWidth: state.page.viewportSize()?.width ?? requestedViewport?.width,
+            viewportHeight: state.page.viewportSize()?.height ?? requestedViewport?.height,
         });
+        const viewport = state.page.viewportSize();
         return {
-            session_id: resolved.sessionId,
+            session_id: normalizedSessionId,
             opened: true,
             created_context: createdContext,
             url: state.currentUrl,
             ...(state.title ? { title: state.title } : {}),
+            ...(viewport?.width ? { viewport_width: viewport.width } : {}),
+            ...(viewport?.height ? { viewport_height: viewport.height } : {}),
         };
     }
     async getConsole(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const normalizedSessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const remote = await this.invokeRemote(normalizedSessionId, "telegramMcp.browser.getConsoleRemote", {
+            ...input,
+            session_id: normalizedSessionId,
+        });
+        if (remote) {
+            return remote;
+        }
         this.ensureEnabled();
         const { sessionId, state } = await this.requireSessionState(input);
         state.lastUsedAt = new Date().toISOString();
@@ -119,6 +163,15 @@ class BrowserService {
         };
     }
     async click(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const normalizedSessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const remote = await this.invokeRemote(normalizedSessionId, "telegramMcp.browser.clickRemote", {
+            ...input,
+            session_id: normalizedSessionId,
+        });
+        if (remote) {
+            return remote;
+        }
         this.ensureEnabled();
         const { sessionId, state } = await this.requireSessionState(input);
         const locator = this.resolveLocator(state.page, input);
@@ -139,6 +192,15 @@ class BrowserService {
         };
     }
     async fill(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const normalizedSessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const remote = await this.invokeRemote(normalizedSessionId, "telegramMcp.browser.fillRemote", {
+            ...input,
+            session_id: normalizedSessionId,
+        });
+        if (remote) {
+            return remote;
+        }
         this.ensureEnabled();
         const { sessionId, state } = await this.requireSessionState(input);
         const locator = this.resolveLocator(state.page, input);
@@ -160,6 +222,15 @@ class BrowserService {
         };
     }
     async press(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const normalizedSessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const remote = await this.invokeRemote(normalizedSessionId, "telegramMcp.browser.pressRemote", {
+            ...input,
+            session_id: normalizedSessionId,
+        });
+        if (remote) {
+            return remote;
+        }
         this.ensureEnabled();
         const { sessionId, state } = await this.requireSessionState(input);
         if (input.selector || input.text) {
@@ -186,6 +257,15 @@ class BrowserService {
         };
     }
     async reload(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const normalizedSessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const remote = await this.invokeRemote(normalizedSessionId, "telegramMcp.browser.reloadRemote", {
+            ...input,
+            session_id: normalizedSessionId,
+        });
+        if (remote) {
+            return remote;
+        }
         this.ensureEnabled();
         const { sessionId, state } = await this.requireSessionState(input);
         const waitUntil = (input.wait_until ??
@@ -211,6 +291,15 @@ class BrowserService {
         };
     }
     async waitFor(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const normalizedSessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const remote = await this.invokeRemote(normalizedSessionId, "telegramMcp.browser.waitForRemote", {
+            ...input,
+            session_id: normalizedSessionId,
+        });
+        if (remote) {
+            return remote;
+        }
         this.ensureEnabled();
         const { sessionId, state } = await this.requireSessionState(input);
         const locator = this.resolveLocator(state.page, input);
@@ -234,6 +323,15 @@ class BrowserService {
         };
     }
     async waitForUrl(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const normalizedSessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const remote = await this.invokeRemote(normalizedSessionId, "telegramMcp.browser.waitForUrlRemote", {
+            ...input,
+            session_id: normalizedSessionId,
+        });
+        if (remote) {
+            return remote;
+        }
         this.ensureEnabled();
         const { sessionId, state } = await this.requireSessionState(input);
         const timeout = this.resolveTimeoutMs(input.timeout_ms);
@@ -267,6 +365,15 @@ class BrowserService {
         };
     }
     async getErrors(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const normalizedSessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const remote = await this.invokeRemote(normalizedSessionId, "telegramMcp.browser.getErrorsRemote", {
+            ...input,
+            session_id: normalizedSessionId,
+        });
+        if (remote) {
+            return remote;
+        }
         this.ensureEnabled();
         const { sessionId, state } = await this.requireSessionState(input);
         state.lastUsedAt = new Date().toISOString();
@@ -281,6 +388,15 @@ class BrowserService {
         };
     }
     async getNetworkFailures(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const normalizedSessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const remote = await this.invokeRemote(normalizedSessionId, "telegramMcp.browser.getNetworkFailuresRemote", {
+            ...input,
+            session_id: normalizedSessionId,
+        });
+        if (remote) {
+            return remote;
+        }
         this.ensureEnabled();
         const { sessionId, state } = await this.requireSessionState(input);
         state.lastUsedAt = new Date().toISOString();
@@ -300,6 +416,15 @@ class BrowserService {
         };
     }
     async clearLogs(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const normalizedSessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const remote = await this.invokeRemote(normalizedSessionId, "telegramMcp.browser.clearLogsRemote", {
+            ...input,
+            session_id: normalizedSessionId,
+        });
+        if (remote) {
+            return remote;
+        }
         this.ensureEnabled();
         const { sessionId, state } = await this.requireSessionState(input);
         const consoleMessagesCleared = state.consoleMessages.length;
@@ -318,6 +443,15 @@ class BrowserService {
         };
     }
     async getDom(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const normalizedSessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const remote = await this.invokeRemote(normalizedSessionId, "telegramMcp.browser.getDomRemote", {
+            ...input,
+            session_id: normalizedSessionId,
+        });
+        if (remote) {
+            return remote;
+        }
         this.ensureEnabled();
         const { sessionId, state } = await this.requireSessionState(input);
         const selector = input.selector?.trim() || "body";
@@ -373,6 +507,15 @@ class BrowserService {
         };
     }
     async getComputedStyle(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const normalizedSessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const remote = await this.invokeRemote(normalizedSessionId, "telegramMcp.browser.getComputedStyleRemote", {
+            ...input,
+            session_id: normalizedSessionId,
+        });
+        if (remote) {
+            return remote;
+        }
         this.ensureEnabled();
         const { sessionId, state } = await this.requireSessionState(input);
         const properties = input.properties?.length
@@ -430,6 +573,15 @@ class BrowserService {
         };
     }
     async screenshot(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const normalizedSessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const remote = await this.invokeRemote(normalizedSessionId, "telegramMcp.browser.screenshotRemote", {
+            ...input,
+            session_id: normalizedSessionId,
+        });
+        if (remote) {
+            return remote;
+        }
         this.ensureEnabled();
         const { sessionId, state, session } = await this.requireSessionState(input);
         const fileName = sanitizeScreenshotName(input.file_name);
@@ -472,18 +624,34 @@ class BrowserService {
             relativePath: storedFile.relativePath,
             source: "browser-screenshot",
             uploadedAt: new Date().toISOString(),
+            storageRef: storedFile.storageRef,
+            bucketName: storedFile.bucketName,
+            objectName: storedFile.objectName,
+            vfsNodeId: storedFile.vfsNodeId,
+            vfsPublicUrl: storedFile.vfsPublicUrl,
+            vfsParentId: storedFile.vfsParentId,
             mimeType: "image/png",
             sizeBytes: storedFile.sizeBytes,
             ...(input.caption ? { caption: input.caption } : {}),
         });
         let telegramMessageId;
         if (input.send_to_telegram === true) {
-            const binding = await this.bindingStore.getBinding(sessionId);
-            if (!binding) {
-                throw new Error("Session is not linked to Telegram, so screenshot cannot be sent there.");
+            if (this.config.distributed.mode === "client") {
+                telegramMessageId = await this.sendScreenshotToGatewayTelegramRoute({
+                    sessionId,
+                    fileName,
+                    pngBuffer,
+                    ...(input.caption ? { caption: input.caption } : {}),
+                });
+            }
+            else {
+                const binding = await this.bindingStore.getBinding(sessionId);
+                if (!binding) {
+                    throw new Error("Session is not linked to Telegram, so screenshot cannot be sent there.");
+                }
+                const sent = await this.telegramTransport.sendDocumentToChat(binding.telegramChatId, filePath, input.caption);
+                telegramMessageId = sent.messageId;
             }
-            const sent = await this.telegramTransport.sendDocumentToChat(binding.telegramChatId, filePath, input.caption);
-            telegramMessageId = sent.messageId;
         }
         return {
             session_id: sessionId,
@@ -498,14 +666,22 @@ class BrowserService {
         };
     }
     async close(input) {
-        this.ensureEnabled();
         const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
-        const state = this.sessionStates.get(resolved.sessionId);
+        const normalizedSessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const remote = await this.invokeRemote(normalizedSessionId, "telegramMcp.browser.closeRemote", {
+            ...input,
+            session_id: normalizedSessionId,
+        });
+        if (remote) {
+            return remote;
+        }
+        this.ensureEnabled();
+        const state = this.sessionStates.get(normalizedSessionId);
         if (state) {
-            await this.closeState(resolved.sessionId, state);
+            await this.closeState(normalizedSessionId, state);
         }
         return {
-            session_id: resolved.sessionId,
+            session_id: normalizedSessionId,
             closed: Boolean(state),
         };
     }
@@ -535,10 +711,13 @@ class BrowserService {
     async ensureBrowser() {
         this.browserPromise ??= (async () => {
             const playwright = await this.ensurePlaywright();
-            const launchArgs = this.config.browser.headless === false &&
-                this.config.browser.devtools === true
-                ? ["--auto-open-devtools-for-tabs"]
-                : [];
+            const launchArgs = [];
+            if (this.config.browser.headless === false) {
+                launchArgs.push("--start-maximized");
+                if (this.config.browser.devtools === true) {
+                    launchArgs.push("--auto-open-devtools-for-tabs");
+                }
+            }
             const browser = await playwright.chromium.launch({
                 headless: this.config.browser.headless,
                 slowMo: this.config.browser.slowMoMs,
@@ -562,13 +741,13 @@ class BrowserService {
         })();
         return this.browserPromise;
     }
-    async ensureSessionState(sessionId, forceNewContext) {
+    async ensureSessionState(sessionId, forceNewContext, openInput) {
         const existing = this.sessionStates.get(sessionId);
         if (existing && !forceNewContext) {
             return { state: existing, createdContext: false };
         }
         const browser = await this.ensureBrowser();
-        const context = await browser.newContext();
+        const context = await browser.newContext(this.buildContextOptions(openInput));
         const page = await context.newPage();
         const createdAt = new Date().toISOString();
         const state = {
@@ -608,6 +787,32 @@ class BrowserService {
         this.sessionStates.set(sessionId, state);
         return { state, createdContext: true };
     }
+    resolveRequestedViewport(input) {
+        const width = input?.width;
+        const height = input?.height;
+        if (!width && !height) {
+            return null;
+        }
+        if (!width || !height) {
+            throw new Error("Browser viewport requires both width and height together.");
+        }
+        return { width, height };
+    }
+    buildContextOptions(input) {
+        const requestedViewport = this.resolveRequestedViewport(input);
+        if (requestedViewport) {
+            return {
+                viewport: requestedViewport,
+                screen: requestedViewport,
+            };
+        }
+        if (this.config.browser.headless === false) {
+            return {
+                viewport: null,
+            };
+        }
+        return {};
+    }
     recordNetworkFailure(state, request, response) {
         const failure = request.failure();
         pushBounded(state.networkFailures, {
@@ -623,19 +828,94 @@ class BrowserService {
     }
     async requireSessionState(input) {
         const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
-        const state = this.sessionStates.get(resolved.sessionId);
+        const sessionId = await this.normalizeSessionIdForAccess(resolved.sessionId);
+        const state = this.sessionStates.get(sessionId);
         if (!state) {
             throw new Error("Browser session is not open. Call browser_open first for this session.");
         }
-        const session = await this.sessionStore.getSession(resolved.sessionId);
+        const session = await this.sessionStore.getSession(sessionId);
         return {
-            sessionId: resolved.sessionId,
+            sessionId,
             session,
             state,
         };
     }
     resolveWorkspaceDir(session) {
-        return session?.cwd?.trim() || process.cwd();
+        const workspaceDir = session?.cwd?.trim();
+        if (!workspaceDir) {
+            throw new Error("Workspace cwd is not registered for this browser console.");
+        }
+        return workspaceDir;
+    }
+    async invokeRemote(sessionId, actionName, input) {
+        if (this.config.distributed.mode === "client") {
+            return undefined;
+        }
+        return await this.remoteConsoleInvoker?.invokeForRelaySession(sessionId, actionName, input);
+    }
+    async normalizeSessionIdForAccess(sessionId) {
+        const trimmed = sessionId.trim();
+        if (!trimmed) {
+            return trimmed;
+        }
+        const direct = await this.sessionStore.getSession(trimmed);
+        if (direct) {
+            return trimmed;
+        }
+        const separatorIndex = trimmed.indexOf(":");
+        if (separatorIndex <= 0) {
+            return trimmed;
+        }
+        const localClientUuid = await this.maintenanceStore.getGatewayClientUuid();
+        const clientUuid = trimmed.slice(0, separatorIndex).trim();
+        const localSessionId = trimmed.slice(separatorIndex + 1).trim();
+        if (!localClientUuid || clientUuid !== localClientUuid || !localSessionId) {
+            return trimmed;
+        }
+        const localSession = await this.sessionStore.getSession(localSessionId);
+        return localSession ? localSessionId : trimmed;
+    }
+    async sendScreenshotToGatewayTelegramRoute(input) {
+        if (!this.config.distributed.gatewayPublicUrl) {
+            throw new Error("send_to_telegram on client nodes requires GATEWAY_PUBLIC_URL.");
+        }
+        const clientUuid = await (0, gatewayClientAccess_1.ensureGatewayClientUuid)({
+            maintenanceStore: this.maintenanceStore,
+            gatewayPublicUrl: this.config.distributed.gatewayPublicUrl,
+            ...(this.config.distributed.gatewayAuthToken
+                ? { gatewayAuthToken: this.config.distributed.gatewayAuthToken }
+                : {}),
+            ...(this.config.distributed.gatewayToken
+                ? { gatewayToken: this.config.distributed.gatewayToken }
+                : {}),
+            ...(this.config.project.name
+                ? { projectName: this.config.project.name }
+                : {}),
+            ...(this.config.telegram.botUsername
+                ? { botUsername: this.config.telegram.botUsername }
+                : {}),
+            ...(this.config.distributed.gatewayUserUuid
+                ? { gatewayUserUuid: this.config.distributed.gatewayUserUuid }
+                : {}),
+        });
+        const output = await (0, gatewayClientAccess_1.callGatewayJson)({
+            gatewayPublicUrl: this.config.distributed.gatewayPublicUrl,
+            ...(this.config.distributed.gatewayAuthToken
+                ? { gatewayAuthToken: this.config.distributed.gatewayAuthToken }
+                : {}),
+            endpointPath: "/transport/document",
+            body: {
+                client_uuid: clientUuid,
+                local_session_id: input.sessionId,
+                file_name: input.fileName,
+                content_base64: input.pngBuffer.toString("base64"),
+                ...(input.caption?.trim() ? { caption: input.caption.trim() } : {}),
+            },
+        });
+        if (!output.sent) {
+            throw new Error("Gateway did not confirm Telegram document delivery for the screenshot.");
+        }
+        return typeof output.message_id === "number" ? output.message_id : undefined;
     }
     ensureEnabled() {
         if (!this.config.browser.enabled) {

package/dist/services/features/telegram-mcp/src/features/collaboration/model/gatewaySessionsService.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GatewaySessionsService = void 0;
+const gatewayClientAccess_1 = require("../../distributed-client/model/gatewayClientAccess");
+class GatewaySessionsService {
+    logger;
+    maintenanceStore;
+    gatewayPublicUrl;
+    gatewayAuthToken;
+    gatewayToken;
+    gatewayUserUuid;
+    projectName;
+    botUsername;
+    constructor(logger, maintenanceStore, gatewayPublicUrl, gatewayAuthToken, gatewayToken, gatewayUserUuid, projectName, botUsername) {
+        this.logger = logger;
+        this.maintenanceStore = maintenanceStore;
+        this.gatewayPublicUrl = gatewayPublicUrl;
+        this.gatewayAuthToken = gatewayAuthToken;
+        this.gatewayToken = gatewayToken;
+        this.gatewayUserUuid = gatewayUserUuid;
+        this.projectName = projectName;
+        this.botUsername = botUsername;
+    }
+    async listKnownSessions(input = {}) {
+        if (!this.gatewayPublicUrl) {
+            throw new Error("Gateway session listing requires GATEWAY_PUBLIC_URL.");
+        }
+        await (0, gatewayClientAccess_1.ensureGatewayClientUuid)({
+            maintenanceStore: this.maintenanceStore,
+            gatewayPublicUrl: this.gatewayPublicUrl,
+            ...(this.gatewayAuthToken
+                ? { gatewayAuthToken: this.gatewayAuthToken }
+                : {}),
+            ...(this.gatewayToken ? { gatewayToken: this.gatewayToken } : {}),
+            ...(this.gatewayUserUuid ? { gatewayUserUuid: this.gatewayUserUuid } : {}),
+            ...(this.projectName ? { projectName: this.projectName } : {}),
+            ...(this.botUsername ? { botUsername: this.botUsername } : {}),
+        });
+        const response = await (0, gatewayClientAccess_1.callGatewayJson)({
+            gatewayPublicUrl: this.gatewayPublicUrl,
+            ...(this.gatewayAuthToken
+                ? { gatewayAuthToken: this.gatewayAuthToken }
+                : {}),
+            endpointPath: "/sessions/known",
+            body: {
+                ...(input.client_uuid?.trim()
+                    ? { client_uuid: input.client_uuid.trim() }
+                    : {}),
+                ...(this.gatewayToken ? { gateway_token: this.gatewayToken } : {}),
+                ...(this.gatewayUserUuid
+                    ? { owner_user_uuid: this.gatewayUserUuid }
+                    : {}),
+                ...(typeof input.connected_only === "boolean"
+                    ? { connected_only: input.connected_only }
+                    : {}),
+            },
+        });
+        const sessions = Array.isArray(response.sessions) ? response.sessions : [];
+        this.logger.info("Known gateway sessions listed", {
+            total: sessions.length,
+            connectedOnly: input.connected_only ?? false,
+        });
+        return {
+            total: typeof response.total === "number" && Number.isFinite(response.total)
+                ? response.total
+                : sessions.length,
+            sessions,
+        };
+    }
+}
+exports.GatewaySessionsService = GatewaySessionsService;

package/dist/services/features/telegram-mcp/src/features/collaboration/model/listGatewaySessionsTool.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListGatewaySessionsTool = void 0;
+const schema_1 = require("../../../entities/request/model/schema");
+function createContent(output) {
+    return [
+        {
+            type: "text",
+            text: JSON.stringify(output, null, 2),
+        },
+    ];
+}
+class ListGatewaySessionsTool {
+    gatewaySessionsService;
+    constructor(gatewaySessionsService) {
+        this.gatewaySessionsService = gatewaySessionsService;
+    }
+    register(server) {
+        server.registerTool("list_gateway_sessions", {
+            title: "List Gateway Sessions",
+            description: "List all known consoles from the configured gateway. Use this before direct cross-console communication outside a single collab project, or when you need to discover a console id once. The result includes live connected consoles and project-registered consoles known to the gateway. The canonical gateway-facing session_id is the composite value client_uuid:local_session_id from this list. Reuse that exact session_id in later gateway-routed tools instead of reconstructing it, stripping it, or re-listing sessions when the current console id is already known. target_client_uuid and target_local_session_id are also returned for direct routing APIs that need them.",
+            inputSchema: schema_1.listGatewaySessionsInputSchema,
+            outputSchema: schema_1.listGatewaySessionsOutputSchema,
+        }, async (args) => {
+            const output = await this.gatewaySessionsService.listKnownSessions(args);
+            return {
+                content: createContent(output),
+                structuredContent: output,
+            };
+        });
+    }
+}
+exports.ListGatewaySessionsTool = ListGatewaySessionsTool;