@deadragdoll/tellymcp 0.0.12 → 0.0.14

package/dist/cli.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
 const node_net_1 = __importDefault(require("node:net"));
 const dotenv_1 = require("dotenv");
 const ioredis_1 = __importDefault(require("ioredis"));
@@ -72,9 +73,12 @@ function printHelp() {
         "  tellymcp doctor [--env <file>]",
         "  tellymcp system-prune [--env <file>] --yes",
         "  tellymcp browser install",
+        "  tellymcp extension firefox",
+        "  tellymcp extension chrome",
         "  tellymcp codex-plugin install",
         "  tellymcp codex-plugin status",
         "  tellymcp mcp [--url <url>] [--bearer <token>] [--format claude|legacy]",
+        "  tellymcp oauth key",
         "  tellymcp help",
     ]);
     printSection("Examples", [
@@ -87,9 +91,12 @@ function printHelp() {
         "  tellymcp doctor --env .env.client",
         "  tellymcp system-prune --env .env.gateway --yes",
         "  tellymcp browser install",
+        "  tellymcp extension firefox",
+        "  tellymcp extension chrome ./tellymcp-chrome-attach",
         "  tellymcp codex-plugin install",
         "  tellymcp codex-plugin status",
         "  tellymcp mcp --help",
+        "  tellymcp oauth key",
     ]);
     printSection("terminal", [
         `${picocolors_1.default.green("  OK")} built-in PTY runtime`,
@@ -234,6 +241,26 @@ function printMcpHelp() {
         "  tellymcp mcp --url https://builder.undoo.ru/api/mcp --format legacy",
     ]);
 }
+function runOAuthCommand(args) {
+    const [subcommand] = args;
+    if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+        printBanner("OAuth helper", "Generate connector signing material");
+        printSection("Usage", ["  tellymcp oauth key"]);
+        printSection("Output", [
+            "  Prints a dotenv-ready TELLYMCP_OAUTH_PRIVATE_KEY_PEM value.",
+            "  Store it only on the gateway and never expose it to chat clients.",
+        ]);
+        return;
+    }
+    if (subcommand !== "key") {
+        fail("Supported OAuth subcommands: key");
+    }
+    const privateKeyPem = (0, node_crypto_1.generateKeyPairSync)("rsa", { modulusLength: 2048 })
+        .privateKey.export({ type: "pkcs8", format: "pem" })
+        .toString()
+        .replace(/\n/gu, "\\n");
+    process.stdout.write(`TELLYMCP_OAUTH_PRIVATE_KEY_PEM="${privateKeyPem}"\n`);
+}
 function printBrowserHelp() {
     printBanner("browser helper", "Manage Playwright browser binaries used by browser_* tools");
     printSection("Usage", [
@@ -245,6 +272,27 @@ function printBrowserHelp() {
         "  Avoids generic npx warnings about missing local project dependencies.",
     ]);
 }
+function printExtensionHelp() {
+    printBanner("extension helper", "Export bundled browser attach extensions into a local directory");
+    printSection("Usage", [
+        "  tellymcp extension firefox [output-directory]",
+        "  tellymcp extension ff [output-directory]",
+        "  tellymcp extension chrome [output-directory]",
+        "  tellymcp extension <firefox|ff|chrome> --out-dir <directory>",
+        "  tellymcp extension <firefox|ff|chrome> --force",
+    ]);
+    printSection("What this command does", [
+        "  Copies the packaged unpacked extension bundle out of the installed tellymcp package.",
+        "  By default exports into the current directory.",
+        "  Creates a browser-specific folder you can load into Firefox or Chrome.",
+    ]);
+    printSection("Examples", [
+        "  tellymcp extension firefox",
+        "  tellymcp extension chrome",
+        "  tellymcp extension firefox ./tellymcp-firefox-attach",
+        "  tellymcp extension chrome --out-dir ./browser-addon",
+    ]);
+}
 function printCodexPluginHelp() {
     printBanner("codex plugin", "Install or inspect the bundled Codex workflow plugin");
     printSection("Usage", [
@@ -684,6 +732,39 @@ async function runDoctor(args) {
 function hasFlag(args, flagName) {
     return args.includes(flagName);
 }
+function normalizeExtensionFlavor(rawValue) {
+    if (rawValue === "firefox" || rawValue === "ff") {
+        return "firefox";
+    }
+    if (rawValue === "chrome") {
+        return "chrome";
+    }
+    return null;
+}
+function getBundledExtensionDir(flavor) {
+    return node_path_1.default.join(packageRoot, "packages", flavor === "firefox" ? "firefox-attach-extension" : "chrome-attach-extension", "dist");
+}
+function getDefaultExtensionTargetDir(flavor) {
+    return node_path_1.default.resolve(process.cwd(), flavor === "firefox" ? "tellymcp-firefox-attach" : "tellymcp-chrome-attach");
+}
+function resolveExtensionTargetDir(args, flavor) {
+    const explicitOutDir = readFlagValue(args, "--out-dir");
+    if (explicitOutDir) {
+        return node_path_1.default.resolve(process.cwd(), explicitOutDir);
+    }
+    const positionalOutDir = args.find((value, index) => {
+        if (index === 0 || !value) {
+            return false;
+        }
+        if (value === "--force") {
+            return false;
+        }
+        return !value.startsWith("--out-dir=");
+    });
+    return positionalOutDir
+        ? node_path_1.default.resolve(process.cwd(), positionalOutDir)
+        : getDefaultExtensionTargetDir(flavor);
+}
 async function runSystemPrune(args) {
     const confirmed = hasFlag(args, "--yes");
     if (!confirmed) {
@@ -821,6 +902,52 @@ function runBrowserCommand(args) {
         process.exit(code ?? 0);
     });
 }
+function runExtensionCommand(args) {
+    const [rawFlavor] = args;
+    if (!rawFlavor || rawFlavor === "--help" || rawFlavor === "-h") {
+        printExtensionHelp();
+        return;
+    }
+    const flavor = normalizeExtensionFlavor(rawFlavor);
+    if (!flavor) {
+        fail("Supported extension targets: firefox, ff, chrome");
+    }
+    const sourceDir = getBundledExtensionDir(flavor);
+    const sourceManifestPath = node_path_1.default.join(sourceDir, "manifest.json");
+    if (!(0, node_fs_1.existsSync)(sourceManifestPath)) {
+        fail(`Missing bundled ${flavor} extension. Reinstall or republish tellymcp with packaged extension bundles.`);
+    }
+    const targetDir = resolveExtensionTargetDir(args, flavor);
+    const force = hasFlag(args, "--force");
+    if ((0, node_fs_1.existsSync)(targetDir)) {
+        if (!force) {
+            fail(`Refusing to overwrite existing directory: ${targetDir}. Re-run with --force.`);
+        }
+        (0, node_fs_1.rmSync)(targetDir, { recursive: true, force: true });
+    }
+    (0, node_fs_1.mkdirSync)(node_path_1.default.dirname(targetDir), { recursive: true });
+    (0, node_fs_1.cpSync)(sourceDir, targetDir, { recursive: true });
+    printBanner(`extension ${flavor}`, "Bundled attach extension exported");
+    printSection("result", [
+        `  source: ${sourceDir}`,
+        `  target: ${targetDir}`,
+        `  manifest: ${node_path_1.default.join(targetDir, "manifest.json")}`,
+    ]);
+    if (flavor === "firefox") {
+        printSection("next", [
+            "  1. Open about:debugging#/runtime/this-firefox",
+            "  2. Click 'Load Temporary Add-on'",
+            `  3. Choose ${node_path_1.default.join(targetDir, "manifest.json")}`,
+        ]);
+        return;
+    }
+    printSection("next", [
+        "  1. Open chrome://extensions",
+        "  2. Enable Developer mode",
+        "  3. Click 'Load unpacked'",
+        `  4. Choose ${targetDir}`,
+    ]);
+}
 function runCodexPluginCommand(args) {
     const [subcommand] = args;
     if (!subcommand || subcommand === "--help" || subcommand === "-h") {
@@ -941,8 +1068,8 @@ async function runRuntime(args) {
 }
 async function main(argv) {
     const [rawCommand, firstArg, secondArg] = argv;
-    const command = rawCommand === "init" || rawCommand === "run" || rawCommand === "help" || rawCommand === "mcp" || rawCommand === "doctor" || rawCommand === "browser" || rawCommand === "system-prune"
-        || rawCommand === "codex-plugin"
+    const command = rawCommand === "init" || rawCommand === "run" || rawCommand === "help" || rawCommand === "mcp" || rawCommand === "oauth" || rawCommand === "doctor" || rawCommand === "browser" || rawCommand === "system-prune"
+        || rawCommand === "codex-plugin" || rawCommand === "extension"
         ? rawCommand
         : "help";
     if (command === "help" || !rawCommand || rawCommand === "--help" || rawCommand === "-h") {
@@ -957,6 +1084,10 @@ async function main(argv) {
         printMcpConfig(argv.slice(1));
         return;
     }
+    if (command === "oauth") {
+        runOAuthCommand(argv.slice(1));
+        return;
+    }
     if (command === "doctor") {
         await runDoctor(argv.slice(1));
         return;
@@ -965,6 +1096,10 @@ async function main(argv) {
         runBrowserCommand(argv.slice(1));
         return;
     }
+    if (command === "extension") {
+        runExtensionCommand(argv.slice(1));
+        return;
+    }
     if (command === "codex-plugin") {
         runCodexPluginCommand(argv.slice(1));
         return;

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

@@ -21,6 +21,54 @@ const TelegramMcpBrowserService = {
                 return this.getBrowserService().getConsole(ctx.params);
             },
         },
+        listAttachedInstancesRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().listAttachedInstances(ctx.params);
+            },
+        },
+        listTabsRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                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) {
+                return this.getBrowserService().startRecording(ctx.params);
+            },
+        },
+        stopRecordingRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().stopRecording(ctx.params);
+            },
+        },
+        getRecordingStatusRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().getRecordingStatus(ctx.params);
+            },
+        },
         clickRemote: {
             params: { $$strict: false },
             async handler(ctx) {
@@ -33,6 +81,12 @@ const TelegramMcpBrowserService = {
                 return this.getBrowserService().fill(ctx.params);
             },
         },
+        injectScriptRemote: {
+            params: { $$strict: false },
+            async handler(ctx) {
+                return this.getBrowserService().injectScript(ctx.params);
+            },
+        },
         pressRemote: {
             params: { $$strict: false },
             async handler(ctx) {
@@ -119,7 +173,8 @@ const TelegramMcpBrowserService = {
         }
         const runtime = await runtimeService.waitUntilReady();
         this.logger.info("Starting telegram_mcp browser service");
-        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 } })));
+        const firefoxAttachServer = runtime.firefoxAttachServer;
+        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 } })), firefoxAttachServer);
         this.logger.info("telegram_mcp browser service is ready");
     },
     async stopped() {

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/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() {

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

@@ -5,22 +5,32 @@ const server_1 = require("./src/app/providers/mcp/server");
 const approval_service_1 = require("./approval.service");
 const browser_service_1 = require("./browser.service");
 const collaboration_service_1 = require("./collaboration.service");
+const file_content_service_1 = require("./file-content.service");
 const notify_service_1 = require("./notify.service");
 const session_context_service_1 = require("./session-context.service");
 const tools_sync_service_1 = require("./tools-sync.service");
 const xchange_service_1 = require("./xchange.service");
 const askUserTelegram_1 = require("./src/features/ask-user/model/askUserTelegram");
+const browserAttachActiveTabTool_1 = require("./src/features/browser/model/browserAttachActiveTabTool");
+const browserAttachTabTool_1 = require("./src/features/browser/model/browserAttachTabTool");
 const browserClickTool_1 = require("./src/features/browser/model/browserClickTool");
 const browserClearLogsTool_1 = require("./src/features/browser/model/browserClearLogsTool");
 const browserCloseTool_1 = require("./src/features/browser/model/browserCloseTool");
 const browserComputedStyleTool_1 = require("./src/features/browser/model/browserComputedStyleTool");
 const browserConsoleTool_1 = require("./src/features/browser/model/browserConsoleTool");
+const browserDetachTabTool_1 = require("./src/features/browser/model/browserDetachTabTool");
 const browserDomTool_1 = require("./src/features/browser/model/browserDomTool");
 const browserErrorsTool_1 = require("./src/features/browser/model/browserErrorsTool");
 const browserFillTool_1 = require("./src/features/browser/model/browserFillTool");
+const browserInjectScriptTool_1 = require("./src/features/browser/model/browserInjectScriptTool");
+const browserListAttachedInstancesTool_1 = require("./src/features/browser/model/browserListAttachedInstancesTool");
+const browserListTabsTool_1 = require("./src/features/browser/model/browserListTabsTool");
 const browserNetworkFailuresTool_1 = require("./src/features/browser/model/browserNetworkFailuresTool");
 const browserOpenTool_1 = require("./src/features/browser/model/browserOpenTool");
 const browserPressTool_1 = require("./src/features/browser/model/browserPressTool");
+const browserRecordingStartTool_1 = require("./src/features/browser/model/browserRecordingStartTool");
+const browserRecordingStatusTool_1 = require("./src/features/browser/model/browserRecordingStatusTool");
+const browserRecordingStopTool_1 = require("./src/features/browser/model/browserRecordingStopTool");
 const browserReloadTool_1 = require("./src/features/browser/model/browserReloadTool");
 const browserScreenshotTool_1 = require("./src/features/browser/model/browserScreenshotTool");
 const browserWaitForTool_1 = require("./src/features/browser/model/browserWaitForTool");
@@ -28,6 +38,8 @@ const browserWaitForUrlTool_1 = require("./src/features/browser/model/browserWai
 const sendPartnerFileTool_1 = require("./src/features/collaboration/model/sendPartnerFileTool");
 const listGatewaySessionsTool_1 = require("./src/features/collaboration/model/listGatewaySessionsTool");
 const sendPartnerNoteTool_1 = require("./src/features/collaboration/model/sendPartnerNoteTool");
+const getFileTool_1 = require("./src/features/file-content/model/getFileTool");
+const getFileListTool_1 = require("./src/features/file-content/model/getFileListTool");
 const sendFileToTelegramTool_1 = require("./src/features/notify/model/sendFileToTelegramTool");
 const notifyTelegramTool_1 = require("./src/features/notify/model/notifyTelegramTool");
 const clearSessionContextTool_1 = require("./src/features/session-context/model/clearSessionContextTool");
@@ -47,6 +59,7 @@ const TelegramMcpMcpServerService = {
         approval_service_1.TELEGRAM_MCP_APPROVAL_SERVICE_NAME,
         browser_service_1.TELEGRAM_MCP_BROWSER_SERVICE_NAME,
         collaboration_service_1.TELEGRAM_MCP_COLLABORATION_SERVICE_NAME,
+        file_content_service_1.TELEGRAM_MCP_FILE_CONTENT_SERVICE_NAME,
         tools_sync_service_1.TELEGRAM_MCP_TOOLS_SYNC_SERVICE_NAME,
         xchange_service_1.TELEGRAM_MCP_XCHANGE_SERVICE_NAME,
     ],
@@ -57,6 +70,7 @@ const TelegramMcpMcpServerService = {
             const approvalService = this.broker.getLocalService(approval_service_1.TELEGRAM_MCP_APPROVAL_SERVICE_NAME);
             const browserService = this.broker.getLocalService(browser_service_1.TELEGRAM_MCP_BROWSER_SERVICE_NAME);
             const collaborationService = this.broker.getLocalService(collaboration_service_1.TELEGRAM_MCP_COLLABORATION_SERVICE_NAME);
+            const fileContentService = this.broker.getLocalService(file_content_service_1.TELEGRAM_MCP_FILE_CONTENT_SERVICE_NAME);
             const toolsSyncService = this.broker.getLocalService(tools_sync_service_1.TELEGRAM_MCP_TOOLS_SYNC_SERVICE_NAME);
             const xchangeService = this.broker.getLocalService(xchange_service_1.TELEGRAM_MCP_XCHANGE_SERVICE_NAME);
             if (!sessionContextService ||
@@ -64,6 +78,7 @@ const TelegramMcpMcpServerService = {
                 !approvalService ||
                 !browserService ||
                 !collaborationService ||
+                !fileContentService ||
                 !toolsSyncService ||
                 !xchangeService) {
                 throw new Error("telegram_mcp MCP server dependencies are not ready");
@@ -76,10 +91,19 @@ const TelegramMcpMcpServerService = {
                 new notifyTelegramTool_1.NotifyTelegramTool(notifyService.getNotifyService()),
                 new sendFileToTelegramTool_1.SendFileToTelegramTool(notifyService.getNotifyService()),
                 new askUserTelegram_1.AskUserTelegramTool(approvalService.getApprovalOrchestrator()),
+                new browserListAttachedInstancesTool_1.BrowserListAttachedInstancesTool(browserService.getBrowserService()),
+                new browserListTabsTool_1.BrowserListTabsTool(browserService.getBrowserService()),
+                new browserAttachActiveTabTool_1.BrowserAttachActiveTabTool(browserService.getBrowserService()),
+                new browserAttachTabTool_1.BrowserAttachTabTool(browserService.getBrowserService()),
+                new browserDetachTabTool_1.BrowserDetachTabTool(browserService.getBrowserService()),
+                new browserRecordingStartTool_1.BrowserRecordingStartTool(browserService.getBrowserService()),
+                new browserRecordingStopTool_1.BrowserRecordingStopTool(browserService.getBrowserService()),
+                new browserRecordingStatusTool_1.BrowserRecordingStatusTool(browserService.getBrowserService()),
                 new browserOpenTool_1.BrowserOpenTool(browserService.getBrowserService()),
                 new browserReloadTool_1.BrowserReloadTool(browserService.getBrowserService()),
                 new browserClickTool_1.BrowserClickTool(browserService.getBrowserService()),
                 new browserFillTool_1.BrowserFillTool(browserService.getBrowserService()),
+                new browserInjectScriptTool_1.BrowserInjectScriptTool(browserService.getBrowserService()),
                 new browserPressTool_1.BrowserPressTool(browserService.getBrowserService()),
                 new browserWaitForTool_1.BrowserWaitForTool(browserService.getBrowserService()),
                 new browserWaitForUrlTool_1.BrowserWaitForUrlTool(browserService.getBrowserService()),
@@ -94,11 +118,16 @@ const TelegramMcpMcpServerService = {
                 new sendPartnerNoteTool_1.SendPartnerNoteTool(collaborationService.getCollaborationService()),
                 new listGatewaySessionsTool_1.ListGatewaySessionsTool(collaborationService.getGatewaySessionsService()),
                 new sendPartnerFileTool_1.SendPartnerFileTool(collaborationService.getSendPartnerFileService()),
+                new getFileTool_1.GetFileTool(fileContentService.getGetFileService()),
+                new getFileListTool_1.GetFileListTool(fileContentService.getGetFileService()),
                 new listXchangeRecordsTool_1.ListXchangeRecordsTool(xchangeService.getXchangeService()),
                 new getXchangeRecordTool_1.GetXchangeRecordTool(xchangeService.getXchangeService()),
                 new markXchangeRecordReadTool_1.MarkXchangeRecordReadTool(xchangeService.getXchangeService()),
                 new refreshToolsMarkdownTool_1.RefreshToolsMarkdownTool(toolsSyncService.getRefreshToolsMarkdownService()),
             ];
+            this.logger.info("telegram_mcp MCP server instance created", {
+                toolCount: tools.length,
+            });
             return (0, server_1.createMcpServer)(tools);
         },
     },
@@ -109,6 +138,7 @@ const TelegramMcpMcpServerService = {
             approval_service_1.TELEGRAM_MCP_APPROVAL_SERVICE_NAME,
             browser_service_1.TELEGRAM_MCP_BROWSER_SERVICE_NAME,
             collaboration_service_1.TELEGRAM_MCP_COLLABORATION_SERVICE_NAME,
+            file_content_service_1.TELEGRAM_MCP_FILE_CONTENT_SERVICE_NAME,
             tools_sync_service_1.TELEGRAM_MCP_TOOLS_SYNC_SERVICE_NAME,
             xchange_service_1.TELEGRAM_MCP_XCHANGE_SERVICE_NAME,
         ]);