@n8n/mcp-browser 0.1.0-rc1

package/dist/adapters/playwright.js

@@ -0,0 +1,684 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaywrightAdapter = void 0;
+const node_child_process_1 = require("node:child_process");
+const playwright_core_1 = require("playwright-core");
+const cdp_relay_1 = require("../cdp-relay");
+const errors_1 = require("../errors");
+const logger_1 = require("../logger");
+const utils_1 = require("../utils");
+const log = (0, logger_1.createLogger)('playwright');
+const BROWSER_BRIDGE_EXTENSION_ID = 'agklaocphkdbepcjccjpnbcglmpebhpo';
+class PlaywrightAdapter {
+    constructor(config) {
+        this.name = 'playwright';
+        this.pageStates = new Map();
+        this.resolvedConfig = config;
+    }
+    async launch(config) {
+        log.debug('launch: browser =', config.browser);
+        this.relay = new cdp_relay_1.CDPRelayServer();
+        const port = await this.relay.listen();
+        const extensionEndpoint = this.relay.extensionEndpoint(port);
+        const connectUrl = `chrome-extension://${BROWSER_BRIDGE_EXTENSION_ID}/dist/connect.html` +
+            `?mcpRelayUrl=${encodeURIComponent(extensionEndpoint)}`;
+        const browserInfo = this.resolvedConfig.browsers.get(config.browser);
+        const chromePath = browserInfo?.executablePath;
+        if (!chromePath) {
+            throw new errors_1.BrowserExecutableNotFoundError(config.browser);
+        }
+        log.debug('launching browser:', chromePath);
+        log.debug('connect URL:', connectUrl);
+        await new Promise((resolve, reject) => {
+            const child = (0, node_child_process_1.execFile)(chromePath, [connectUrl]);
+            const earlyFailTimer = setTimeout(() => resolve(), 2_000);
+            child.on('error', (spawnError) => {
+                clearTimeout(earlyFailTimer);
+                log.error('browser spawn error:', spawnError.message);
+                reject(new errors_1.BrowserExecutableNotFoundError(`${config.browser} (${spawnError.message})`));
+            });
+        });
+        log.debug('waiting for extension...');
+        await this.relay.waitForExtension({ browserWasLaunched: true });
+        const cdpEndpoint = this.relay.cdpEndpoint(port);
+        log.debug('connecting Playwright over CDP:', cdpEndpoint);
+        this.browser = await playwright_core_1.chromium.connectOverCDP(cdpEndpoint);
+        const contexts = this.browser.contexts();
+        log.debug('browser contexts:', contexts.length);
+        this.context = contexts[0] ?? (await this.browser.newContext());
+        this.context.on('page', (page) => {
+            if (this.pendingActivation) {
+                const { id, resolve } = this.pendingActivation;
+                this.pendingActivation = undefined;
+                log.debug('page event: consumed pendingActivation, id =', id);
+                if (!this.pageStates.has(id)) {
+                    this.trackPage(page, id);
+                }
+                resolve(page);
+                return;
+            }
+            log.debug('page event: no pendingActivation, assigning random id');
+            if (!this.findPageState(page)) {
+                this.trackPage(page);
+            }
+        });
+        log.debug('launch complete, context ready for lazy activation');
+    }
+    async close() {
+        try {
+            if (this.context)
+                await this.context.close();
+        }
+        catch {
+        }
+        try {
+            if (this.browser)
+                await this.browser.close();
+        }
+        catch {
+        }
+        if (this.relay) {
+            this.relay.stop();
+            this.relay = undefined;
+        }
+        this.pageStates.clear();
+    }
+    async newPage(url) {
+        log.debug('newPage: creating page, url =', url ?? '(none)');
+        const page = await this.requireContext().newPage();
+        const tabId = this.relay?.getLastCreatedTabId();
+        log.debug('newPage: relay tabId =', tabId);
+        const state = this.findPageState(page) ?? this.trackPage(page, tabId);
+        if (url) {
+            await page.goto(url, { waitUntil: 'load' });
+            state.info.title = await page.title();
+            state.info.url = page.url();
+        }
+        return { ...state.info };
+    }
+    async closePage(pageId) {
+        this.pageStates.delete(pageId);
+        if (this.relay) {
+            await this.relay.closeTab(pageId);
+        }
+    }
+    async focusPage(pageId) {
+        const state = await this.ensurePage(pageId);
+        await state.page.bringToFront();
+    }
+    async listPages() {
+        const result = [];
+        for (const state of this.pageStates.values()) {
+            try {
+                state.info.title = await state.page.title();
+                state.info.url = state.page.url();
+            }
+            catch {
+            }
+            result.push({ ...state.info });
+        }
+        return result;
+    }
+    async listTabs() {
+        if (this.relay) {
+            const tabs = (await this.relay.listTabs()).map((t) => ({
+                id: t.id,
+                title: t.title,
+                url: t.url,
+            }));
+            log.debug('listTabs: relay returned', tabs.length, 'tabs');
+            return tabs;
+        }
+        const pages = await this.listPages();
+        log.debug('listTabs: fallback to listPages, returned', pages.length, 'pages');
+        return pages;
+    }
+    listTabSessionIds() {
+        return Array.from(this.pageStates.keys());
+    }
+    async listTabIds() {
+        if (this.relay) {
+            const tabs = await this.relay.listTabs();
+            log.debug(`listTabIds: relay returned ${tabs.length} tab(s)`);
+            return tabs.map((t) => t.id);
+        }
+        const ids = this.listTabSessionIds();
+        log.debug(`listTabIds: fallback to pageStates, ${ids.length} page(s)`);
+        return ids;
+    }
+    async navigate(pageId, url, waitUntil = 'load') {
+        const { page } = await this.ensurePage(pageId);
+        const response = await page.goto(url, { waitUntil });
+        return {
+            title: await page.title(),
+            url: page.url(),
+            status: response?.status() ?? 0,
+        };
+    }
+    async back(pageId) {
+        const { page } = await this.ensurePage(pageId);
+        await page.goBack({ waitUntil: 'load' });
+        return { title: await page.title(), url: page.url(), status: 0 };
+    }
+    async forward(pageId) {
+        const { page } = await this.ensurePage(pageId);
+        await page.goForward({ waitUntil: 'load' });
+        return { title: await page.title(), url: page.url(), status: 0 };
+    }
+    async reload(pageId, waitUntil = 'load') {
+        const { page } = await this.ensurePage(pageId);
+        const response = await page.reload({ waitUntil });
+        return {
+            title: await page.title(),
+            url: page.url(),
+            status: response?.status() ?? 0,
+        };
+    }
+    async click(pageId, target, options) {
+        await this.ensurePage(pageId);
+        const locator = await this.resolveLocator(pageId, target);
+        await locator.click({
+            button: options?.button,
+            clickCount: options?.clickCount,
+            modifiers: options?.modifiers,
+        });
+    }
+    async type(pageId, target, text, options) {
+        await this.ensurePage(pageId);
+        const locator = await this.resolveLocator(pageId, target);
+        if (options?.clear) {
+            await locator.clear();
+        }
+        await locator.pressSequentially(text, { delay: options?.delay });
+        if (options?.submit) {
+            await locator.press('Enter');
+        }
+    }
+    async select(pageId, target, values) {
+        await this.ensurePage(pageId);
+        const locator = await this.resolveLocator(pageId, target);
+        return await locator.selectOption(values);
+    }
+    async hover(pageId, target) {
+        await this.ensurePage(pageId);
+        const locator = await this.resolveLocator(pageId, target);
+        await locator.hover();
+    }
+    async press(pageId, keys) {
+        const { page } = await this.ensurePage(pageId);
+        await page.keyboard.press(keys);
+    }
+    async drag(pageId, from, to) {
+        await this.ensurePage(pageId);
+        const fromLocator = await this.resolveLocator(pageId, from);
+        const toLocator = await this.resolveLocator(pageId, to);
+        await fromLocator.dragTo(toLocator);
+    }
+    async scroll(pageId, target, options) {
+        const { page } = await this.ensurePage(pageId);
+        if (target) {
+            const locator = await this.resolveLocator(pageId, target);
+            await locator.scrollIntoViewIfNeeded();
+        }
+        else {
+            const amount = options?.amount ?? 500;
+            const delta = options?.direction === 'up' ? -amount : amount;
+            await page.mouse.wheel(0, delta);
+        }
+    }
+    async upload(pageId, target, files) {
+        const state = await this.ensurePage(pageId);
+        if (state.pendingFileChooser) {
+            await state.pendingFileChooser.setFiles(files);
+            state.pendingFileChooser = undefined;
+            return;
+        }
+        if (!target) {
+            throw new Error('No file chooser pending and no element target provided');
+        }
+        const locator = await this.resolveLocator(pageId, target);
+        await locator.setInputFiles(files);
+    }
+    async dialog(pageId, action, text) {
+        const state = await this.ensurePage(pageId);
+        if (state.pendingDialog) {
+            const dialogType = state.pendingDialog.type();
+            if (action === 'accept') {
+                await state.pendingDialog.accept(text);
+            }
+            else {
+                await state.pendingDialog.dismiss();
+            }
+            state.pendingDialog = undefined;
+            return dialogType;
+        }
+        return await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error('No dialog appeared within 10 seconds'));
+            }, 10_000);
+            state.page.once('dialog', async (dlg) => {
+                clearTimeout(timeout);
+                try {
+                    const dialogType = dlg.type();
+                    if (action === 'accept') {
+                        await dlg.accept(text);
+                    }
+                    else {
+                        await dlg.dismiss();
+                    }
+                    resolve(dialogType);
+                }
+                catch (error) {
+                    reject((0, utils_1.toError)(error));
+                }
+            });
+        });
+    }
+    async screenshot(pageId, target, options) {
+        const { page } = await this.ensurePage(pageId);
+        let buffer;
+        if (target) {
+            const locator = await this.resolveLocator(pageId, target);
+            buffer = await locator.screenshot({ type: 'png' });
+        }
+        else {
+            buffer = await page.screenshot({
+                type: 'png',
+                fullPage: options?.fullPage,
+            });
+        }
+        return buffer.toString('base64');
+    }
+    async snapshot(pageId, target) {
+        const { page } = await this.ensurePage(pageId);
+        let yaml;
+        if (target) {
+            const locator = await this.resolveLocator(pageId, target);
+            yaml = await locator.ariaSnapshot();
+        }
+        else {
+            const privatePage = page;
+            const result = await privatePage._snapshotForAI({ track: 'response' });
+            yaml = result.full;
+        }
+        if (!yaml) {
+            return { tree: '(empty page)', refCount: 0 };
+        }
+        const refMatches = yaml.match(/\[ref=e\d+\]/g);
+        const refCount = refMatches?.length ?? 0;
+        return { tree: yaml, refCount };
+    }
+    async getText(pageId, target) {
+        const { page } = await this.ensurePage(pageId);
+        if (target) {
+            const locator = await this.resolveLocator(pageId, target);
+            return await locator.innerText();
+        }
+        return await page.innerText('body');
+    }
+    async evaluate(pageId, script) {
+        const { page } = await this.ensurePage(pageId);
+        return await page.evaluate(script);
+    }
+    async getConsole(pageId, level, clear) {
+        const state = await this.ensurePage(pageId);
+        let entries = [
+            ...state.consoleBuffer,
+            ...state.errorBuffer.map((e) => ({
+                level: 'error',
+                text: e.stack ? `${e.message}\n${e.stack}` : e.message,
+                timestamp: e.timestamp,
+            })),
+        ];
+        entries.sort((a, b) => a.timestamp - b.timestamp);
+        if (level) {
+            entries = entries.filter((e) => e.level === level);
+        }
+        if (clear) {
+            state.consoleBuffer = [];
+            state.errorBuffer = [];
+        }
+        return entries;
+    }
+    getConsoleSummary(pageId) {
+        const state = this.pageStates.get(pageId);
+        if (!state)
+            return { errors: 0, warnings: 0 };
+        const consoleErrors = state.consoleBuffer.filter((e) => e.level === 'error').length;
+        const pageErrors = state.errorBuffer.length;
+        const warnings = state.consoleBuffer.filter((e) => e.level === 'warning').length;
+        return { errors: consoleErrors + pageErrors, warnings };
+    }
+    async pdf(pageId, options) {
+        const { page } = await this.ensurePage(pageId);
+        const buffer = await page.pdf({
+            format: options?.format ?? 'A4',
+            landscape: options?.landscape,
+        });
+        const data = buffer.toString('base64');
+        return { data, pages: 1 };
+    }
+    async getNetwork(pageId, filter, clear) {
+        const state = await this.ensurePage(pageId);
+        let entries = [...state.networkBuffer];
+        if (filter) {
+            const pattern = this.globToRegex(filter);
+            entries = entries.filter((e) => pattern.test(e.url));
+        }
+        if (clear) {
+            state.networkBuffer = [];
+        }
+        return entries;
+    }
+    async wait(pageId, options) {
+        const { page } = await this.ensurePage(pageId);
+        const start = Date.now();
+        const timeout = options.timeoutMs ?? 30_000;
+        const promises = [];
+        if (options.selector) {
+            promises.push(page.waitForSelector(options.selector, { timeout }));
+        }
+        if (options.url) {
+            promises.push(page.waitForURL(options.url, { timeout }));
+        }
+        if (options.loadState) {
+            promises.push(page.waitForLoadState(options.loadState, { timeout }));
+        }
+        if (options.predicate) {
+            promises.push(page.waitForFunction(options.predicate, undefined, { timeout }));
+        }
+        if (options.text) {
+            promises.push(page.waitForSelector(`text=${options.text}`, { timeout }));
+        }
+        if (promises.length === 0) {
+            await page.waitForTimeout(100);
+        }
+        else {
+            await Promise.all(promises);
+        }
+        return Date.now() - start;
+    }
+    async getCookies(pageId, url) {
+        await this.ensurePage(pageId);
+        const context = this.requireContext();
+        const cookies = url ? await context.cookies(url) : await context.cookies();
+        return cookies.map((c) => ({
+            name: c.name,
+            value: c.value,
+            domain: c.domain,
+            path: c.path,
+            expires: c.expires,
+            httpOnly: c.httpOnly,
+            secure: c.secure,
+            sameSite: c.sameSite,
+        }));
+    }
+    async setCookies(pageId, cookies) {
+        await this.ensurePage(pageId);
+        const context = this.requireContext();
+        await context.addCookies(cookies.map((c) => ({
+            name: c.name,
+            value: c.value,
+            domain: c.domain,
+            path: c.path ?? '/',
+            expires: c.expires,
+            httpOnly: c.httpOnly,
+            secure: c.secure,
+            sameSite: c.sameSite,
+        })));
+    }
+    async clearCookies(pageId) {
+        await this.ensurePage(pageId);
+        await this.requireContext().clearCookies();
+    }
+    async getStorage(pageId, kind) {
+        const { page } = await this.ensurePage(pageId);
+        const storageObj = kind === 'local' ? 'localStorage' : 'sessionStorage';
+        return await page.evaluate((s) => {
+            const storage = s === 'localStorage' ? localStorage : sessionStorage;
+            const result = {};
+            for (let i = 0; i < storage.length; i++) {
+                const key = storage.key(i);
+                if (key !== null)
+                    result[key] = storage.getItem(key) ?? '';
+            }
+            return result;
+        }, storageObj);
+    }
+    async setStorage(pageId, kind, data) {
+        const { page } = await this.ensurePage(pageId);
+        await page.evaluate(({ kind: k, data: d }) => {
+            const storage = k === 'local' ? localStorage : sessionStorage;
+            for (const [key, value] of Object.entries(d)) {
+                storage.setItem(key, value);
+            }
+        }, { kind, data });
+    }
+    async clearStorage(pageId, kind) {
+        const { page } = await this.ensurePage(pageId);
+        await page.evaluate((k) => {
+            const storage = k === 'local' ? localStorage : sessionStorage;
+            storage.clear();
+        }, kind);
+    }
+    async waitForCompletion(pageId, action) {
+        if (!this.pageStates.has(pageId) && !this.relay?.hasTab(pageId)) {
+            log.debug('waitForCompletion: page not found, running action directly:', pageId);
+            return await action();
+        }
+        const { page } = await this.ensurePage(pageId);
+        const requests = [];
+        const requestListener = (request) => requests.push(request);
+        page.on('request', requestListener);
+        let result;
+        try {
+            result = await action();
+            await page.waitForTimeout(500);
+        }
+        finally {
+            page.off('request', requestListener);
+        }
+        if (requests.some((r) => r.isNavigationRequest())) {
+            await page
+                .mainFrame()
+                .waitForLoadState('load', { timeout: 10_000 })
+                .catch(() => { });
+            return result;
+        }
+        const resourceTypes = new Set(['document', 'stylesheet', 'script', 'xhr', 'fetch']);
+        const promises = requests.map(async (r) => {
+            if (resourceTypes.has(r.resourceType())) {
+                const resp = await r.response().catch(() => undefined);
+                await resp?.finished().catch(() => { });
+                return;
+            }
+            await r.response().catch(() => { });
+        });
+        await Promise.race([
+            Promise.all(promises),
+            new Promise((resolve) => setTimeout(resolve, 5_000)),
+        ]);
+        if (requests.length > 0) {
+            await page.waitForTimeout(500);
+        }
+        return result;
+    }
+    getModalStates(pageId) {
+        const state = this.pageStates.get(pageId);
+        if (!state)
+            return [];
+        const modals = [];
+        if (state.pendingDialog) {
+            modals.push({
+                type: 'dialog',
+                description: `JavaScript ${state.pendingDialog.type()} dialog: "${state.pendingDialog.message()}"`,
+                clearedBy: 'browser_dialog',
+                dialogType: state.pendingDialog.type(),
+                message: state.pendingDialog.message(),
+            });
+        }
+        if (state.pendingFileChooser) {
+            modals.push({
+                type: 'filechooser',
+                description: 'File chooser is open, waiting for file selection.',
+                clearedBy: 'browser_upload',
+            });
+        }
+        return modals;
+    }
+    async getContent(pageId, selector) {
+        const { page } = await this.ensurePage(pageId);
+        if (selector) {
+            const locator = page.locator(selector);
+            const html = await locator.evaluate((el) => el.outerHTML);
+            return { html, url: page.url() };
+        }
+        return { html: await page.content(), url: page.url() };
+    }
+    async resolveRef(pageId, ref) {
+        const { page } = await this.ensurePage(pageId);
+        const locator = page.locator(`aria-ref=${ref}`);
+        try {
+            const count = await locator.count();
+            if (count === 0)
+                throw new errors_1.StaleRefError(ref);
+        }
+        catch (error) {
+            if (error instanceof errors_1.StaleRefError)
+                throw error;
+            throw new errors_1.StaleRefError(ref);
+        }
+        return locator;
+    }
+    requireContext() {
+        if (!this.context)
+            throw new Error('Browser context not initialized');
+        return this.context;
+    }
+    requirePage(pageId) {
+        const state = this.pageStates.get(pageId);
+        if (!state)
+            throw new errors_1.PageNotFoundError(pageId);
+        return state;
+    }
+    async ensurePage(pageId) {
+        const existing = this.pageStates.get(pageId);
+        if (existing) {
+            log.debug('ensurePage: page already tracked:', pageId);
+            return existing;
+        }
+        if (!this.relay || !this.context)
+            throw new errors_1.PageNotFoundError(pageId);
+        if (!pageId || !this.relay.hasTab(pageId)) {
+            throw new errors_1.PageNotFoundError(pageId);
+        }
+        log.debug('ensurePage: activating tab', pageId, 'current pages:', [...this.pageStates.keys()]);
+        const pagePromise = new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingActivation = undefined;
+                log.error('ensurePage: timed out waiting for page event after activateTab:', pageId);
+                reject(new Error(`Timed out waiting for page after activateTab (${pageId})`));
+            }, 10_000);
+            this.pendingActivation = {
+                id: pageId,
+                resolve: (page) => {
+                    clearTimeout(timeout);
+                    log.debug('ensurePage: page event received for', pageId);
+                    resolve(page);
+                },
+            };
+        });
+        log.debug('ensurePage: calling activateTab for', pageId);
+        await this.relay.activateTab(pageId);
+        log.debug('ensurePage: activateTab completed for', pageId, '— waiting for page event');
+        const page = await pagePromise;
+        log.debug('ensurePage: waiting for domcontentloaded on', pageId);
+        await page.waitForLoadState('domcontentloaded', { timeout: 5_000 }).catch(() => {
+            log.debug('ensurePage: domcontentloaded timeout (non-fatal) for', pageId);
+        });
+        log.debug('ensurePage: page ready:', pageId);
+        return this.pageStates.get(pageId) ?? this.trackPage(page, pageId);
+    }
+    findPageState(page) {
+        for (const state of this.pageStates.values()) {
+            if (state.page === page)
+                return state;
+        }
+        return undefined;
+    }
+    trackPage(page, explicitId) {
+        const id = explicitId ?? (0, utils_1.generateId)('page');
+        log.debug('trackPage: id =', id, 'url =', page.url());
+        const state = {
+            page,
+            info: { id, title: '', url: page.url() },
+            consoleBuffer: [],
+            errorBuffer: [],
+            networkBuffer: [],
+        };
+        page.on('console', (msg) => {
+            state.consoleBuffer.push({
+                level: msg.type(),
+                text: msg.text(),
+                timestamp: Date.now(),
+            });
+        });
+        page.on('pageerror', (error) => {
+            state.errorBuffer.push({
+                message: error.message,
+                stack: error.stack,
+                timestamp: Date.now(),
+            });
+        });
+        page.on('response', (response) => {
+            state.networkBuffer.push({
+                url: response.url(),
+                method: response.request().method(),
+                status: response.status(),
+                contentType: response.headers()['content-type'],
+                timestamp: Date.now(),
+            });
+        });
+        page.on('dialog', (dlg) => {
+            state.pendingDialog = dlg;
+        });
+        page.on('filechooser', (chooser) => {
+            state.pendingFileChooser = chooser;
+        });
+        page.on('close', () => {
+            log.debug('page closed:', id);
+            this.pageStates.delete(id);
+            this.relay?.deactivateTab(id);
+        });
+        this.pageStates.set(id, state);
+        return state;
+    }
+    getPageUrl(pageId) {
+        const state = this.pageStates.get(pageId);
+        if (!state)
+            return undefined;
+        try {
+            return state.page.url();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async resolveLocator(pageId, target) {
+        if ('ref' in target) {
+            return (await this.resolveRef(pageId, target.ref));
+        }
+        const { page } = this.requirePage(pageId);
+        return page.locator(target.selector);
+    }
+    globToRegex(pattern) {
+        const escaped = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*\*/g, '.*')
+            .replace(/\*/g, '[^/]*')
+            .replace(/\?/g, '.');
+        return new RegExp(`^${escaped}$`);
+    }
+}
+exports.PlaywrightAdapter = PlaywrightAdapter;
+//# sourceMappingURL=playwright.js.map