@deadragdoll/tellymcp 0.0.9 → 0.0.11

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) {
@@ -49,35 +50,47 @@ function escapeCssAttributeValue(value) {
 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 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 shouldReset = input.reset_context === true;
         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(resolved.sessionId, shouldReset);
+        const { state, createdContext } = await this.ensureSessionState(normalizedSessionId, shouldReset);
         const waitUntil = (input.wait_until ??
             this.config.browser.waitUntil);
         await state.page.goto(targetUrl, {
@@ -89,6 +102,7 @@ class BrowserService {
         state.lastUsedAt = new Date().toISOString();
         this.logger.info("Browser page opened", {
             sessionId: resolved.sessionId,
+            normalizedSessionId,
             url: state.currentUrl,
             title: state.title,
             createdContext,
@@ -96,7 +110,7 @@ class BrowserService {
             headless: this.config.browser.headless,
         });
         return {
-            session_id: resolved.sessionId,
+            session_id: normalizedSessionId,
             opened: true,
             created_context: createdContext,
             url: state.currentUrl,
@@ -104,6 +118,15 @@ class BrowserService {
         };
     }
     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 +142,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 +171,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 +201,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 +236,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 +270,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 +302,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 +344,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 +367,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 +395,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 +422,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 +486,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 +552,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 +603,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 +645,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),
         };
     }
@@ -623,19 +778,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;