@roxybrowser/playwright 2.0.2-beta.0

package/dist/mcp/connectedBrowser.js

@@ -0,0 +1,2153 @@
+import { appendFile, mkdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import * as cdpModule from "chrome-remote-interface";
+import { normalizeAriaSnapshotOptions, retryUntilReady } from "../ariaSnapshot.js";
+import { PLAYWRIGHT_ARIA_SNAPSHOT_EVALUATE_SOURCE as ARIA_SNAPSHOT_EVALUATE_SOURCE } from "../vendor/playwright/ariaSnapshotEvaluate.js";
+import { getBidiClientFactory } from "../protocol/bidi/client.js";
+import { McpToolError } from "./errors.js";
+import { ACTION_POINT_EVALUATE_SOURCE, ACTION_POINT_BY_SELECTOR_SOURCE } from "./snapshot.js";
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const chromeRemoteInterface = ("default" in cdpModule
+    ? cdpModule.default
+    : cdpModule);
+function buildConnectionFromWsEndpoint(browserWsEndpoint) {
+    const parsed = new URL(browserWsEndpoint);
+    return {
+        browserWsEndpoint,
+        host: parsed.hostname,
+        port: Number(parsed.port)
+    };
+}
+async function resolveCdpConnection(endpoint) {
+    const parsed = new URL(endpoint);
+    if (parsed.protocol === "ws:" || parsed.protocol === "wss:") {
+        return buildConnectionFromWsEndpoint(endpoint);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new McpToolError("unsupported_protocol_input", `CDP endpoint must use http(s) discovery or ws(s) browser websocket. Received "${parsed.protocol}".`);
+    }
+    const versionUrl = parsed.pathname.endsWith("/json/version")
+        ? parsed
+        : new URL("/json/version", parsed);
+    const response = await fetch(versionUrl);
+    if (!response.ok) {
+        throw new Error(`Unable to resolve CDP discovery endpoint: ${response.status} ${response.statusText}`);
+    }
+    const payload = (await response.json());
+    if (!payload.webSocketDebuggerUrl) {
+        throw new Error("CDP discovery response did not include webSocketDebuggerUrl.");
+    }
+    return buildConnectionFromWsEndpoint(payload.webSocketDebuggerUrl);
+}
+async function evaluateCdp(client, functionSource, arg, contextId) {
+    const expression = arg === undefined
+        ? `(${functionSource})()`
+        : `(${functionSource})(${JSON.stringify(arg)})`;
+    const response = await client.Runtime.evaluate({
+        expression,
+        returnByValue: true,
+        awaitPromise: true,
+        ...(contextId !== undefined ? { contextId } : {})
+    });
+    if (response.exceptionDetails) {
+        const description = response.exceptionDetails.exception?.description;
+        const value = response.exceptionDetails.exception?.value;
+        throw new Error(description
+            || (value !== undefined ? String(value) : undefined)
+            || response.exceptionDetails.text
+            || "CDP runtime evaluation failed.");
+    }
+    return response.result.value;
+}
+async function evaluateCdpRef(client, functionSource, arg, contextId) {
+    const expression = arg === undefined
+        ? `(${functionSource})()`
+        : `(${functionSource})(${JSON.stringify(arg)})`;
+    const response = await client.Runtime.evaluate({
+        expression,
+        returnByValue: false,
+        awaitPromise: true,
+        ...(contextId !== undefined ? { contextId } : {})
+    });
+    if (response.exceptionDetails) {
+        const description = response.exceptionDetails.exception?.description;
+        const value = response.exceptionDetails.exception?.value;
+        throw new Error(description
+            || (value !== undefined ? String(value) : undefined)
+            || response.exceptionDetails.text
+            || "CDP runtime evaluation failed.");
+    }
+    const objectId = response.result.objectId;
+    return objectId !== undefined ? { objectId } : {};
+}
+const FOCUS_AND_GET_ELEMENT_SOURCE = String.raw `(payload) => {
+  const state = globalThis.__roxyMcpState;
+  const el = payload.nodeToken
+    ? (state?.elements?.get(payload.nodeToken) ?? null)
+    : document.querySelector(payload.selector);
+  if (!el || !el.isConnected) return null;
+  el.scrollIntoView({ block: 'nearest', inline: 'nearest' });
+  el.focus();
+  return el;
+}`;
+const TYPE_INTO_ELEMENT_SOURCE = String.raw `(payload) => {
+  const state = globalThis.__roxyMcpState;
+  const el = payload.nodeToken
+    ? (state?.elements?.get(payload.nodeToken) ?? null)
+    : document.querySelector(payload.selector);
+  if (!el || !el.isConnected) return { ok: false, reason: 'not_found' };
+  el.scrollIntoView({ block: 'nearest', inline: 'nearest' });
+  el.focus();
+  const tag = el.tagName.toLowerCase();
+  if (tag === 'input' || tag === 'textarea') {
+    const proto = Object.getPrototypeOf(el);
+    const setter = Object.getOwnPropertyDescriptor(proto, 'value')?.set
+      ?? Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set;
+    if (setter) setter.call(el, payload.text);
+    else el.value = payload.text;
+  } else if (el.isContentEditable) {
+    el.textContent = payload.text;
+  } else {
+    return { ok: false, reason: 'not_input' };
+  }
+  el.dispatchEvent(new Event('input', { bubbles: true }));
+  el.dispatchEvent(new Event('change', { bubbles: true }));
+  if (payload.submit) {
+    el.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', keyCode: 13, bubbles: true }));
+    el.dispatchEvent(new KeyboardEvent('keyup', { key: 'Enter', keyCode: 13, bubbles: true }));
+    if (el.form && typeof el.form.submit === 'function') el.form.submit();
+    else if (el.form) {
+      el.form.dispatchEvent(new Event('submit', { bubbles: true, cancelable: true }));
+    }
+  }
+  return { ok: true };
+}`;
+const SELECT_OPTION_SOURCE = String.raw `(payload) => {
+  const state = globalThis.__roxyMcpState;
+  const el = payload.nodeToken
+    ? (state?.elements?.get(payload.nodeToken) ?? null)
+    : document.querySelector(payload.selector);
+  if (!el || !el.isConnected) return { ok: false, reason: 'not_found', selected: [] };
+  if (el.tagName.toLowerCase() !== 'select') return { ok: false, reason: 'not_select', selected: [] };
+  const selectEl = el;
+  const values = payload.values;
+  let matched = false;
+  for (const option of selectEl.options) {
+    const shouldSelect = values.includes(option.value) || values.includes(option.text);
+    if (shouldSelect) {
+      option.selected = true;
+      matched = true;
+    } else if (!selectEl.multiple) {
+      option.selected = false;
+    }
+  }
+  if (!matched) {
+    // Try partial match
+    for (const option of selectEl.options) {
+      const shouldSelect = values.some(v => option.value.includes(v) || option.text.includes(v));
+      if (shouldSelect) { option.selected = true; matched = true; }
+    }
+  }
+  selectEl.dispatchEvent(new Event('input', { bubbles: true }));
+  selectEl.dispatchEvent(new Event('change', { bubbles: true }));
+  const selected = Array.from(selectEl.selectedOptions).map(o => o.value);
+  return { ok: matched, selected };
+}`;
+const CHECK_ELEMENT_SOURCE = String.raw `(payload) => {
+  const state = globalThis.__roxyMcpState;
+  const el = payload.nodeToken
+    ? (state?.elements?.get(payload.nodeToken) ?? null)
+    : document.querySelector(payload.selector);
+  if (!el || !el.isConnected) return { ok: false, reason: 'not_found' };
+  const tag = el.tagName.toLowerCase();
+  const type = el.getAttribute('type')?.toLowerCase();
+  if (tag === 'input' && (type === 'checkbox' || type === 'radio')) {
+    if (el.checked !== payload.checked) {
+      el.click();
+    }
+    return { ok: true };
+  }
+  const role = el.getAttribute('role');
+  if (role === 'checkbox' || role === 'switch') {
+    const current = el.getAttribute('aria-checked') === 'true';
+    if (current !== payload.checked) {
+      el.click();
+    }
+    return { ok: true };
+  }
+  return { ok: false, reason: 'not_checkable' };
+}`;
+const IS_FILE_INPUT_SOURCE = String.raw `(payload) => {
+  const state = globalThis.__roxyMcpState;
+  const element = payload.nodeToken
+    ? state?.elements?.get(payload.nodeToken)
+    : document.querySelector(payload.selector);
+  return !!element
+    && element instanceof HTMLInputElement
+    && element.type === 'file';
+}`;
+const SCROLL_ELEMENT_SOURCE = String.raw `(payload) => {
+  const state = globalThis.__roxyMcpState;
+  const el = payload.nodeToken
+    ? (state?.elements?.get(payload.nodeToken) ?? null)
+    : payload.selector ? document.querySelector(payload.selector) : null;
+  const target = el ?? document.documentElement;
+  target.scrollBy({ left: payload.deltaX, top: payload.deltaY, behavior: 'instant' });
+  return { ok: true };
+}`;
+const GET_ELEMENT_OBJECT_SOURCE = String.raw `(payload) => {
+  const state = globalThis.__roxyMcpState;
+  return payload.nodeToken
+    ? (state?.elements?.get(payload.nodeToken) ?? null)
+    : document.querySelector(payload.selector);
+}`;
+const SET_FORM_FIELD_SOURCE = String.raw `(payload) => {
+  const state = globalThis.__roxyMcpState;
+  const el = payload.nodeToken
+    ? (state?.elements?.get(payload.nodeToken) ?? null)
+    : document.querySelector(payload.selector);
+  if (!el || !el.isConnected) return { ok: false, reason: 'not_found' };
+  const tag = el.tagName.toLowerCase();
+  const type = el.getAttribute('type')?.toLowerCase();
+  if (payload.fieldType === 'textbox' || payload.fieldType === 'slider') {
+    if (tag !== 'input' && tag !== 'textarea' && !el.isContentEditable) return { ok: false, reason: 'not_input' };
+    el.focus();
+    if (el.isContentEditable) el.textContent = payload.value;
+    else {
+      const proto = Object.getPrototypeOf(el);
+      const setter = Object.getOwnPropertyDescriptor(proto, 'value')?.set
+        ?? Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set;
+      if (setter) setter.call(el, payload.value);
+      else el.value = payload.value;
+    }
+    el.dispatchEvent(new Event('input', { bubbles: true }));
+    el.dispatchEvent(new Event('change', { bubbles: true }));
+    return { ok: true };
+  }
+  if (payload.fieldType === 'checkbox' || payload.fieldType === 'radio') {
+    if (tag !== 'input' || (type !== 'checkbox' && type !== 'radio')) return { ok: false, reason: 'not_checkable' };
+    const checked = payload.value === 'true';
+    if (el.checked !== checked) el.click();
+    return { ok: true };
+  }
+  if (payload.fieldType === 'combobox') {
+    if (tag !== 'select') return { ok: false, reason: 'not_select' };
+    let matched = false;
+    for (const option of el.options) {
+      const shouldSelect = option.value === payload.value || option.text === payload.value;
+      option.selected = shouldSelect;
+      matched ||= shouldSelect;
+    }
+    el.dispatchEvent(new Event('input', { bubbles: true }));
+    el.dispatchEvent(new Event('change', { bubbles: true }));
+    return { ok: matched, reason: matched ? undefined : 'not_found' };
+  }
+  return { ok: false, reason: 'unsupported' };
+}`;
+const DROP_ON_ELEMENT_SOURCE = String.raw `async (payload) => {
+  const state = globalThis.__roxyMcpState;
+  const el = payload.nodeToken
+    ? (state?.elements?.get(payload.nodeToken) ?? null)
+    : document.querySelector(payload.selector);
+  if (!el || !el.isConnected) return { ok: false, reason: 'not_found' };
+  const dataTransfer = new DataTransfer();
+  for (const file of payload.files || []) {
+    const bytes = Uint8Array.from(atob(file.buffer), c => c.charCodeAt(0));
+    dataTransfer.items.add(new File([bytes], file.name, {
+      type: file.mimeType || 'application/octet-stream',
+      lastModified: file.lastModifiedMs
+    }));
+  }
+  for (const [type, value] of Object.entries(payload.data || {}))
+    dataTransfer.setData(type, value);
+  const rect = el.getBoundingClientRect();
+  const makeEvent = (type) => new DragEvent(type, {
+    bubbles: true,
+    cancelable: true,
+    composed: true,
+    dataTransfer,
+    clientX: rect.left + rect.width / 2,
+    clientY: rect.top + rect.height / 2
+  });
+  el.dispatchEvent(makeEvent('dragenter'));
+  const dragover = makeEvent('dragover');
+  el.dispatchEvent(dragover);
+  if (!dragover.defaultPrevented) {
+    el.dispatchEvent(makeEvent('dragleave'));
+    return { ok: false, reason: 'not_accepted' };
+  }
+  el.dispatchEvent(makeEvent('drop'));
+  return { ok: true };
+}`;
+const ELEMENT_BOX_SOURCE = String.raw `(payload) => {
+  const state = globalThis.__roxyMcpState;
+  const el = payload.nodeToken
+    ? (state?.elements?.get(payload.nodeToken) ?? null)
+    : document.querySelector(payload.selector);
+  if (!el || !el.isConnected || !(el instanceof Element) || el.getClientRects().length === 0)
+    return { ok: false };
+  const rect = el.getBoundingClientRect();
+  return {
+    ok: true,
+    x: rect.x,
+    y: rect.y,
+    width: Math.max(1, rect.width),
+    height: Math.max(1, rect.height)
+  };
+}`;
+const DOCUMENT_BOX_SOURCE = String.raw `() => {
+  const body = document.body;
+  const documentElement = document.documentElement;
+  const width = Math.max(
+    body?.scrollWidth ?? 0,
+    body?.offsetWidth ?? 0,
+    documentElement?.clientWidth ?? 0,
+    documentElement?.scrollWidth ?? 0,
+    documentElement?.offsetWidth ?? 0
+  );
+  const height = Math.max(
+    body?.scrollHeight ?? 0,
+    body?.offsetHeight ?? 0,
+    documentElement?.clientHeight ?? 0,
+    documentElement?.scrollHeight ?? 0,
+    documentElement?.offsetHeight ?? 0
+  );
+  return { x: 0, y: 0, width: Math.max(1, width), height: Math.max(1, height) };
+}`;
+const CDP_KEY_MAP = {
+    Enter: { key: "Enter", code: "Enter", keyCode: 13, text: "\r" },
+    Return: { key: "Enter", code: "Enter", keyCode: 13, text: "\r" },
+    Escape: { key: "Escape", code: "Escape", keyCode: 27 },
+    Tab: { key: "Tab", code: "Tab", keyCode: 9 },
+    Backspace: { key: "Backspace", code: "Backspace", keyCode: 8 },
+    Delete: { key: "Delete", code: "Delete", keyCode: 46 },
+    ArrowLeft: { key: "ArrowLeft", code: "ArrowLeft", keyCode: 37 },
+    ArrowRight: { key: "ArrowRight", code: "ArrowRight", keyCode: 39 },
+    ArrowUp: { key: "ArrowUp", code: "ArrowUp", keyCode: 38 },
+    ArrowDown: { key: "ArrowDown", code: "ArrowDown", keyCode: 40 },
+    Home: { key: "Home", code: "Home", keyCode: 36 },
+    End: { key: "End", code: "End", keyCode: 35 },
+    PageUp: { key: "PageUp", code: "PageUp", keyCode: 33 },
+    PageDown: { key: "PageDown", code: "PageDown", keyCode: 34 },
+    Insert: { key: "Insert", code: "Insert", keyCode: 45 },
+    Space: { key: " ", code: "Space", keyCode: 32, text: " " },
+    F1: { key: "F1", code: "F1", keyCode: 112 },
+    F2: { key: "F2", code: "F2", keyCode: 113 },
+    F3: { key: "F3", code: "F3", keyCode: 114 },
+    F4: { key: "F4", code: "F4", keyCode: 115 },
+    F5: { key: "F5", code: "F5", keyCode: 116 },
+    F6: { key: "F6", code: "F6", keyCode: 117 },
+    F7: { key: "F7", code: "F7", keyCode: 118 },
+    F8: { key: "F8", code: "F8", keyCode: 119 },
+    F9: { key: "F9", code: "F9", keyCode: 120 },
+    F10: { key: "F10", code: "F10", keyCode: 121 },
+    F11: { key: "F11", code: "F11", keyCode: 122 },
+    F12: { key: "F12", code: "F12", keyCode: 123 },
+};
+async function evaluateBiDi(client, contextId, functionSource, arg) {
+    const expression = arg === undefined
+        ? `(${functionSource})()`
+        : `(${functionSource})(${JSON.stringify(arg)})`;
+    const response = (await client.scriptEvaluate({
+        expression,
+        target: {
+            context: contextId
+        },
+        awaitPromise: true,
+        resultOwnership: "none"
+    }));
+    if (response.type === "exception") {
+        throw new Error(response.exceptionDetails?.text || "BiDi runtime evaluation failed.");
+    }
+    return response.result?.value;
+}
+async function evaluateBiDiRef(client, contextId, functionSource, arg) {
+    const expression = arg === undefined
+        ? `(${functionSource})()`
+        : `(${functionSource})(${JSON.stringify(arg)})`;
+    const response = (await client.scriptEvaluate({
+        expression,
+        target: {
+            context: contextId
+        },
+        awaitPromise: true,
+        resultOwnership: "root",
+        serializationOptions: {
+            maxObjectDepth: 0,
+            maxDomDepth: 0
+        }
+    }));
+    if (response.type === "exception") {
+        throw new Error(response.exceptionDetails?.text || "BiDi runtime evaluation failed.");
+    }
+    return {
+        ...(response.result?.sharedId !== undefined ? { sharedId: response.result.sharedId } : {}),
+        ...(response.result?.handle !== undefined ? { handle: response.result.handle } : {}),
+        ...(response.result?.value?.sharedId !== undefined ? { sharedId: response.result.value.sharedId } : {}),
+        ...(response.result?.value?.handle !== undefined ? { handle: response.result.value.handle } : {})
+    };
+}
+function toAriaSnapshotPayload(request = {}) {
+    return {
+        options: normalizeAriaSnapshotOptions({
+            mode: "ai",
+            ...(request.depth !== undefined ? { depth: request.depth } : {}),
+            ...(request.boxes !== undefined ? { boxes: request.boxes } : {})
+        }),
+        ...(request.target ? { target: request.target } : {})
+    };
+}
+function toBrowserSnapshot(result, request, extras = {}) {
+    if (result.error) {
+        const targetLabel = request.target?.raw ?? "target";
+        const detailedMessage = result.error.message;
+        if (result.error.code === "stale") {
+            throw new McpToolError("stale_ref", detailedMessage || `Target "${targetLabel}" is no longer valid. Call "browser_snapshot" again.`);
+        }
+        if (result.error.code === "invalid_selector" || result.error.code === "strict") {
+            throw new McpToolError("invalid_target", detailedMessage || `Target "${targetLabel}" is not a valid selector.`);
+        }
+        throw new McpToolError("invalid_target", detailedMessage || `Target "${targetLabel}" could not be found in the active tab.`);
+    }
+    return {
+        refs: result.refs,
+        text: result.text,
+        title: result.title,
+        url: result.url,
+        ...(extras.console ? { console: extras.console } : {}),
+        ...(extras.consoleLink ? { consoleLink: extras.consoleLink } : {})
+    };
+}
+function chooseInitialTab(tabs) {
+    return tabs.find((tab) => tab.url && tab.url !== "about:blank")?.id ?? tabs[0]?.id;
+}
+class CdpConnectedBrowserSession {
+    browserClient;
+    connection;
+    protocol = "cdp";
+    browserName = "chromium";
+    pageClients = new Map();
+    pageConsoleStates = new Map();
+    pageNetworkStates = new Map();
+    pageDialogStates = new Map();
+    activeTabId;
+    versionString = "Chromium/unknown";
+    constructor(browserClient, connection) {
+        this.browserClient = browserClient;
+        this.connection = connection;
+    }
+    static async connect(args) {
+        if (args.browser && args.browser !== "chromium") {
+            throw new McpToolError("unsupported_protocol_input", 'CDP attach only supports browser "chromium".');
+        }
+        const connection = await resolveCdpConnection(args.endpoint);
+        const version = await chromeRemoteInterface.Version({
+            host: connection.host,
+            port: connection.port
+        });
+        const browserClient = await chromeRemoteInterface({
+            target: connection.browserWsEndpoint
+        });
+        const session = new CdpConnectedBrowserSession(browserClient, connection);
+        session.versionString = version.Browser;
+        const tabs = await session.refreshTabs();
+        if (tabs.length === 0) {
+            await session.newTab();
+        }
+        await session.getActivePageClient().catch(() => undefined);
+        return session;
+    }
+    async version() {
+        return this.versionString;
+    }
+    async listTabs() {
+        return this.refreshTabs();
+    }
+    async newTab(url = "about:blank") {
+        const response = await this.browserClient.Target.createTarget({ url });
+        this.activeTabId = response.targetId;
+        await this.browserClient.Target.activateTarget({
+            targetId: response.targetId
+        });
+        return this.refreshTabs();
+    }
+    async selectTab(tabId) {
+        this.activeTabId = tabId;
+        await this.browserClient.Target.activateTarget({
+            targetId: tabId
+        });
+        return this.refreshTabs();
+    }
+    async closeTab(tabId) {
+        const tabsBeforeClose = await this.refreshTabs();
+        const index = tabsBeforeClose.findIndex((tab) => tab.id === tabId);
+        await this.browserClient.Target.closeTarget({
+            targetId: tabId
+        });
+        const pageClient = this.pageClients.get(tabId);
+        if (pageClient) {
+            this.pageClients.delete(tabId);
+            this.pageConsoleStates.delete(tabId);
+            await pageClient.close().catch(() => { });
+        }
+        const tabsAfterClose = await this.refreshTabs();
+        if (tabsAfterClose.length === 0) {
+            this.activeTabId = undefined;
+            return tabsAfterClose;
+        }
+        const fallbackIndex = index >= 0 ? Math.min(index, tabsAfterClose.length - 1) : 0;
+        this.activeTabId = tabsAfterClose[fallbackIndex]?.id;
+        if (this.activeTabId) {
+            await this.browserClient.Target.activateTarget({
+                targetId: this.activeTabId
+            });
+        }
+        return this.refreshTabs();
+    }
+    async snapshot(request = {}) {
+        const activeTabId = await this.getActiveTabId();
+        const pageClient = await this.getActivePageClient();
+        const contextId = await this.getActiveUtilityContextId(pageClient);
+        const result = await retryUntilReady(() => evaluateCdp(pageClient, ARIA_SNAPSHOT_EVALUATE_SOURCE, toAriaSnapshotPayload(request), contextId));
+        return toBrowserSnapshot(result, request, {
+            console: this.consoleSummary(activeTabId),
+            consoleLink: await this.takeConsoleLink(activeTabId)
+        });
+    }
+    async click(target, options) {
+        const pageClient = await this.getActivePageClient();
+        const contextId = await this.getActiveUtilityContextId(pageClient);
+        const source = "nodeToken" in target ? ACTION_POINT_EVALUATE_SOURCE : ACTION_POINT_BY_SELECTOR_SOURCE;
+        const arg = "nodeToken" in target ? { nodeToken: target.nodeToken } : { selector: target.selector };
+        const point = await evaluateCdp(pageClient, source, arg, contextId);
+        if (!point.ok || point.x === undefined || point.y === undefined) {
+            const isSelector = "selector" in target;
+            throw new McpToolError(isSelector ? "invalid_target" : "stale_ref", isSelector
+                ? `Element "${target.selector}" could not be found or is not visible.`
+                : 'The referenced element is no longer valid. Call "browser_snapshot" again.');
+        }
+        const MODIFIER_BITS = {
+            Alt: 1, Control: 2, ControlOrMeta: 2, Meta: 4, Shift: 8
+        };
+        const modifiersMask = (options.modifiers ?? []).reduce((acc, m) => acc | (MODIFIER_BITS[m] ?? 0), 0);
+        const cdpButton = (options.button ?? "left");
+        const clickCount = options.doubleClick ? 2 : 1;
+        const cycles = options.doubleClick ? 2 : 1;
+        await pageClient.Input.dispatchMouseEvent({
+            type: "mouseMoved",
+            x: point.x,
+            y: point.y,
+            button: "none",
+            modifiers: modifiersMask
+        });
+        for (let i = 0; i < cycles; i++) {
+            await pageClient.Input.dispatchMouseEvent({
+                type: "mousePressed",
+                x: point.x,
+                y: point.y,
+                button: cdpButton,
+                clickCount,
+                modifiers: modifiersMask
+            });
+            await delay(options.clickHoldMs);
+            await pageClient.Input.dispatchMouseEvent({
+                type: "mouseReleased",
+                x: point.x,
+                y: point.y,
+                button: cdpButton,
+                clickCount,
+                modifiers: modifiersMask
+            });
+        }
+    }
+    async drag(start, end, options) {
+        const pageClient = await this.getActivePageClient();
+        const contextId = await this.getActiveUtilityContextId(pageClient);
+        const startPoint = await this.actionPoint(pageClient, contextId, start);
+        const endPoint = await this.actionPoint(pageClient, contextId, end);
+        await pageClient.Input.dispatchMouseEvent({
+            type: "mouseMoved",
+            x: startPoint.x,
+            y: startPoint.y,
+            button: "none"
+        });
+        await delay(options.moveDelayMs);
+        await pageClient.Input.dispatchMouseEvent({
+            type: "mousePressed",
+            x: startPoint.x,
+            y: startPoint.y,
+            button: "left",
+            clickCount: 1
+        });
+        await delay(options.holdDelayMs);
+        await pageClient.Input.dispatchMouseEvent({
+            type: "mouseMoved",
+            x: endPoint.x,
+            y: endPoint.y,
+            button: "left"
+        });
+        await delay(options.moveDelayMs);
+        await pageClient.Input.dispatchMouseEvent({
+            type: "mouseReleased",
+            x: endPoint.x,
+            y: endPoint.y,
+            button: "left",
+            clickCount: 1
+        });
+    }
+    async drop(target, payload) {
+        const files = await prepareDropFiles(payload.paths);
+        const pageClient = await this.getActivePageClient();
+        const contextId = await this.getActiveUtilityContextId(pageClient);
+        const result = await evaluateCdp(pageClient, DROP_ON_ELEMENT_SOURCE, { ...this.targetArg(target), data: payload.data ?? {}, files }, contextId);
+        if (!result.ok) {
+            throw new McpToolError(result.reason === "not_accepted" ? "action_failed" : "invalid_target", result.reason === "not_accepted"
+                ? "Drop target did not accept the drop; its dragover handler did not call preventDefault()."
+                : "Drop target could not be found.");
+        }
+    }
+    async hover(target) {
+        const pageClient = await this.getActivePageClient();
+        const contextId = await this.getActiveUtilityContextId(pageClient);
+        const source = "nodeToken" in target ? ACTION_POINT_EVALUATE_SOURCE : ACTION_POINT_BY_SELECTOR_SOURCE;
+        const arg = "nodeToken" in target ? { nodeToken: target.nodeToken } : { selector: target.selector };
+        const point = await evaluateCdp(pageClient, source, arg, contextId);
+        if (!point.ok || point.x === undefined || point.y === undefined) {
+            const isSelector = "selector" in target;
+            throw new McpToolError(isSelector ? "invalid_target" : "stale_ref", isSelector
+                ? `Element "${target.selector}" could not be found or is not visible.`
+                : 'The referenced element is no longer valid. Call "browser_snapshot" again.');
+        }
+        await pageClient.Input.dispatchMouseEvent({
+            type: "mouseMoved",
+            x: point.x,
+            y: point.y,
+            button: "none"
+        });
+    }
+    async close() {
+        await Promise.all(Array.from(this.pageClients.values()).map(async (client) => {
+            await client.close().catch(() => { });
+        }));
+        this.pageClients.clear();
+        await this.browserClient.close().catch(() => { });
+    }
+    async navigate(url) {
+        const pageClient = await this.getActivePageClient();
+        const tabId = await this.getActiveTabId();
+        this.resetConsole(tabId);
+        await pageClient.Page.navigate({ url });
+        await waitForCdpDocumentReady(pageClient, 5_000);
+    }
+    async type(target, text, options) {
+        const pageClient = await this.getActivePageClient();
+        const contextId = await this.getActiveUtilityContextId(pageClient);
+        const arg = this.targetArg(target);
+        if (options?.slowly || options?.delayMs) {
+            const refResult = await evaluateCdpRef(pageClient, FOCUS_AND_GET_ELEMENT_SOURCE, arg, contextId);
+            if (!refResult.objectId) {
+                const isSelector = "selector" in target;
+                throw new McpToolError(isSelector ? "invalid_target" : "stale_ref", isSelector ? `Element "${target.selector}" could not be found.` : "The referenced element is no longer valid.");
+            }
+            for (const char of text) {
+                await pageClient.Input.insertText({ text: char });
+                if (options.delayMs) {
+                    await delay(options.delayMs);
+                }
+            }
+            if (options.submit) {
+                await this.pressKey("Enter");
+            }
+            return;
+        }
+        const result = await evaluateCdp(pageClient, TYPE_INTO_ELEMENT_SOURCE, { ...arg, text, submit: options?.submit ?? false }, contextId);
+        if (!result.ok) {
+            const isSelector = "selector" in target;
+            throw new McpToolError(isSelector ? "invalid_target" : "stale_ref", result.reason === "not_found"
+                ? (isSelector ? `Element "${target.selector}" could not be found.` : 'The referenced element is no longer valid. Call "browser_snapshot" again.')
+                : `Element is not a typeable input.`);
+        }
+    }
+    async pressKey(key, modifiers) {
+        const pageClient = await this.getActivePageClient();
+        const MODIFIER_BITS = {
+            Alt: 1, Control: 2, ControlOrMeta: 2, Meta: 4, Shift: 8
+        };
+        const modifiersMask = (modifiers ?? []).reduce((acc, m) => acc | (MODIFIER_BITS[m] ?? 0), 0);
+        const mapped = CDP_KEY_MAP[key];
+        if (mapped) {
+            await pageClient.Input.dispatchKeyEvent({
+                type: "keyDown",
+                key: mapped.key,
+                code: mapped.code,
+                windowsVirtualKeyCode: mapped.keyCode,
+                nativeVirtualKeyCode: mapped.keyCode,
+                ...(mapped.text ? { text: mapped.text } : {}),
+                modifiers: modifiersMask
+            });
+            await pageClient.Input.dispatchKeyEvent({
+                type: "keyUp",
+                key: mapped.key,
+                code: mapped.code,
+                windowsVirtualKeyCode: mapped.keyCode,
+                nativeVirtualKeyCode: mapped.keyCode,
+                modifiers: modifiersMask
+            });
+        }
+        else {
+            // Printable single character
+            await pageClient.Input.insertText({ text: key });
+        }
+    }
+    async selectOption(target, values) {
+        const pageClient = await this.getActivePageClient();
+        const contextId = await this.getActiveUtilityContextId(pageClient);
+        const arg = this.targetArg(target);
+        const result = await evaluateCdp(pageClient, SELECT_OPTION_SOURCE, { ...arg, values }, contextId);
+        if (!result.ok) {
+            const isSelector = "selector" in target;
+            throw new McpToolError(isSelector ? "invalid_target" : "stale_ref", result.reason === "not_found"
+                ? (isSelector ? `Element "${target.selector}" could not be found.` : 'The referenced element is no longer valid.')
+                : `Element is not a <select> element.`);
+        }
+        return result.selected;
+    }
+    async check(target, checked) {
+        const pageClient = await this.getActivePageClient();
+        const contextId = await this.getActiveUtilityContextId(pageClient);
+        const arg = this.targetArg(target);
+        const result = await evaluateCdp(pageClient, CHECK_ELEMENT_SOURCE, { ...arg, checked }, contextId);
+        if (!result.ok) {
+            const isSelector = "selector" in target;
+            throw new McpToolError(isSelector ? "invalid_target" : "stale_ref", result.reason === "not_found"
+                ? (isSelector ? `Element "${target.selector}" could not be found.` : 'The referenced element is no longer valid.')
+                : `Element is not a checkbox or radio button.`);
+        }
+    }
+    async goBack() {
+        const pageClient = await this.getActivePageClient();
+        await pageClient.Page.goBack().catch(() => { });
+    }
+    async goForward() {
+        const pageClient = await this.getActivePageClient();
+        await pageClient.Page.goForward().catch(() => { });
+    }
+    async resize(width, height) {
+        const pageClient = await this.getActivePageClient();
+        await pageClient.Emulation?.setDeviceMetricsOverride({
+            mobile: false,
+            width,
+            height,
+            screenWidth: width,
+            screenHeight: height,
+            deviceScaleFactor: 1
+        });
+    }
+    async scroll(target, deltaX, deltaY) {
+        const pageClient = await this.getActivePageClient();
+        const contextId = await this.getActiveUtilityContextId(pageClient);
+        const arg = target ? this.targetArg(target) : {};
+        await evaluateCdp(pageClient, SCROLL_ELEMENT_SOURCE, { ...arg, deltaX, deltaY }, contextId);
+    }
+    async screenshot(options = {}) {
+        const pageClient = await this.getActivePageClient();
+        const format = options.type ?? "png";
+        const screenshotOptions = { format };
+        if (options.target) {
+            const refResult = await evaluateCdpRef(pageClient, GET_ELEMENT_OBJECT_SOURCE, this.targetArg(options.target), await this.getActiveUtilityContextId(pageClient));
+            if (!refResult.objectId) {
+                throw new McpToolError("invalid_target", "Screenshot target could not be found.");
+            }
+            const model = await pageClient.DOM.getBoxModel({ objectId: refResult.objectId });
+            const border = model.model.border;
+            const xs = [border[0], border[2], border[4], border[6]].filter((value) => value !== undefined);
+            const ys = [border[1], border[3], border[5], border[7]].filter((value) => value !== undefined);
+            const x = Math.min(...xs);
+            const y = Math.min(...ys);
+            screenshotOptions.clip = {
+                x,
+                y,
+                width: Math.max(1, Math.max(...xs) - x),
+                height: Math.max(1, Math.max(...ys) - y),
+                scale: 1
+            };
+        }
+        else if (options.fullPage) {
+            const metrics = await pageClient.send("Page.getLayoutMetrics");
+            const contentSize = metrics.cssContentSize ?? metrics.contentSize;
+            if (contentSize) {
+                screenshotOptions.clip = {
+                    x: contentSize.x,
+                    y: contentSize.y,
+                    width: contentSize.width,
+                    height: contentSize.height,
+                    scale: 1
+                };
+            }
+        }
+        const result = await pageClient.Page.captureScreenshot(screenshotOptions);
+        return { data: result.data, mimeType: format === "png" ? "image/png" : "image/jpeg" };
+    }
+    async uploadFile(target, filePaths) {
+        const pageClient = await this.getActivePageClient();
+        const contextId = await this.getActiveUtilityContextId(pageClient);
+        const arg = this.targetArg(target);
+        const refResult = await evaluateCdpRef(pageClient, GET_ELEMENT_OBJECT_SOURCE, arg, contextId);
+        if (!refResult.objectId) {
+            const isSelector = "selector" in target;
+            throw new McpToolError(isSelector ? "invalid_target" : "stale_ref", isSelector ? `Element "${target.selector}" could not be found.` : 'The referenced element is no longer valid.');
+        }
+        await pageClient.DOM.setFileInputFiles({ objectId: refResult.objectId, files: filePaths });
+    }
+    async fillForm(fields) {
+        const pageClient = await this.getActivePageClient();
+        const contextId = await this.getActiveUtilityContextId(pageClient);
+        for (const field of fields) {
+            const result = await evaluateCdp(pageClient, SET_FORM_FIELD_SOURCE, {
+                ...this.targetArg(field.target),
+                fieldType: field.type,
+                value: field.value
+            }, contextId);
+            if (!result.ok) {
+                throw new McpToolError("invalid_target", `Unable to fill form field: ${result.reason ?? "unknown error"}.`);
+            }
+        }
+    }
+    async handleDialog(accept, promptText) {
+        const tabId = await this.getActiveTabId();
+        if (!this.pageDialogStates.has(tabId)) {
+            throw new McpToolError("no_dialog", "No dialog visible.");
+        }
+        const pageClient = await this.getActivePageClient();
+        this.pageDialogStates.delete(tabId);
+        await pageClient.Page.handleJavaScriptDialog({
+            accept,
+            ...(promptText !== undefined ? { promptText } : {})
+        });
+    }
+    async networkRequests() {
+        const tabId = await this.getActiveTabId();
+        return this.ensureNetworkState(tabId).requests.map(cloneNetworkRequest);
+    }
+    async networkRequest(index) {
+        const tabId = await this.getActiveTabId();
+        const request = this.ensureNetworkState(tabId).requests[index - 1];
+        return request ? cloneNetworkRequest(request) : undefined;
+    }
+    async runCodeUnsafe(code) {
+        const pageClient = await this.getActivePageClient();
+        const contextId = await this.getActiveUtilityContextId(pageClient);
+        return evaluateCdp(pageClient, String.raw `async (payload) => {
+        const fn = eval('(' + payload.code + ')');
+        if (typeof fn !== 'function') throw new Error('Code must evaluate to a function.');
+        const page = {
+          evaluate: async (expression, arg) => {
+            const value = typeof expression === 'function' ? expression : eval('(' + expression + ')');
+            return typeof value === 'function' ? await value(arg) : value;
+          },
+          title: () => document.title,
+          url: () => location.href,
+          goto: (url) => { location.href = url; },
+          locator: (selector) => ({
+            click: () => document.querySelector(selector)?.click(),
+            fill: (value) => {
+              const el = document.querySelector(selector);
+              if (!el) throw new Error('Element not found: ' + selector);
+              el.value = value;
+              el.dispatchEvent(new Event('input', { bubbles: true }));
+              el.dispatchEvent(new Event('change', { bubbles: true }));
+            },
+            textContent: () => document.querySelector(selector)?.textContent ?? null
+          })
+        };
+        return await fn(page);
+      }`, { code }, contextId);
+    }
+    targetArg(target) {
+        return "nodeToken" in target
+            ? { nodeToken: target.nodeToken }
+            : { selector: target.selector };
+    }
+    async actionPoint(client, contextId, target) {
+        const source = "nodeToken" in target ? ACTION_POINT_EVALUATE_SOURCE : ACTION_POINT_BY_SELECTOR_SOURCE;
+        const point = await evaluateCdp(client, source, this.targetArg(target), contextId);
+        if (!point.ok || point.x === undefined || point.y === undefined) {
+            throw new McpToolError("invalid_target", "Element could not be found or is not visible.");
+        }
+        return { x: point.x, y: point.y };
+    }
+    async refreshTabs() {
+        const response = await this.browserClient.Target.getTargets();
+        const tabs = response.targetInfos
+            .filter((targetInfo) => {
+            return targetInfo.type === "page" && !targetInfo.url.startsWith("devtools://");
+        })
+            .map((targetInfo) => ({
+            id: targetInfo.targetId,
+            title: targetInfo.title,
+            url: targetInfo.url
+        }));
+        if (!this.activeTabId) {
+            this.activeTabId = chooseInitialTab(tabs);
+        }
+        return tabs.map((tab) => ({
+            ...tab,
+            active: tab.id === this.activeTabId
+        }));
+    }
+    async getActiveTabId() {
+        const tabs = await this.refreshTabs();
+        const activeTab = tabs.find((tab) => tab.active);
+        if (!activeTab) {
+            throw new McpToolError("no_active_tab", "No active tab is available.");
+        }
+        return activeTab.id;
+    }
+    async getActivePageClient() {
+        const tabs = await this.refreshTabs();
+        const activeTab = tabs.find((tab) => tab.active);
+        if (!activeTab) {
+            throw new McpToolError("no_active_tab", "No active tab is available.");
+        }
+        const existing = this.pageClients.get(activeTab.id);
+        if (existing) {
+            return existing;
+        }
+        const client = await chromeRemoteInterface({
+            host: this.connection.host,
+            port: this.connection.port,
+            target: activeTab.id
+        });
+        this.installConsoleCollection(activeTab.id, client);
+        await Promise.all([
+            client.Page.enable(),
+            client.Runtime.enable(),
+            client.DOM.enable({}),
+            client.Network?.enable({}).catch(() => undefined),
+            client.Log?.enable().catch(() => undefined)
+        ]);
+        this.pageClients.set(activeTab.id, client);
+        return client;
+    }
+    async getActiveUtilityContextId(client) {
+        const { frameTree } = await client.Page.getFrameTree();
+        const response = await client.Page.createIsolatedWorld({
+            frameId: frameTree.frame.id,
+            worldName: "__roxy_playwright_utility_world__",
+            grantUniversalAccess: true
+        });
+        return response.executionContextId;
+    }
+    installConsoleCollection(tabId, client) {
+        this.ensureConsoleState(tabId);
+        client.Runtime.consoleAPICalled((event) => {
+            if (event.executionContextId === 0) {
+                return;
+            }
+            const frame = event.stackTrace?.callFrames?.[0];
+            const text = formatConsoleText(event.args);
+            const locationUrl = frame?.url ?? "";
+            const lineNumber = frame?.lineNumber ?? 0;
+            this.addConsoleMessage(tabId, {
+                type: event.type,
+                timestamp: normalizeConsoleTimestamp(event.timestamp),
+                text,
+                locationUrl,
+                lineNumber,
+                formattedText: formatConsoleMessage(event.type, text, locationUrl, lineNumber)
+            });
+        });
+        client.Runtime.exceptionThrown((event) => {
+            const details = event.exceptionDetails;
+            const text = details?.exception?.description
+                || (details?.exception?.value !== undefined ? String(details.exception.value) : undefined)
+                || details?.text
+                || "Uncaught exception";
+            this.addConsoleMessage(tabId, {
+                type: "error",
+                timestamp: Date.now(),
+                text,
+                locationUrl: details?.url ?? "",
+                lineNumber: details?.lineNumber ?? 0,
+                formattedText: text
+            });
+        });
+        client.Log?.entryAdded((event) => {
+            const entry = event.entry;
+            if (entry.source === "worker") {
+                return;
+            }
+            const type = entry.level ?? "log";
+            const text = entry.text ?? "";
+            const locationUrl = entry.url ?? "";
+            const lineNumber = entry.lineNumber ?? 0;
+            this.addConsoleMessage(tabId, {
+                type,
+                timestamp: normalizeConsoleTimestamp(entry.timestamp),
+                text,
+                locationUrl,
+                lineNumber,
+                formattedText: formatConsoleMessage(type, text, locationUrl, lineNumber)
+            });
+        });
+        client.Page.javascriptDialogOpening((event) => {
+            this.pageDialogStates.set(tabId, {
+                message: event.message,
+                type: event.type,
+                ...(event.defaultPrompt !== undefined ? { defaultPrompt: event.defaultPrompt } : {}),
+                ...(event.url !== undefined ? { url: event.url } : {})
+            });
+        });
+        this.installNetworkCollection(tabId, client);
+    }
+    installNetworkCollection(tabId, client) {
+        if (!client.Network) {
+            return;
+        }
+        const state = this.ensureNetworkState(tabId);
+        client.Network.requestWillBeSent((event) => {
+            const existing = state.byRequestId.get(event.requestId);
+            const request = existing ?? {
+                index: state.requests.length + 1,
+                requestId: event.requestId,
+                method: event.request.method,
+                url: event.request.url,
+                resourceType: normalizeResourceType(event.type),
+                requestHeaders: {},
+            };
+            request.method = event.request.method;
+            request.url = event.request.url;
+            request.resourceType = normalizeResourceType(event.type);
+            request.requestHeaders = normalizeHeaders(event.request.headers ?? {});
+            if (event.request.postData !== undefined) {
+                request.requestBody = event.request.postData;
+            }
+            if (!existing) {
+                state.requests.push(request);
+                state.byRequestId.set(event.requestId, request);
+            }
+            if (event.timestamp !== undefined) {
+                state.startedAt.set(event.requestId, event.timestamp * 1000);
+            }
+        });
+        client.Network.responseReceived((event) => {
+            const request = state.byRequestId.get(event.requestId);
+            if (!request) {
+                return;
+            }
+            request.status = event.response.status;
+            request.statusText = event.response.statusText;
+            request.responseHeaders = normalizeHeaders(event.response.headers ?? {});
+            request.mimeType = event.response.mimeType;
+            request.resourceType = normalizeResourceType(event.type) || request.resourceType;
+        });
+        client.Network.loadingFinished(async (event) => {
+            const request = state.byRequestId.get(event.requestId);
+            if (!request) {
+                return;
+            }
+            const startedAt = state.startedAt.get(event.requestId);
+            if (startedAt !== undefined && event.timestamp !== undefined) {
+                request.durationMs = Math.round(event.timestamp * 1000 - startedAt);
+            }
+            if (canReadResponseBody(request)) {
+                const clientNetwork = client.Network;
+                const body = await clientNetwork?.getResponseBody({ requestId: event.requestId }).catch(() => undefined);
+                if (body) {
+                    request.responseBody = body.base64Encoded
+                        ? Buffer.from(body.body, "base64").toString("utf8")
+                        : body.body;
+                }
+            }
+        });
+        client.Network.loadingFailed((event) => {
+            const request = state.byRequestId.get(event.requestId);
+            if (!request) {
+                return;
+            }
+            request.failureText = event.errorText ?? "Unknown error";
+            const startedAt = state.startedAt.get(event.requestId);
+            if (startedAt !== undefined && event.timestamp !== undefined) {
+                request.durationMs = Math.round(event.timestamp * 1000 - startedAt);
+            }
+        });
+    }
+    ensureConsoleState(tabId) {
+        let state = this.pageConsoleStates.get(tabId);
+        if (!state) {
+            state = {
+                messages: [],
+                nextMessageIndex: 0,
+                logStartTime: Date.now(),
+                logLine: 0
+            };
+            this.pageConsoleStates.set(tabId, state);
+        }
+        return state;
+    }
+    ensureNetworkState(tabId) {
+        let state = this.pageNetworkStates.get(tabId);
+        if (!state) {
+            state = {
+                requests: [],
+                byRequestId: new Map(),
+                startedAt: new Map()
+            };
+            this.pageNetworkStates.set(tabId, state);
+        }
+        return state;
+    }
+    resetConsole(tabId) {
+        this.pageConsoleStates.set(tabId, {
+            messages: [],
+            nextMessageIndex: 0,
+            logStartTime: Date.now(),
+            logLine: 0
+        });
+        this.pageNetworkStates.set(tabId, {
+            requests: [],
+            byRequestId: new Map(),
+            startedAt: new Map()
+        });
+        this.pageDialogStates.delete(tabId);
+    }
+    addConsoleMessage(tabId, message) {
+        const state = this.ensureConsoleState(tabId);
+        if (!shouldIncludeConsoleMessage(message.type)) {
+            return;
+        }
+        state.messages.push(message);
+    }
+    async consoleMessages(level = "info", all = false) {
+        const activeTabId = await this.getActiveTabId();
+        const state = this.ensureConsoleState(activeTabId);
+        const startIndex = all ? 0 : state.nextMessageIndex;
+        return state.messages
+            .slice(startIndex)
+            .filter((message) => consoleLevelForMessageType(message.type) <= consoleLevelForMessageType(level))
+            .map((message) => ({
+            type: message.type,
+            text: message.text,
+            timestamp: message.timestamp,
+            locationUrl: message.locationUrl,
+            lineNumber: message.lineNumber,
+            formattedText: message.formattedText
+        }));
+    }
+    async evaluate(expression, target) {
+        const pageClient = await this.getActivePageClient();
+        const contextId = await this.getActiveUtilityContextId(pageClient);
+        const source = target
+            ? String.raw `async (payload) => {
+          const state = globalThis.__roxyMcpState;
+          const element = payload.nodeToken
+            ? (state?.elements?.get(payload.nodeToken) ?? null)
+            : document.querySelector(payload.selector);
+          if (!element) throw new Error('Element not found');
+          const value = eval('(' + payload.expression + ')');
+          return typeof value === 'function' ? await value(element) : value;
+        }`
+            : String.raw `async (payload) => {
+          const value = eval('(' + payload.expression + ')');
+          return typeof value === 'function' ? await value() : value;
+        }`;
+        const payload = target ? { ...this.targetArg(target), expression } : { expression };
+        return evaluateCdp(pageClient, source, payload, contextId);
+    }
+    async isFileInput(target) {
+        const pageClient = await this.getActivePageClient();
+        const contextId = await this.getActiveUtilityContextId(pageClient);
+        return evaluateCdp(pageClient, IS_FILE_INPUT_SOURCE, this.targetArg(target), contextId).catch(() => false);
+    }
+    consoleSummary(tabId) {
+        const messages = this.ensureConsoleState(tabId).messages;
+        let errors = 0;
+        let warnings = 0;
+        for (const message of messages) {
+            if (message.type === "error" || message.type === "assert") {
+                errors++;
+            }
+            else if (message.type === "warning") {
+                warnings++;
+            }
+        }
+        return { total: messages.length, errors, warnings };
+    }
+    async takeConsoleLink(tabId) {
+        const state = this.ensureConsoleState(tabId);
+        const messages = state.messages.slice(state.nextMessageIndex);
+        if (messages.length === 0) {
+            return undefined;
+        }
+        state.logFile ??= path.join(process.cwd(), ".playwright-mcp", `console-${new Date(state.logStartTime).toISOString().replace(/[:.]/g, "-")}.log`);
+        await mkdir(path.dirname(state.logFile), { recursive: true });
+        const fromLine = state.logLine + 1;
+        for (const message of messages) {
+            const relativeTime = Math.round(message.timestamp - state.logStartTime);
+            const logLine = `[${String(relativeTime).padStart(8, " ")}ms] ${message.formattedText}\n`;
+            await appendFile(state.logFile, logLine);
+            state.logLine += logLine.split("\n").length - 1;
+        }
+        state.nextMessageIndex = state.messages.length;
+        const relativePath = path.relative(process.cwd(), state.logFile);
+        const lineRange = fromLine === state.logLine ? `#L${fromLine}` : `#L${fromLine}-L${state.logLine}`;
+        return `${relativePath}${lineRange}`;
+    }
+}
+async function waitForCdpDocumentReady(client, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const readyState = await evaluateCdp(client, String.raw `() => document.readyState`).catch(() => "loading");
+        if (readyState === "complete") {
+            return;
+        }
+        await delay(100);
+    }
+}
+function normalizeConsoleTimestamp(timestamp) {
+    if (timestamp === undefined) {
+        return Date.now();
+    }
+    return timestamp < 100_000_000_000 ? timestamp * 1000 : timestamp;
+}
+function formatConsoleText(args) {
+    return args
+        .map((arg) => {
+        if (typeof arg.value === "string") {
+            return arg.value;
+        }
+        if (arg.value !== undefined) {
+            return String(arg.value);
+        }
+        if (arg.unserializableValue) {
+            return arg.unserializableValue;
+        }
+        if (arg.description) {
+            return arg.description;
+        }
+        return arg.type ?? "";
+    })
+        .join(" ");
+}
+function formatConsoleMessage(type, text, locationUrl, lineNumber) {
+    return `[${type.toUpperCase()}] ${text} @ ${locationUrl}:${lineNumber}`;
+}
+function shouldIncludeConsoleMessage(type) {
+    return consoleLevelForMessageType(type) <= consoleLevelForMessageType("info");
+}
+function consoleLevelForMessageType(type) {
+    switch (type) {
+        case "assert":
+        case "error":
+            return 0;
+        case "warning":
+            return 1;
+        case "count":
+        case "dir":
+        case "dirxml":
+        case "info":
+        case "log":
+        case "table":
+        case "time":
+        case "timeEnd":
+            return 2;
+        case "clear":
+        case "debug":
+        case "endGroup":
+        case "profile":
+        case "profileEnd":
+        case "startGroup":
+        case "startGroupCollapsed":
+        case "trace":
+            return 3;
+        default:
+            return 2;
+    }
+}
+function normalizeHeaders(headers) {
+    const result = {};
+    for (const [key, value] of Object.entries(headers)) {
+        result[key.toLowerCase()] = String(value);
+    }
+    return result;
+}
+function normalizeResourceType(type) {
+    return (type ?? "other").toLowerCase();
+}
+function canReadResponseBody(request) {
+    if (request.failureText || request.status === undefined) {
+        return false;
+    }
+    return request.status !== 204 && request.status !== 304 && !(request.status >= 100 && request.status < 200);
+}
+function cloneNetworkRequest(request) {
+    return {
+        ...request,
+        requestHeaders: { ...request.requestHeaders },
+        ...(request.responseHeaders ? { responseHeaders: { ...request.responseHeaders } } : {})
+    };
+}
+async function prepareDropFiles(paths) {
+    if (!paths?.length) {
+        return [];
+    }
+    return Promise.all(paths.map(async (filePath) => {
+        const [fileStat, buffer] = await Promise.all([
+            stat(filePath),
+            readFile(filePath)
+        ]);
+        if (!fileStat.isFile()) {
+            throw new McpToolError("invalid_input", `Drop path is not a file: ${filePath}`);
+        }
+        return {
+            name: path.basename(filePath),
+            mimeType: mimeTypeForPath(filePath),
+            buffer: buffer.toString("base64"),
+            lastModifiedMs: fileStat.mtimeMs
+        };
+    }));
+}
+function mimeTypeForPath(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    switch (ext) {
+        case ".avif": return "image/avif";
+        case ".bmp": return "image/bmp";
+        case ".css": return "text/css";
+        case ".csv": return "text/csv";
+        case ".gif": return "image/gif";
+        case ".htm":
+        case ".html": return "text/html";
+        case ".jpeg":
+        case ".jpg": return "image/jpeg";
+        case ".js":
+        case ".mjs": return "text/javascript";
+        case ".json": return "application/json";
+        case ".md": return "text/markdown";
+        case ".pdf": return "application/pdf";
+        case ".png": return "image/png";
+        case ".svg": return "image/svg+xml";
+        case ".txt": return "text/plain";
+        case ".webp": return "image/webp";
+        case ".xml": return "application/xml";
+        case ".zip": return "application/zip";
+        default: return "application/octet-stream";
+    }
+}
+function bidiBytesValueToString(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (value.type === "base64" && value.value !== undefined) {
+        return Buffer.from(value.value, "base64").toString("utf8");
+    }
+    return value.value ?? "";
+}
+function bidiHeadersToRecord(headers) {
+    const result = {};
+    for (const header of headers ?? []) {
+        result[header.name] = bidiBytesValueToString(header.value);
+    }
+    return result;
+}
+function parseBidiNetworkEvent(payload) {
+    if (!payload || typeof payload !== "object") {
+        return undefined;
+    }
+    const event = payload;
+    if (!event.context || !event.request?.request || !event.request.method || !event.request.url) {
+        return undefined;
+    }
+    return {
+        context: event.context,
+        request: event.request,
+        ...(event.errorText !== undefined ? { errorText: event.errorText } : {}),
+        ...(event.response !== undefined ? { response: event.response } : {}),
+        ...(event.timestamp !== undefined ? { timestamp: event.timestamp } : {})
+    };
+}
+function bidiLogContext(payload) {
+    if (!payload || typeof payload !== "object" || !("source" in payload)) {
+        return undefined;
+    }
+    const context = payload.source?.context;
+    return context ?? undefined;
+}
+class BidiConnectedBrowserSession {
+    client;
+    protocol = "bidi";
+    browserName = "firefox";
+    pageConsoleStates = new Map();
+    pageNetworkStates = new Map();
+    pageDialogStates = new Map();
+    bidiListeners = new Map();
+    responseDataCollector;
+    activeTabId;
+    constructor(client) {
+        this.client = client;
+    }
+    static async connect(args) {
+        if (args.browser && args.browser !== "firefox") {
+            throw new McpToolError("unsupported_protocol_input", 'BiDi attach only supports browser "firefox" in v1.');
+        }
+        const parsed = new URL(args.endpoint);
+        if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
+            throw new McpToolError("unsupported_protocol_input", `BiDi endpoint must be a ws(s) URL. Received "${parsed.protocol}".`);
+        }
+        const client = await getBidiClientFactory()({
+            browserName: "firefox",
+            webSocketUrl: args.endpoint
+        });
+        const session = new BidiConnectedBrowserSession(client);
+        await session.initialize();
+        const tabs = await session.refreshTabs();
+        if (tabs.length === 0) {
+            await session.newTab();
+        }
+        return session;
+    }
+    async version() {
+        return `${this.browserName}/unknown`;
+    }
+    async listTabs() {
+        return this.refreshTabs();
+    }
+    async newTab(url = "about:blank") {
+        const response = await this.client.browsingContextCreate({
+            type: "tab"
+        });
+        this.activeTabId = response.context;
+        await this.client.browsingContextActivate({
+            context: response.context
+        });
+        if (url && url !== "about:blank") {
+            await this.client.browsingContextNavigate({
+                context: response.context,
+                url,
+                wait: "complete"
+            });
+        }
+        return this.refreshTabs();
+    }
+    async selectTab(tabId) {
+        this.activeTabId = tabId;
+        await this.client.browsingContextActivate({
+            context: tabId
+        });
+        return this.refreshTabs();
+    }
+    async closeTab(tabId) {
+        const tabsBeforeClose = await this.refreshTabs();
+        const index = tabsBeforeClose.findIndex((tab) => tab.id === tabId);
+        await this.client.browsingContextClose({
+            context: tabId
+        });
+        const tabsAfterClose = await this.refreshTabs();
+        if (tabsAfterClose.length === 0) {
+            this.activeTabId = undefined;
+            this.pageConsoleStates.delete(tabId);
+            this.pageNetworkStates.delete(tabId);
+            this.pageDialogStates.delete(tabId);
+            return tabsAfterClose;
+        }
+        const fallbackIndex = index >= 0 ? Math.min(index, tabsAfterClose.length - 1) : 0;
+        this.activeTabId = tabsAfterClose[fallbackIndex]?.id;
+        if (this.activeTabId) {
+            await this.client.browsingContextActivate({
+                context: this.activeTabId
+            });
+        }
+        return this.refreshTabs();
+    }
+    async snapshot(request = {}) {
+        const tabId = await this.getActiveTabId();
+        const result = await evaluateBiDi(this.client, tabId, ARIA_SNAPSHOT_EVALUATE_SOURCE, toAriaSnapshotPayload(request));
+        return toBrowserSnapshot(result, request, {
+            console: this.consoleSummary(tabId),
+            consoleLink: await this.takeConsoleLink(tabId)
+        });
+    }
+    async consoleMessages(level = "info", all = false) {
+        const activeTabId = await this.getActiveTabId();
+        const state = this.ensureConsoleState(activeTabId);
+        const startIndex = all ? 0 : state.nextMessageIndex;
+        return state.messages
+            .slice(startIndex)
+            .filter((message) => consoleLevelForMessageType(message.type) <= consoleLevelForMessageType(level))
+            .map((message) => ({
+            type: message.type,
+            text: message.text,
+            timestamp: message.timestamp,
+            locationUrl: message.locationUrl,
+            lineNumber: message.lineNumber,
+            formattedText: message.formattedText
+        }));
+    }
+    async evaluate(expression, target) {
+        const tabId = await this.getActiveTabId();
+        const source = target
+            ? String.raw `async (payload) => {
+          const state = globalThis.__roxyMcpState;
+          const element = payload.nodeToken
+            ? (state?.elements?.get(payload.nodeToken) ?? null)
+            : document.querySelector(payload.selector);
+          if (!element) throw new Error('Element not found');
+          const value = eval('(' + payload.expression + ')');
+          return typeof value === 'function' ? await value(element) : value;
+        }`
+            : String.raw `async (payload) => {
+          const value = eval('(' + payload.expression + ')');
+          return typeof value === 'function' ? await value() : value;
+        }`;
+        const payload = target ? { ...("nodeToken" in target ? { nodeToken: target.nodeToken } : { selector: target.selector }), expression } : { expression };
+        return evaluateBiDi(this.client, tabId, source, payload);
+    }
+    async isFileInput(target) {
+        const tabId = await this.getActiveTabId();
+        return evaluateBiDi(this.client, tabId, IS_FILE_INPUT_SOURCE, this.targetArg(target)).catch(() => false);
+    }
+    async click(target, options) {
+        const tabId = await this.getActiveTabId();
+        const source = "nodeToken" in target ? ACTION_POINT_EVALUATE_SOURCE : ACTION_POINT_BY_SELECTOR_SOURCE;
+        const arg = "nodeToken" in target ? { nodeToken: target.nodeToken } : { selector: target.selector };
+        const point = await evaluateBiDi(this.client, tabId, source, arg);
+        if (!point.ok || point.x === undefined || point.y === undefined) {
+            const isSelector = "selector" in target;
+            throw new McpToolError(isSelector ? "invalid_target" : "stale_ref", isSelector
+                ? `Element "${target.selector}" could not be found or is not visible.`
+                : 'The referenced element is no longer valid. Call "browser_snapshot" again.');
+        }
+        const BIDI_BUTTON = { left: 0, middle: 1, right: 2 };
+        const buttonCode = BIDI_BUTTON[options.button ?? "left"] ?? 0;
+        const cycles = options.doubleClick ? 2 : 1;
+        const modifierKeys = (options.modifiers ?? []).map((m) => {
+            const KEY_MAP = {
+                Alt: "",
+                Control: "",
+                ControlOrMeta: "",
+                Meta: "",
+                Shift: ""
+            };
+            return KEY_MAP[m] ?? m;
+        });
+        const keyDownActions = modifierKeys.map((value) => ({ type: "keyDown", value }));
+        const keyUpActions = modifierKeys.map((value) => ({ type: "keyUp", value }));
+        const pointerActions = [
+            {
+                type: "pointerMove",
+                x: Math.round(point.x),
+                y: Math.round(point.y),
+                origin: "viewport"
+            }
+        ];
+        for (let i = 0; i < cycles; i++) {
+            pointerActions.push({ type: "pointerDown", button: buttonCode });
+            pointerActions.push({ type: "pause", duration: options.clickHoldMs });
+            pointerActions.push({ type: "pointerUp", button: buttonCode });
+        }
+        const actions = [];
+        if (modifierKeys.length > 0) {
+            actions.push({ type: "key", id: "kbd", actions: [...keyDownActions, ...keyUpActions] });
+        }
+        actions.push({
+            type: "pointer",
+            id: "mouse",
+            parameters: { pointerType: "mouse" },
+            actions: pointerActions
+        });
+        await this.client.inputPerformActions({
+            context: tabId,
+            actions
+        });
+        await this.client.inputReleaseActions({ context: tabId }).catch(() => { });
+    }
+    async drag(start, end, options) {
+        const tabId = await this.getActiveTabId();
+        const startPoint = await this.actionPoint(tabId, start);
+        const endPoint = await this.actionPoint(tabId, end);
+        await this.client.inputPerformActions({
+            context: tabId,
+            actions: [
+                {
+                    type: "pointer",
+                    id: "mouse",
+                    parameters: { pointerType: "mouse" },
+                    actions: [
+                        {
+                            type: "pointerMove",
+                            x: Math.round(startPoint.x),
+                            y: Math.round(startPoint.y),
+                            origin: "viewport"
+                        },
+                        { type: "pause", duration: options.moveDelayMs },
+                        { type: "pointerDown", button: 0 },
+                        { type: "pause", duration: options.holdDelayMs },
+                        {
+                            type: "pointerMove",
+                            x: Math.round(endPoint.x),
+                            y: Math.round(endPoint.y),
+                            origin: "viewport"
+                        },
+                        { type: "pause", duration: options.moveDelayMs },
+                        { type: "pointerUp", button: 0 }
+                    ]
+                }
+            ]
+        });
+        await this.client.inputReleaseActions({ context: tabId }).catch(() => { });
+    }
+    async drop(target, payload) {
+        const files = await prepareDropFiles(payload.paths);
+        const tabId = await this.getActiveTabId();
+        const result = await evaluateBiDi(this.client, tabId, DROP_ON_ELEMENT_SOURCE, { ...this.targetArg(target), data: payload.data ?? {}, files });
+        if (!result.ok) {
+            throw new McpToolError(result.reason === "not_accepted" ? "action_failed" : "invalid_target", result.reason === "not_accepted"
+                ? "Drop target did not accept the drop; its dragover handler did not call preventDefault()."
+                : "Drop target could not be found.");
+        }
+    }
+    async hover(target) {
+        const tabId = await this.getActiveTabId();
+        const source = "nodeToken" in target ? ACTION_POINT_EVALUATE_SOURCE : ACTION_POINT_BY_SELECTOR_SOURCE;
+        const arg = "nodeToken" in target ? { nodeToken: target.nodeToken } : { selector: target.selector };
+        const point = await evaluateBiDi(this.client, tabId, source, arg);
+        if (!point.ok || point.x === undefined || point.y === undefined) {
+            const isSelector = "selector" in target;
+            throw new McpToolError(isSelector ? "invalid_target" : "stale_ref", isSelector
+                ? `Element "${target.selector}" could not be found or is not visible.`
+                : 'The referenced element is no longer valid. Call "browser_snapshot" again.');
+        }
+        await this.client.inputPerformActions({
+            context: tabId,
+            actions: [
+                {
+                    type: "pointer",
+                    id: "mouse",
+                    parameters: { pointerType: "mouse" },
+                    actions: [
+                        {
+                            type: "pointerMove",
+                            x: Math.round(point.x),
+                            y: Math.round(point.y),
+                            origin: "viewport"
+                        }
+                    ]
+                }
+            ]
+        });
+        await this.client.inputReleaseActions({ context: tabId }).catch(() => { });
+    }
+    async close() {
+        for (const [event, listener] of this.bidiListeners) {
+            this.client.removeListener(event, listener);
+        }
+        this.bidiListeners.clear();
+        if (this.responseDataCollector) {
+            await this.client.networkRemoveDataCollector({ collector: this.responseDataCollector }).catch(() => { });
+            this.responseDataCollector = undefined;
+        }
+        await this.client.sessionEnd({}).catch(() => { });
+        this.client.close();
+    }
+    async navigate(url) {
+        const tabId = await this.getActiveTabId();
+        this.resetConsole(tabId);
+        await this.client.browsingContextNavigate({ context: tabId, url, wait: "complete" });
+    }
+    async type(target, text, options) {
+        const tabId = await this.getActiveTabId();
+        const arg = "nodeToken" in target ? { nodeToken: target.nodeToken } : { selector: target.selector };
+        const result = await evaluateBiDi(this.client, tabId, TYPE_INTO_ELEMENT_SOURCE, { ...arg, text, submit: options?.submit ?? false });
+        if (!result.ok) {
+            const isSelector = "selector" in target;
+            throw new McpToolError(isSelector ? "invalid_target" : "stale_ref", result.reason === "not_found"
+                ? (isSelector ? `Element "${target.selector}" could not be found.` : 'The referenced element is no longer valid.')
+                : `Element is not a typeable input.`);
+        }
+    }
+    async pressKey(key, modifiers) {
+        const tabId = await this.getActiveTabId();
+        // WebDriver BiDi uses Unicode Private Use Area for special keys
+        const BIDI_SPECIAL_KEY = {
+            Enter: "", Return: "", Escape: "",
+            Tab: "", Backspace: "", Delete: "",
+            ArrowLeft: "", ArrowRight: "", ArrowUp: "", ArrowDown: "",
+            Home: "", End: "", PageUp: "", PageDown: "",
+            Insert: "", Space: " ",
+            F1: "", F2: "", F3: "", F4: "",
+            F5: "", F6: "", F7: "", F8: "",
+            F9: "", F10: "", F11: "", F12: "",
+        };
+        const BIDI_MODIFIER_KEY = {
+            Alt: "", Control: "", ControlOrMeta: "",
+            Meta: "", Shift: ""
+        };
+        const keyValue = BIDI_SPECIAL_KEY[key] ?? key;
+        const modifierKeys = (modifiers ?? []).map((m) => BIDI_MODIFIER_KEY[m] ?? m);
+        const keyDownActions = modifierKeys.map((value) => ({ type: "keyDown", value }));
+        const keyUpActions = [...modifierKeys].reverse().map((value) => ({ type: "keyUp", value }));
+        await this.client.inputPerformActions({
+            context: tabId,
+            actions: [
+                {
+                    type: "key",
+                    id: "kbd",
+                    actions: [
+                        ...keyDownActions,
+                        { type: "keyDown", value: keyValue },
+                        { type: "keyUp", value: keyValue },
+                        ...keyUpActions
+                    ]
+                }
+            ]
+        });
+        await this.client.inputReleaseActions({ context: tabId }).catch(() => { });
+    }
+    async selectOption(target, values) {
+        const tabId = await this.getActiveTabId();
+        const arg = "nodeToken" in target ? { nodeToken: target.nodeToken } : { selector: target.selector };
+        const result = await evaluateBiDi(this.client, tabId, SELECT_OPTION_SOURCE, { ...arg, values });
+        if (!result.ok) {
+            const isSelector = "selector" in target;
+            throw new McpToolError(isSelector ? "invalid_target" : "stale_ref", result.reason === "not_found"
+                ? (isSelector ? `Element "${target.selector}" could not be found.` : 'The referenced element is no longer valid.')
+                : `Element is not a <select> element.`);
+        }
+        return result.selected;
+    }
+    async check(target, checked) {
+        const tabId = await this.getActiveTabId();
+        const arg = "nodeToken" in target ? { nodeToken: target.nodeToken } : { selector: target.selector };
+        const result = await evaluateBiDi(this.client, tabId, CHECK_ELEMENT_SOURCE, { ...arg, checked });
+        if (!result.ok) {
+            const isSelector = "selector" in target;
+            throw new McpToolError(isSelector ? "invalid_target" : "stale_ref", result.reason === "not_found"
+                ? (isSelector ? `Element "${target.selector}" could not be found.` : 'The referenced element is no longer valid.')
+                : `Element is not a checkbox or radio button.`);
+        }
+    }
+    async goBack() {
+        const tabId = await this.getActiveTabId();
+        await this.client.browsingContextTraverseHistory({ context: tabId, delta: -1 }).catch(() => { });
+    }
+    async goForward() {
+        const tabId = await this.getActiveTabId();
+        await this.client.browsingContextTraverseHistory({ context: tabId, delta: 1 }).catch(() => { });
+    }
+    async resize(width, height) {
+        const tabId = await this.getActiveTabId();
+        await this.client.browsingContextSetViewport({
+            context: tabId,
+            viewport: { width, height }
+        });
+    }
+    async scroll(target, deltaX, deltaY) {
+        const tabId = await this.getActiveTabId();
+        const arg = target ? ("nodeToken" in target ? { nodeToken: target.nodeToken } : { selector: target.selector }) : {};
+        await evaluateBiDi(this.client, tabId, SCROLL_ELEMENT_SOURCE, { ...arg, deltaX, deltaY });
+    }
+    async screenshot(options = {}) {
+        const tabId = await this.getActiveTabId();
+        const format = options.type ?? "png";
+        const screenshotOptions = {
+            context: tabId,
+            format: { type: format === "png" ? "image/png" : "image/jpeg" }
+        };
+        if (options.target) {
+            const box = await evaluateBiDi(this.client, tabId, ELEMENT_BOX_SOURCE, this.targetArg(options.target));
+            if (!box.ok || box.x === undefined || box.y === undefined || box.width === undefined || box.height === undefined) {
+                throw new McpToolError("invalid_target", "Screenshot target could not be found.");
+            }
+            screenshotOptions.origin = "viewport";
+            screenshotOptions.clip = {
+                type: "box",
+                x: box.x,
+                y: box.y,
+                width: box.width,
+                height: box.height
+            };
+        }
+        else if (options.fullPage) {
+            const box = await evaluateBiDi(this.client, tabId, DOCUMENT_BOX_SOURCE);
+            screenshotOptions.origin = "document";
+            screenshotOptions.clip = {
+                type: "box",
+                x: box.x,
+                y: box.y,
+                width: box.width,
+                height: box.height
+            };
+        }
+        const result = await this.client.browsingContextCaptureScreenshot(screenshotOptions);
+        return {
+            data: result.data,
+            mimeType: format === "jpeg" ? "image/jpeg" : "image/png"
+        };
+    }
+    async uploadFile(target, filePaths) {
+        const tabId = await this.getActiveTabId();
+        const element = await this.sharedElementReference(tabId, target);
+        await this.client.inputSetFiles({
+            context: tabId,
+            element,
+            files: filePaths
+        });
+    }
+    async fillForm(fields) {
+        const tabId = await this.getActiveTabId();
+        for (const field of fields) {
+            const result = await evaluateBiDi(this.client, tabId, SET_FORM_FIELD_SOURCE, {
+                ...this.targetArg(field.target),
+                fieldType: field.type,
+                value: field.value
+            });
+            if (!result.ok) {
+                throw new McpToolError("invalid_target", `Unable to fill form field: ${result.reason ?? "unknown error"}.`);
+            }
+        }
+    }
+    async handleDialog(accept, promptText) {
+        const tabId = await this.getActiveTabId();
+        if (!this.pageDialogStates.has(tabId)) {
+            throw new McpToolError("no_dialog", "No dialog visible.");
+        }
+        this.pageDialogStates.delete(tabId);
+        await this.client.browsingContextHandleUserPrompt({
+            context: tabId,
+            accept,
+            ...(promptText !== undefined ? { userText: promptText } : {})
+        });
+    }
+    async networkRequests() {
+        const tabId = await this.getActiveTabId();
+        return this.ensureNetworkState(tabId).requests.map(cloneNetworkRequest);
+    }
+    async networkRequest(index) {
+        const tabId = await this.getActiveTabId();
+        const request = this.ensureNetworkState(tabId).requests[index - 1];
+        return request ? cloneNetworkRequest(request) : undefined;
+    }
+    async runCodeUnsafe(code) {
+        return this.evaluate(`async () => {
+      const fn = eval(${JSON.stringify(`(${code})`)});
+      if (typeof fn !== 'function') throw new Error('Code must evaluate to a function.');
+      return await fn({
+        evaluate: async expression => {
+          const value = typeof expression === 'function' ? expression : eval('(' + expression + ')');
+          return typeof value === 'function' ? await value() : value;
+        },
+        title: () => document.title,
+        url: () => location.href
+      });
+    }`);
+    }
+    async initialize() {
+        await this.client.sessionSubscribe({
+            events: [
+                "browsingContext.userPromptOpened",
+                "log.entryAdded",
+                "network.beforeRequestSent",
+                "network.responseCompleted",
+                "network.fetchError",
+                "network.responseStarted"
+            ]
+        }).catch(() => undefined);
+        const collectorResult = await this.client.networkAddDataCollector({
+            dataTypes: ["response"],
+            maxEncodedDataSize: 10_000_000
+        }).catch(() => undefined);
+        this.responseDataCollector = collectorResult?.collector;
+        this.attachBiDiListeners();
+    }
+    attachBiDiListeners() {
+        this.attachBiDiListener("log.entryAdded", (payload) => this.handleLogEntry(payload));
+        this.attachBiDiListener("browsingContext.userPromptOpened", (payload) => this.handleUserPromptOpened(payload));
+        this.attachBiDiListener("network.beforeRequestSent", (payload) => this.handleBeforeRequestSent(payload));
+        this.attachBiDiListener("network.responseStarted", (payload) => this.handleResponseStarted(payload));
+        this.attachBiDiListener("network.responseCompleted", (payload) => void this.handleResponseCompleted(payload));
+        this.attachBiDiListener("network.fetchError", (payload) => this.handleFetchError(payload));
+    }
+    attachBiDiListener(event, listener) {
+        this.bidiListeners.set(event, listener);
+        this.client.on(event, listener);
+    }
+    async refreshTabs() {
+        const response = await this.client.browsingContextGetTree({});
+        const tabs = await Promise.all(response.contexts
+            .filter((context) => context.parent === undefined || context.parent === null)
+            .map(async (context) => ({
+            id: context.context,
+            title: await this.titleForContext(context.context),
+            url: context.url
+        })));
+        if (!this.activeTabId) {
+            this.activeTabId = chooseInitialTab(tabs);
+        }
+        return tabs.map((tab) => ({
+            ...tab,
+            active: tab.id === this.activeTabId
+        }));
+    }
+    async getActiveTabId() {
+        const tabs = await this.refreshTabs();
+        const activeTab = tabs.find((tab) => tab.active);
+        if (!activeTab) {
+            throw new McpToolError("no_active_tab", "No active tab is available.");
+        }
+        return activeTab.id;
+    }
+    targetArg(target) {
+        return "nodeToken" in target ? { nodeToken: target.nodeToken } : { selector: target.selector };
+    }
+    async actionPoint(tabId, target) {
+        const source = "nodeToken" in target ? ACTION_POINT_EVALUATE_SOURCE : ACTION_POINT_BY_SELECTOR_SOURCE;
+        const point = await evaluateBiDi(this.client, tabId, source, this.targetArg(target));
+        if (!point.ok || point.x === undefined || point.y === undefined) {
+            const isSelector = "selector" in target;
+            throw new McpToolError(isSelector ? "invalid_target" : "stale_ref", isSelector
+                ? `Element "${target.selector}" could not be found or is not visible.`
+                : 'The referenced element is no longer valid. Call "browser_snapshot" again.');
+        }
+        return { x: point.x, y: point.y };
+    }
+    async sharedElementReference(tabId, target) {
+        const reference = await evaluateBiDiRef(this.client, tabId, GET_ELEMENT_OBJECT_SOURCE, this.targetArg(target));
+        if (!reference.sharedId) {
+            const isSelector = "selector" in target;
+            throw new McpToolError(isSelector ? "invalid_target" : "stale_ref", isSelector ? `Element "${target.selector}" could not be found.` : 'The referenced element is no longer valid.');
+        }
+        return {
+            sharedId: reference.sharedId,
+            ...(reference.handle !== undefined ? { handle: reference.handle } : {})
+        };
+    }
+    async titleForContext(contextId) {
+        try {
+            return await evaluateBiDi(this.client, contextId, String.raw `() => document.title || ""`);
+        }
+        catch {
+            return "";
+        }
+    }
+    handleLogEntry(payload) {
+        const context = bidiLogContext(payload);
+        if (!context) {
+            return;
+        }
+        const log = payload;
+        const frame = log.stackTrace?.callFrames?.[0];
+        const text = log.text ?? (log.args ? formatConsoleText(log.args) : "");
+        const type = log.method ?? log.level ?? log.type ?? "log";
+        const locationUrl = frame?.url ?? "";
+        const lineNumber = frame?.lineNumber ?? 0;
+        this.addConsoleMessage(context, {
+            type,
+            timestamp: normalizeConsoleTimestamp(log.timestamp),
+            text,
+            locationUrl,
+            lineNumber,
+            formattedText: formatConsoleMessage(type, text, locationUrl, lineNumber)
+        });
+    }
+    handleUserPromptOpened(payload) {
+        if (!payload || typeof payload !== "object" || !("context" in payload)) {
+            return;
+        }
+        const event = payload;
+        this.pageDialogStates.set(event.context, {
+            message: event.message ?? "",
+            type: event.type ?? "alert",
+            ...(event.defaultValue !== undefined ? { defaultPrompt: event.defaultValue } : {})
+        });
+    }
+    handleBeforeRequestSent(payload) {
+        const event = parseBidiNetworkEvent(payload);
+        if (!event) {
+            return;
+        }
+        const state = this.ensureNetworkState(event.context);
+        const existing = state.byRequestId.get(event.request.request);
+        const request = existing ?? {
+            index: state.requests.length + 1,
+            requestId: event.request.request,
+            method: event.request.method,
+            url: event.request.url,
+            resourceType: normalizeResourceType(event.request.destination),
+            requestHeaders: {},
+        };
+        request.method = event.request.method;
+        request.url = event.request.url;
+        request.resourceType = normalizeResourceType(event.request.destination);
+        request.requestHeaders = normalizeHeaders(bidiHeadersToRecord(event.request.headers));
+        if (event.request.bodySize !== undefined && event.request.bodySize > 0) {
+            request.requestBody ??= "";
+        }
+        if (!existing) {
+            state.requests.push(request);
+            state.byRequestId.set(event.request.request, request);
+        }
+        if (event.timestamp !== undefined) {
+            state.startedAt.set(event.request.request, event.timestamp);
+        }
+    }
+    handleResponseStarted(payload) {
+        const event = parseBidiNetworkEvent(payload);
+        if (!event?.response) {
+            return;
+        }
+        const request = this.ensureNetworkRequest(event);
+        request.status = event.response.status;
+        request.statusText = event.response.statusText ?? "";
+        request.responseHeaders = normalizeHeaders(bidiHeadersToRecord(event.response.headers));
+        request.mimeType = event.response.mimeType;
+    }
+    async handleResponseCompleted(payload) {
+        const event = parseBidiNetworkEvent(payload);
+        if (!event?.response) {
+            return;
+        }
+        const request = this.ensureNetworkRequest(event);
+        request.status = event.response.status;
+        request.statusText = event.response.statusText ?? "";
+        request.responseHeaders = normalizeHeaders(bidiHeadersToRecord(event.response.headers));
+        request.mimeType = event.response.mimeType;
+        const startedAt = this.ensureNetworkState(event.context).startedAt.get(event.request.request);
+        if (startedAt !== undefined && event.timestamp !== undefined) {
+            request.durationMs = Math.round(event.timestamp - startedAt);
+        }
+        if (canReadResponseBody(request)) {
+            const body = await this.getResponseBody(event.request.request).catch(() => undefined);
+            if (body !== undefined) {
+                request.responseBody = body;
+            }
+        }
+    }
+    handleFetchError(payload) {
+        const event = parseBidiNetworkEvent(payload);
+        if (!event) {
+            return;
+        }
+        const request = this.ensureNetworkRequest(event);
+        request.failureText = event.errorText ?? "Unknown error";
+        const startedAt = this.ensureNetworkState(event.context).startedAt.get(event.request.request);
+        if (startedAt !== undefined && event.timestamp !== undefined) {
+            request.durationMs = Math.round(event.timestamp - startedAt);
+        }
+    }
+    ensureNetworkRequest(event) {
+        const state = this.ensureNetworkState(event.context);
+        let request = state.byRequestId.get(event.request.request);
+        if (!request) {
+            request = {
+                index: state.requests.length + 1,
+                requestId: event.request.request,
+                method: event.request.method,
+                url: event.request.url,
+                resourceType: normalizeResourceType(event.request.destination),
+                requestHeaders: normalizeHeaders(bidiHeadersToRecord(event.request.headers)),
+            };
+            state.requests.push(request);
+            state.byRequestId.set(event.request.request, request);
+        }
+        return request;
+    }
+    async getResponseBody(requestId) {
+        if (!this.responseDataCollector) {
+            return undefined;
+        }
+        const response = await this.client.networkGetData({
+            collector: this.responseDataCollector,
+            dataType: "response",
+            request: requestId
+        });
+        return response.bytes ? bidiBytesValueToString(response.bytes) : undefined;
+    }
+    ensureConsoleState(tabId) {
+        let state = this.pageConsoleStates.get(tabId);
+        if (!state) {
+            state = {
+                messages: [],
+                nextMessageIndex: 0,
+                logStartTime: Date.now(),
+                logLine: 0
+            };
+            this.pageConsoleStates.set(tabId, state);
+        }
+        return state;
+    }
+    ensureNetworkState(tabId) {
+        let state = this.pageNetworkStates.get(tabId);
+        if (!state) {
+            state = {
+                requests: [],
+                byRequestId: new Map(),
+                startedAt: new Map()
+            };
+            this.pageNetworkStates.set(tabId, state);
+        }
+        return state;
+    }
+    resetConsole(tabId) {
+        this.pageConsoleStates.set(tabId, {
+            messages: [],
+            nextMessageIndex: 0,
+            logStartTime: Date.now(),
+            logLine: 0
+        });
+        this.pageNetworkStates.set(tabId, {
+            requests: [],
+            byRequestId: new Map(),
+            startedAt: new Map()
+        });
+        this.pageDialogStates.delete(tabId);
+    }
+    addConsoleMessage(tabId, message) {
+        const state = this.ensureConsoleState(tabId);
+        if (!shouldIncludeConsoleMessage(message.type)) {
+            return;
+        }
+        state.messages.push(message);
+    }
+    consoleSummary(tabId) {
+        const messages = this.ensureConsoleState(tabId).messages;
+        let errors = 0;
+        let warnings = 0;
+        for (const message of messages) {
+            if (message.type === "error" || message.type === "assert") {
+                errors++;
+            }
+            else if (message.type === "warning") {
+                warnings++;
+            }
+        }
+        return { total: messages.length, errors, warnings };
+    }
+    async takeConsoleLink(tabId) {
+        const state = this.ensureConsoleState(tabId);
+        const messages = state.messages.slice(state.nextMessageIndex);
+        if (messages.length === 0) {
+            return undefined;
+        }
+        state.logFile ??= path.join(process.cwd(), ".playwright-mcp", `console-${new Date(state.logStartTime).toISOString().replace(/[:.]/g, "-")}.log`);
+        await mkdir(path.dirname(state.logFile), { recursive: true });
+        const fromLine = state.logLine + 1;
+        for (const message of messages) {
+            const relativeTime = Math.round(message.timestamp - state.logStartTime);
+            const logLine = `[${String(relativeTime).padStart(8, " ")}ms] ${message.formattedText}\n`;
+            await appendFile(state.logFile, logLine);
+            state.logLine += logLine.split("\n").length - 1;
+        }
+        state.nextMessageIndex = state.messages.length;
+        const relativePath = path.relative(process.cwd(), state.logFile);
+        const lineRange = fromLine === state.logLine ? `#L${fromLine}` : `#L${fromLine}-L${state.logLine}`;
+        return `${relativePath}${lineRange}`;
+    }
+}
+export async function connectBrowserSession(args) {
+    if (args.protocol === "cdp") {
+        return CdpConnectedBrowserSession.connect(args);
+    }
+    return BidiConnectedBrowserSession.connect(args);
+}
+//# sourceMappingURL=connectedBrowser.js.map