@deadragdoll/tellymcp 0.0.1

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

@@ -0,0 +1,689 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserService = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+function pushBounded(list, entry, max) {
+    list.push(entry);
+    if (list.length > max) {
+        list.splice(0, list.length - max);
+    }
+}
+function trimList(list, limit) {
+    if (!limit || limit <= 0 || limit >= list.length) {
+        return [...list];
+    }
+    return list.slice(-limit);
+}
+function sanitizeScreenshotName(fileName) {
+    const trimmed = fileName?.trim();
+    if (!trimmed) {
+        const timestamp = new Date().toISOString().replace(/[:.]/gu, "-");
+        return `browser-screenshot-${timestamp}.png`;
+    }
+    const parsed = node_path_1.default.parse(trimmed);
+    const base = parsed.name.trim() || "browser-screenshot";
+    const extension = parsed.ext.toLowerCase() === ".png" ? ".png" : ".png";
+    return `${base}${extension}`;
+}
+function buildDatedRelativePath(fileName, date = new Date()) {
+    const dateSegment = date.toISOString().slice(0, 10);
+    const timeSegment = date.toTimeString().slice(0, 8).replace(/:/gu, "-");
+    return `${dateSegment}/${timeSegment}/${fileName}`;
+}
+function isAbsoluteBrowserUrl(value) {
+    return /^https?:\/\//iu.test(value) || value.startsWith("data:");
+}
+function formatConsoleLocation(message) {
+    const location = message.location();
+    if (!location.url && !location.lineNumber && !location.columnNumber) {
+        return undefined;
+    }
+    return `${location.url || "unknown"}:${location.lineNumber ?? 0}:${location.columnNumber ?? 0}`;
+}
+function escapeCssAttributeValue(value) {
+    return value.replace(/\\/gu, "\\\\").replace(/"/gu, '\\"');
+}
+class BrowserService {
+    config;
+    sessionStore;
+    bindingStore;
+    xchangeFileMetaStore;
+    objectStore;
+    telegramTransport;
+    logger;
+    projectIdentityResolver;
+    playwrightModulePromise;
+    browserPromise;
+    sessionStates = new Map();
+    constructor(config, sessionStore, bindingStore, xchangeFileMetaStore, objectStore, telegramTransport, logger, projectIdentityResolver) {
+        this.config = config;
+        this.sessionStore = sessionStore;
+        this.bindingStore = bindingStore;
+        this.xchangeFileMetaStore = xchangeFileMetaStore;
+        this.objectStore = objectStore;
+        this.telegramTransport = telegramTransport;
+        this.logger = logger;
+        this.projectIdentityResolver = projectIdentityResolver;
+    }
+    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 targetUrl = this.resolveBrowserUrl(input.url);
+        if (shouldReset && existingState) {
+            await this.closeState(resolved.sessionId, existingState);
+        }
+        const { state, createdContext } = await this.ensureSessionState(resolved.sessionId, shouldReset);
+        const waitUntil = (input.wait_until ??
+            this.config.browser.waitUntil);
+        await state.page.goto(targetUrl, {
+            waitUntil,
+            timeout: this.config.browser.timeoutMs,
+        });
+        state.currentUrl = state.page.url();
+        state.title = await state.page.title();
+        state.lastUsedAt = new Date().toISOString();
+        this.logger.info("Browser page opened", {
+            sessionId: resolved.sessionId,
+            url: state.currentUrl,
+            title: state.title,
+            createdContext,
+            waitUntil,
+            headless: this.config.browser.headless,
+        });
+        return {
+            session_id: resolved.sessionId,
+            opened: true,
+            created_context: createdContext,
+            url: state.currentUrl,
+            ...(state.title ? { title: state.title } : {}),
+        };
+    }
+    async getConsole(input) {
+        this.ensureEnabled();
+        const { sessionId, state } = await this.requireSessionState(input);
+        state.lastUsedAt = new Date().toISOString();
+        return {
+            session_id: sessionId,
+            total: state.consoleMessages.length,
+            messages: trimList(state.consoleMessages, input.limit).map((message) => ({
+                type: message.type,
+                text: message.text,
+                ...(message.location ? { location: message.location } : {}),
+                timestamp: message.timestamp,
+            })),
+        };
+    }
+    async click(input) {
+        this.ensureEnabled();
+        const { sessionId, state } = await this.requireSessionState(input);
+        const locator = this.resolveLocator(state.page, input);
+        await locator.click({
+            timeout: this.resolveTimeoutMs(input.timeout_ms),
+        });
+        state.currentUrl = state.page.url();
+        state.title = await state.page.title().catch(() => state.title);
+        state.lastUsedAt = new Date().toISOString();
+        return {
+            session_id: sessionId,
+            clicked: true,
+            ...(input.ai_tag ? { ai_tag: input.ai_tag } : {}),
+            ...(input.selector ? { selector: input.selector } : {}),
+            ...(input.text ? { text: input.text } : {}),
+            url: state.currentUrl,
+            ...(state.title ? { title: state.title } : {}),
+        };
+    }
+    async fill(input) {
+        this.ensureEnabled();
+        const { sessionId, state } = await this.requireSessionState(input);
+        const locator = this.resolveLocator(state.page, input);
+        await locator.fill(input.value, {
+            timeout: this.resolveTimeoutMs(input.timeout_ms),
+        });
+        state.currentUrl = state.page.url();
+        state.title = await state.page.title().catch(() => state.title);
+        state.lastUsedAt = new Date().toISOString();
+        return {
+            session_id: sessionId,
+            filled: true,
+            ...(input.ai_tag ? { ai_tag: input.ai_tag } : {}),
+            ...(input.selector ? { selector: input.selector } : {}),
+            ...(input.text ? { text: input.text } : {}),
+            value_length: input.value.length,
+            url: state.currentUrl,
+            ...(state.title ? { title: state.title } : {}),
+        };
+    }
+    async press(input) {
+        this.ensureEnabled();
+        const { sessionId, state } = await this.requireSessionState(input);
+        if (input.selector || input.text) {
+            const locator = this.resolveLocator(state.page, input);
+            await locator.press(input.key, {
+                timeout: this.resolveTimeoutMs(input.timeout_ms),
+            });
+        }
+        else {
+            await state.page.keyboard.press(input.key);
+        }
+        state.currentUrl = state.page.url();
+        state.title = await state.page.title().catch(() => state.title);
+        state.lastUsedAt = new Date().toISOString();
+        return {
+            session_id: sessionId,
+            pressed: true,
+            key: input.key,
+            ...(input.ai_tag ? { ai_tag: input.ai_tag } : {}),
+            ...(input.selector ? { selector: input.selector } : {}),
+            ...(input.text ? { text: input.text } : {}),
+            url: state.currentUrl,
+            ...(state.title ? { title: state.title } : {}),
+        };
+    }
+    async reload(input) {
+        this.ensureEnabled();
+        const { sessionId, state } = await this.requireSessionState(input);
+        const waitUntil = (input.wait_until ??
+            this.config.browser.waitUntil);
+        await state.page.reload({
+            waitUntil,
+            timeout: this.config.browser.timeoutMs,
+        });
+        state.currentUrl = state.page.url();
+        state.title = await state.page.title().catch(() => state.title);
+        state.lastUsedAt = new Date().toISOString();
+        this.logger.info("Browser page reloaded", {
+            sessionId,
+            url: state.currentUrl,
+            title: state.title,
+            waitUntil,
+        });
+        return {
+            session_id: sessionId,
+            reloaded: true,
+            url: state.currentUrl,
+            ...(state.title ? { title: state.title } : {}),
+        };
+    }
+    async waitFor(input) {
+        this.ensureEnabled();
+        const { sessionId, state } = await this.requireSessionState(input);
+        const locator = this.resolveLocator(state.page, input);
+        const waitState = input.state ?? "visible";
+        await locator.waitFor({
+            state: waitState,
+            timeout: this.resolveTimeoutMs(input.timeout_ms),
+        });
+        state.currentUrl = state.page.url();
+        state.title = await state.page.title().catch(() => state.title);
+        state.lastUsedAt = new Date().toISOString();
+        return {
+            session_id: sessionId,
+            waited: true,
+            state: waitState,
+            ...(input.ai_tag ? { ai_tag: input.ai_tag } : {}),
+            ...(input.selector ? { selector: input.selector } : {}),
+            ...(input.text ? { text: input.text } : {}),
+            url: state.currentUrl,
+            ...(state.title ? { title: state.title } : {}),
+        };
+    }
+    async waitForUrl(input) {
+        this.ensureEnabled();
+        const { sessionId, state } = await this.requireSessionState(input);
+        const timeout = this.resolveTimeoutMs(input.timeout_ms);
+        if (input.url?.trim()) {
+            await state.page.waitForURL(input.url.trim(), {
+                timeout,
+            });
+        }
+        else if (input.url_contains?.trim()) {
+            const expected = input.url_contains.trim();
+            await state.page.waitForURL((value) => value.toString().includes(expected), {
+                timeout,
+            });
+        }
+        else {
+            throw new Error("Browser URL target is missing. Provide url or url_contains.");
+        }
+        state.currentUrl = state.page.url();
+        state.title = await state.page.title().catch(() => state.title);
+        state.lastUsedAt = new Date().toISOString();
+        return {
+            session_id: sessionId,
+            waited: true,
+            matched: input.url?.trim() ? "url" : "url_contains",
+            ...(input.url?.trim() ? { url: input.url.trim() } : {}),
+            ...(input.url_contains?.trim()
+                ? { url_contains: input.url_contains.trim() }
+                : {}),
+            current_url: state.currentUrl,
+            ...(state.title ? { title: state.title } : {}),
+        };
+    }
+    async getErrors(input) {
+        this.ensureEnabled();
+        const { sessionId, state } = await this.requireSessionState(input);
+        state.lastUsedAt = new Date().toISOString();
+        return {
+            session_id: sessionId,
+            total: state.pageErrors.length,
+            errors: trimList(state.pageErrors, input.limit).map((error) => ({
+                message: error.message,
+                ...(error.stack ? { stack: error.stack } : {}),
+                timestamp: error.timestamp,
+            })),
+        };
+    }
+    async getNetworkFailures(input) {
+        this.ensureEnabled();
+        const { sessionId, state } = await this.requireSessionState(input);
+        state.lastUsedAt = new Date().toISOString();
+        return {
+            session_id: sessionId,
+            total: state.networkFailures.length,
+            failures: trimList(state.networkFailures, input.limit).map((failure) => ({
+                url: failure.url,
+                method: failure.method,
+                ...(typeof failure.status === "number" ? { status: failure.status } : {}),
+                ...(failure.errorText ? { error_text: failure.errorText } : {}),
+                ...(failure.resourceType
+                    ? { resource_type: failure.resourceType }
+                    : {}),
+                timestamp: failure.timestamp,
+            })),
+        };
+    }
+    async clearLogs(input) {
+        this.ensureEnabled();
+        const { sessionId, state } = await this.requireSessionState(input);
+        const consoleMessagesCleared = state.consoleMessages.length;
+        const pageErrorsCleared = state.pageErrors.length;
+        const networkFailuresCleared = state.networkFailures.length;
+        state.consoleMessages = [];
+        state.pageErrors = [];
+        state.networkFailures = [];
+        state.lastUsedAt = new Date().toISOString();
+        return {
+            session_id: sessionId,
+            cleared: true,
+            console_messages_cleared: consoleMessagesCleared,
+            page_errors_cleared: pageErrorsCleared,
+            network_failures_cleared: networkFailuresCleared,
+        };
+    }
+    async getDom(input) {
+        this.ensureEnabled();
+        const { sessionId, state } = await this.requireSessionState(input);
+        const selector = input.selector?.trim() || "body";
+        const snapshot = await state.page
+            .locator(selector)
+            .first()
+            .evaluate((element, payload) => {
+            const htmlRequested = payload.includeHtml;
+            const textRequested = payload.includeText;
+            const computed = globalThis.getComputedStyle(element);
+            const attributes = Object.fromEntries(Array.from(element.attributes).map((attribute) => [
+                attribute.name,
+                attribute.value,
+            ]));
+            return {
+                found: true,
+                ...(htmlRequested
+                    ? { outerHtml: element.outerHTML }
+                    : {}),
+                ...(textRequested
+                    ? {
+                        textContent: element.textContent?.trim() ??
+                            "",
+                    }
+                    : {}),
+                visible: computed.display !== "none" &&
+                    computed.visibility !== "hidden" &&
+                    computed.opacity !== "0",
+                attributes,
+            };
+        }, {
+            includeHtml: input.include_html !== false,
+            includeText: input.include_text !== false,
+        })
+            .catch(() => ({ found: false }));
+        state.lastUsedAt = new Date().toISOString();
+        state.currentUrl = state.page.url();
+        state.title = await state.page.title().catch(() => state.title);
+        return {
+            session_id: sessionId,
+            selector,
+            found: snapshot.found,
+            ...(state.currentUrl ? { url: state.currentUrl } : {}),
+            ...(state.title ? { title: state.title } : {}),
+            ...(snapshot.outerHtml ? { outer_html: snapshot.outerHtml } : {}),
+            ...(typeof snapshot.textContent === "string"
+                ? { text_content: snapshot.textContent }
+                : {}),
+            ...(typeof snapshot.visible === "boolean"
+                ? { visible: snapshot.visible }
+                : {}),
+            ...(snapshot.attributes ? { attributes: snapshot.attributes } : {}),
+        };
+    }
+    async getComputedStyle(input) {
+        this.ensureEnabled();
+        const { sessionId, state } = await this.requireSessionState(input);
+        const properties = input.properties?.length
+            ? input.properties
+            : [
+                "display",
+                "position",
+                "visibility",
+                "opacity",
+                "color",
+                "background-color",
+                "font-size",
+                "z-index",
+                "overflow",
+            ];
+        const snapshot = await state.page
+            .locator(input.selector)
+            .first()
+            .evaluate((element, requestedProperties) => {
+            const computed = globalThis.getComputedStyle(element);
+            const rect = element.getBoundingClientRect();
+            const styles = Object.fromEntries(requestedProperties.map((property) => [
+                property,
+                computed.getPropertyValue(property),
+            ]));
+            return {
+                found: true,
+                visible: computed.display !== "none" &&
+                    computed.visibility !== "hidden" &&
+                    computed.opacity !== "0",
+                styles,
+                box: {
+                    x: rect.x,
+                    y: rect.y,
+                    width: rect.width,
+                    height: rect.height,
+                },
+            };
+        }, properties)
+            .catch(() => ({ found: false }));
+        state.lastUsedAt = new Date().toISOString();
+        state.currentUrl = state.page.url();
+        state.title = await state.page.title().catch(() => state.title);
+        return {
+            session_id: sessionId,
+            selector: input.selector,
+            found: snapshot.found,
+            ...(state.currentUrl ? { url: state.currentUrl } : {}),
+            ...(state.title ? { title: state.title } : {}),
+            ...(typeof snapshot.visible === "boolean"
+                ? { visible: snapshot.visible }
+                : {}),
+            ...(snapshot.styles ? { styles: snapshot.styles } : {}),
+            ...(snapshot.box ? { box: snapshot.box } : {}),
+        };
+    }
+    async screenshot(input) {
+        this.ensureEnabled();
+        const { sessionId, state, session } = await this.requireSessionState(input);
+        const fileName = sanitizeScreenshotName(input.file_name);
+        const pngBuffer = input.selector?.trim()
+            ? await state.page
+                .locator(input.selector)
+                .first()
+                .screenshot({
+                type: "png",
+                timeout: this.config.browser.timeoutMs,
+            })
+            : await state.page.screenshot({
+                type: "png",
+                fullPage: input.full_page === true,
+                timeout: this.config.browser.timeoutMs,
+            });
+        const workspaceDir = this.objectStore.resolveWorkspaceDir(session);
+        const exchangeDir = node_path_1.default.resolve(workspaceDir, this.config.exchange.dir);
+        const storedFile = await this.objectStore.storeFile({
+            session,
+            sessionId,
+            source: "browser-screenshot",
+            relativePath: buildDatedRelativePath(fileName),
+            content: pngBuffer,
+            mimeType: "image/png",
+        });
+        const filePath = storedFile.filePath;
+        state.lastUsedAt = new Date().toISOString();
+        state.currentUrl = state.page.url();
+        state.title = await state.page.title().catch(() => state.title);
+        this.logger.info("Browser screenshot captured", {
+            sessionId,
+            filePath,
+            selector: input.selector,
+            fullPage: input.full_page === true,
+        });
+        await this.xchangeFileMetaStore.setXchangeFileMeta({
+            sessionId,
+            filePath,
+            relativePath: storedFile.relativePath,
+            source: "browser-screenshot",
+            uploadedAt: new Date().toISOString(),
+            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.");
+            }
+            const sent = await this.telegramTransport.sendDocumentToChat(binding.telegramChatId, filePath, input.caption);
+            telegramMessageId = sent.messageId;
+        }
+        return {
+            session_id: sessionId,
+            file_path: filePath,
+            workspace_dir: workspaceDir,
+            exchange_dir: exchangeDir,
+            ...(typeof telegramMessageId === "number"
+                ? { telegram_message_id: telegramMessageId }
+                : {}),
+            ...(state.currentUrl ? { url: state.currentUrl } : {}),
+            ...(state.title ? { title: state.title } : {}),
+        };
+    }
+    async close(input) {
+        this.ensureEnabled();
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const state = this.sessionStates.get(resolved.sessionId);
+        if (state) {
+            await this.closeState(resolved.sessionId, state);
+        }
+        return {
+            session_id: resolved.sessionId,
+            closed: Boolean(state),
+        };
+    }
+    async shutdown() {
+        for (const [sessionId, state] of this.sessionStates.entries()) {
+            await this.closeState(sessionId, state);
+        }
+        if (this.browserPromise) {
+            try {
+                const browser = await this.browserPromise;
+                await browser.close();
+            }
+            catch (error) {
+                this.logger.warn("Browser shutdown failed", {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            finally {
+                this.browserPromise = undefined;
+            }
+        }
+    }
+    async ensurePlaywright() {
+        this.playwrightModulePromise ??= import("playwright");
+        return this.playwrightModulePromise;
+    }
+    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 browser = await playwright.chromium.launch({
+                headless: this.config.browser.headless,
+                slowMo: this.config.browser.slowMoMs,
+                ...(launchArgs.length ? { args: launchArgs } : {}),
+                ...(this.config.browser.executablePath
+                    ? { executablePath: this.config.browser.executablePath }
+                    : {}),
+                ...(this.config.browser.channel
+                    ? { channel: this.config.browser.channel }
+                    : {}),
+            });
+            this.logger.info("Browser runtime launched", {
+                headless: this.config.browser.headless,
+                devtools: this.config.browser.headless === false &&
+                    this.config.browser.devtools === true,
+                slowMoMs: this.config.browser.slowMoMs,
+                channel: this.config.browser.channel,
+                executablePath: this.config.browser.executablePath,
+            });
+            return browser;
+        })();
+        return this.browserPromise;
+    }
+    async ensureSessionState(sessionId, forceNewContext) {
+        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 page = await context.newPage();
+        const createdAt = new Date().toISOString();
+        const state = {
+            context,
+            page,
+            createdAt,
+            lastUsedAt: createdAt,
+            consoleMessages: [],
+            pageErrors: [],
+            networkFailures: [],
+        };
+        page.on("console", (message) => {
+            pushBounded(state.consoleMessages, {
+                type: message.type(),
+                text: message.text(),
+                ...(formatConsoleLocation(message)
+                    ? { location: formatConsoleLocation(message) }
+                    : {}),
+                timestamp: new Date().toISOString(),
+            }, this.config.browser.maxEvents);
+        });
+        page.on("pageerror", (error) => {
+            pushBounded(state.pageErrors, {
+                message: error.message,
+                ...(error.stack ? { stack: error.stack } : {}),
+                timestamp: new Date().toISOString(),
+            }, this.config.browser.maxEvents);
+        });
+        page.on("requestfailed", (request) => {
+            this.recordNetworkFailure(state, request, undefined);
+        });
+        page.on("response", (response) => {
+            if (response.status() >= 400) {
+                this.recordNetworkFailure(state, response.request(), response);
+            }
+        });
+        this.sessionStates.set(sessionId, state);
+        return { state, createdContext: true };
+    }
+    recordNetworkFailure(state, request, response) {
+        const failure = request.failure();
+        pushBounded(state.networkFailures, {
+            url: request.url(),
+            method: request.method(),
+            ...(typeof response?.status() === "number"
+                ? { status: response.status() }
+                : {}),
+            ...(failure?.errorText ? { errorText: failure.errorText } : {}),
+            resourceType: request.resourceType(),
+            timestamp: new Date().toISOString(),
+        }, this.config.browser.maxEvents);
+    }
+    async requireSessionState(input) {
+        const resolved = this.projectIdentityResolver.resolveSessionDefaults(input);
+        const state = this.sessionStates.get(resolved.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);
+        return {
+            sessionId: resolved.sessionId,
+            session,
+            state,
+        };
+    }
+    resolveWorkspaceDir(session) {
+        return session?.cwd?.trim() || process.cwd();
+    }
+    ensureEnabled() {
+        if (!this.config.browser.enabled) {
+            throw new Error("Browser tools are disabled. Enable them with BROWSER_ENABLED=true.");
+        }
+    }
+    resolveLocator(page, input) {
+        if (input.ai_tag?.trim()) {
+            const aiTag = escapeCssAttributeValue(input.ai_tag.trim());
+            return page
+                .locator(`[data-drive-tag="${aiTag}"], [ai-tag="${aiTag}"]`)
+                .first();
+        }
+        if (input.selector?.trim()) {
+            return page.locator(input.selector.trim()).first();
+        }
+        if (input.text?.trim()) {
+            return page.getByText(input.text.trim(), {
+                exact: input.exact === true,
+            }).first();
+        }
+        throw new Error("Browser target is missing. Provide ai_tag, selector, or text.");
+    }
+    resolveTimeoutMs(timeoutMs) {
+        return timeoutMs && timeoutMs > 0
+            ? timeoutMs
+            : this.config.browser.timeoutMs;
+    }
+    resolveBrowserUrl(inputUrl) {
+        const trimmed = inputUrl.trim();
+        if (isAbsoluteBrowserUrl(trimmed)) {
+            return trimmed;
+        }
+        if (!this.config.browser.address) {
+            throw new Error("BROWSER_ADDRESS is not configured, so browser_open requires an absolute URL.");
+        }
+        return new URL(trimmed, this.config.browser.address).toString();
+    }
+    async closeState(sessionId, state) {
+        this.sessionStates.delete(sessionId);
+        await state.context.close();
+        this.logger.info("Browser session context closed", {
+            sessionId,
+            currentUrl: state.currentUrl,
+            title: state.title,
+            createdAt: state.createdAt,
+            lastUsedAt: state.lastUsedAt,
+        });
+    }
+}
+exports.BrowserService = BrowserService;