@godscene/web 1.7.11

package/README.md

@@ -0,0 +1,7 @@
+# @midscene/web
+
+Automate UI actions, extract data, and perform assertions using AI for web browsers.
+
+- **Playwright integration**: <https://midscenejs.com/integrate-with-playwright.html>
+- **Puppeteer integration**: <https://midscenejs.com/integrate-with-puppeteer.html>
+- **Bridge mode**: <https://midscenejs.com/bridge-mode.html>

package/bin/midscene-playground

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('../dist/lib/bin.js');

package/bin/midscene-web

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../dist/lib/cli.js');

package/dist/es/bin.mjs

@@ -0,0 +1,14 @@
+import { launchPreparedPlaygroundPlatform } from "@godscene/playground";
+import "dotenv/config";
+import { webPlaygroundPlatform } from "./platform.mjs";
+async function startServer() {
+    const prepared = await webPlaygroundPlatform.prepare({
+        launchOptions: {
+            openBrowser: false,
+            verbose: false
+        }
+    });
+    const { server } = await launchPreparedPlaygroundPlatform(prepared);
+    console.log(`Midscene playground server is running on http://localhost:${server.port}`);
+}
+startServer().catch(console.error);

package/dist/es/bridge-mode/agent-cli-side.mjs

@@ -0,0 +1,135 @@
+import { Agent } from "@godscene/core/agent";
+import { assert } from "@godscene/shared/utils";
+import { commonWebActionsForWebPage } from "../web-page.mjs";
+import { BridgeEvent, BridgePageType, DefaultBridgeServerHost, DefaultBridgeServerPort, KeyboardEvent, MouseEvent, getBridgeServerHost } from "./common.mjs";
+import { BridgeServer } from "./io-server.mjs";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
+const getBridgePageInCliSide = (options)=>{
+    const host = options?.host || DefaultBridgeServerHost;
+    const port = options?.port || DefaultBridgeServerPort;
+    const server = new BridgeServer(host, port, void 0, void 0, options?.closeConflictServer);
+    server.listen({
+        timeout: options?.timeout
+    });
+    const bridgeCaller = (method, timeout)=>async (...args)=>{
+            const response = await server.call(method, args, timeout);
+            return response;
+        };
+    const page = {
+        showStatusMessage: async (message)=>{
+            await server.call(BridgeEvent.UpdateAgentStatus, [
+                message
+            ]);
+        }
+    };
+    const proxyPage = new Proxy(page, {
+        get (target, prop, receiver) {
+            assert('string' == typeof prop, 'prop must be a string');
+            if ('toJSON' === prop) return ()=>({
+                    interfaceType: BridgePageType
+                });
+            if ('interfaceType' === prop) return BridgePageType;
+            if ('actionSpace' === prop) return ()=>commonWebActionsForWebPage(proxyPage);
+            if (Object.keys(page).includes(prop)) return page[prop];
+            if ('mouse' === prop) {
+                const mouse = {
+                    click: bridgeCaller(MouseEvent.Click),
+                    wheel: bridgeCaller(MouseEvent.Wheel),
+                    move: bridgeCaller(MouseEvent.Move),
+                    drag: bridgeCaller(MouseEvent.Drag)
+                };
+                return mouse;
+            }
+            if ('keyboard' === prop) {
+                const keyboard = {
+                    type: bridgeCaller(KeyboardEvent.Type),
+                    press: bridgeCaller(KeyboardEvent.Press)
+                };
+                return keyboard;
+            }
+            if ('destroy' === prop) return async (...args)=>{
+                try {
+                    const caller = bridgeCaller('destroy');
+                    await caller(...args);
+                } catch (e) {}
+                return server.close();
+            };
+            if ('connectNewTabWithUrl' === prop) return async (url, options)=>{
+                const timeout = options?.timeout;
+                const caller = bridgeCaller(prop, timeout);
+                return await caller(url, options);
+            };
+            if ('connectCurrentTab' === prop) return async (options)=>{
+                const timeout = options?.timeout;
+                const caller = bridgeCaller(prop, timeout);
+                return await caller(options);
+            };
+            return bridgeCaller(prop);
+        }
+    });
+    return proxyPage;
+};
+class AgentOverChromeBridge extends Agent {
+    async setDestroyOptionsAfterConnect() {
+        if (this.destroyAfterDisconnectFlag) this.page.setDestroyOptions({
+            closeTab: true
+        });
+    }
+    async connectNewTabWithUrl(url, options) {
+        await this.page.connectNewTabWithUrl(url, options);
+        await sleep(500);
+        await this.setDestroyOptionsAfterConnect();
+    }
+    async getBrowserTabList() {
+        return await this.page.getBrowserTabList();
+    }
+    async setActiveTabId(tabId) {
+        return await this.page.setActiveTabId(Number.parseInt(tabId));
+    }
+    async connectCurrentTab(options) {
+        await this.page.connectCurrentTab(options);
+        await sleep(500);
+        await this.setDestroyOptionsAfterConnect();
+    }
+    async aiAct(prompt, options) {
+        if (options) console.warn('the `options` parameter of aiAct is not supported in cli side');
+        return await super.aiAct(prompt);
+    }
+    async destroy(closeNewTabsAfterDisconnect) {
+        if ('boolean' == typeof closeNewTabsAfterDisconnect) await this.page.setDestroyOptions({
+            closeTab: closeNewTabsAfterDisconnect
+        });
+        await super.destroy();
+    }
+    constructor(opts){
+        const host = getBridgeServerHost({
+            host: opts?.host,
+            allowRemoteAccess: opts?.allowRemoteAccess
+        });
+        const page = getBridgePageInCliSide({
+            host,
+            port: opts?.port,
+            timeout: opts?.serverListeningTimeout,
+            closeConflictServer: opts?.closeConflictServer
+        });
+        const originalOnTaskStartTip = opts?.onTaskStartTip;
+        super(page, Object.assign(opts || {}, {
+            onTaskStartTip: (tip)=>{
+                this.page.showStatusMessage(tip);
+                if (originalOnTaskStartTip) originalOnTaskStartTip?.call(this, tip);
+            }
+        })), _define_property(this, "destroyAfterDisconnectFlag", void 0);
+        this.destroyAfterDisconnectFlag = opts?.closeNewTabsAfterDisconnect;
+    }
+}
+export { AgentOverChromeBridge, getBridgePageInCliSide };

package/dist/es/bridge-mode/browser.mjs

@@ -0,0 +1,2 @@
+import { ExtensionBridgePageBrowserSide } from "./page-browser-side.mjs";
+export { ExtensionBridgePageBrowserSide };

package/dist/es/bridge-mode/common.mjs

@@ -0,0 +1,41 @@
+const DefaultBridgeServerHost = '127.0.0.1';
+const DefaultBridgeServerPort = 3766;
+const DefaultLocalEndpoint = `http://${DefaultBridgeServerHost}:${DefaultBridgeServerPort}`;
+const BridgeCallTimeout = 30000;
+function getBridgeServerHost(options) {
+    if (options?.host) return options.host;
+    if (options?.allowRemoteAccess) return '0.0.0.0';
+    return DefaultBridgeServerHost;
+}
+var common_BridgeEvent = /*#__PURE__*/ function(BridgeEvent) {
+    BridgeEvent["Call"] = "bridge-call";
+    BridgeEvent["CallResponse"] = "bridge-call-response";
+    BridgeEvent["UpdateAgentStatus"] = "bridge-update-agent-status";
+    BridgeEvent["Message"] = "bridge-message";
+    BridgeEvent["Connected"] = "bridge-connected";
+    BridgeEvent["Refused"] = "bridge-refused";
+    BridgeEvent["ConnectNewTabWithUrl"] = "connectNewTabWithUrl";
+    BridgeEvent["ConnectCurrentTab"] = "connectCurrentTab";
+    BridgeEvent["GetBrowserTabList"] = "getBrowserTabList";
+    BridgeEvent["SetDestroyOptions"] = "setDestroyOptions";
+    BridgeEvent["SetActiveTabId"] = "setActiveTabId";
+    return BridgeEvent;
+}({});
+const BridgeSignalKill = 'MIDSCENE_BRIDGE_SIGNAL_KILL';
+var common_MouseEvent = /*#__PURE__*/ function(MouseEvent) {
+    MouseEvent["PREFIX"] = "mouse.";
+    MouseEvent["Click"] = "mouse.click";
+    MouseEvent["Wheel"] = "mouse.wheel";
+    MouseEvent["Move"] = "mouse.move";
+    MouseEvent["Drag"] = "mouse.drag";
+    return MouseEvent;
+}({});
+var common_KeyboardEvent = /*#__PURE__*/ function(KeyboardEvent) {
+    KeyboardEvent["PREFIX"] = "keyboard.";
+    KeyboardEvent["Type"] = "keyboard.type";
+    KeyboardEvent["Press"] = "keyboard.press";
+    return KeyboardEvent;
+}({});
+const BridgePageType = 'page-over-chrome-extension-bridge';
+const BridgeErrorCodeNoClientConnected = 'no-client-connected';
+export { BridgeCallTimeout, BridgeErrorCodeNoClientConnected, common_BridgeEvent as BridgeEvent, BridgePageType, BridgeSignalKill, DefaultBridgeServerHost, DefaultBridgeServerPort, DefaultLocalEndpoint, common_KeyboardEvent as KeyboardEvent, common_MouseEvent as MouseEvent, getBridgeServerHost };

package/dist/es/bridge-mode/index.mjs

@@ -0,0 +1,4 @@
+import { AgentOverChromeBridge } from "./agent-cli-side.mjs";
+import { overrideAIConfig } from "@godscene/shared/env";
+import { killRunningServer } from "./io-server.mjs";
+export { AgentOverChromeBridge, killRunningServer, overrideAIConfig };

package/dist/es/bridge-mode/io-client.mjs

@@ -0,0 +1,99 @@
+import { assert } from "@godscene/shared/utils";
+import { io } from "socket.io-client";
+import { BridgeEvent } from "./common.mjs";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class BridgeClient {
+    async connect() {
+        return new Promise((resolve, reject)=>{
+            const forceWebSocket = "u" < typeof XMLHttpRequest;
+            this.socket = io(this.endpoint, {
+                reconnection: false,
+                ...forceWebSocket ? {
+                    transports: [
+                        'websocket'
+                    ]
+                } : {},
+                query: {
+                    version: "1.7.10"
+                }
+            });
+            const timeout = setTimeout(()=>{
+                try {
+                    this.socket?.offAny();
+                    this.socket?.close();
+                } catch (e) {
+                    console.warn('got error when offing socket', e);
+                }
+                this.socket = null;
+                reject(new Error('failed to connect to bridge server after timeout'));
+            }, 5000);
+            this.socket.on('disconnect', (reason)=>{
+                this.socket = null;
+                this.onDisconnect?.();
+            });
+            this.socket.on('connect_error', (e)=>{
+                console.error('bridge-connect-error', e);
+                reject(new Error(e || 'bridge connect error'));
+            });
+            this.socket.on(BridgeEvent.Connected, (payload)=>{
+                clearTimeout(timeout);
+                this.serverVersion = payload?.version || 'unknown';
+                resolve(this.socket);
+            });
+            this.socket.on(BridgeEvent.Refused, (e)=>{
+                console.error('bridge-refused', e);
+                try {
+                    this.socket?.disconnect();
+                } catch (e) {}
+                reject(new Error(e || 'bridge refused'));
+            });
+            this.socket.on(BridgeEvent.Call, (call)=>{
+                const id = call.id;
+                assert(void 0 !== id, 'call id is required');
+                (async ()=>{
+                    let response;
+                    try {
+                        response = await this.onBridgeCall(call.method, call.args);
+                    } catch (e) {
+                        const errorContent = `Error from bridge client when calling, method: ${call.method}, args: ${call.args}, error: ${e?.message || e}\n${e?.stack || ''}`;
+                        console.error(errorContent);
+                        return this.socket?.emit(BridgeEvent.CallResponse, {
+                            id,
+                            error: errorContent
+                        });
+                    }
+                    this.socket?.emit(BridgeEvent.CallResponse, {
+                        id,
+                        response
+                    });
+                })();
+            });
+        });
+    }
+    disconnect() {
+        this.socket?.disconnect();
+        this.socket = null;
+    }
+    constructor(endpoint, onBridgeCall, onDisconnect){
+        _define_property(this, "endpoint", void 0);
+        _define_property(this, "onBridgeCall", void 0);
+        _define_property(this, "onDisconnect", void 0);
+        _define_property(this, "socket", void 0);
+        _define_property(this, "serverVersion", void 0);
+        this.endpoint = endpoint;
+        this.onBridgeCall = onBridgeCall;
+        this.onDisconnect = onDisconnect;
+        this.socket = null;
+        this.serverVersion = null;
+    }
+}
+export { BridgeClient };

package/dist/es/bridge-mode/io-server.mjs

@@ -0,0 +1,218 @@
+import { createServer } from "node:http";
+import { sleep } from "@godscene/core/utils";
+import { logMsg } from "@godscene/shared/utils";
+import { Server } from "socket.io";
+import { io } from "socket.io-client";
+import { BridgeCallTimeout, BridgeErrorCodeNoClientConnected, BridgeEvent, BridgeSignalKill, DefaultBridgeServerPort } from "./common.mjs";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const killRunningServer = async (port, host = 'localhost')=>{
+    try {
+        const client = io(`ws://${host}:${port || DefaultBridgeServerPort}`, {
+            query: {
+                [BridgeSignalKill]: 1
+            }
+        });
+        await sleep(300);
+        await client.close();
+    } catch (e) {}
+};
+class BridgeServer {
+    async listen(opts = {}) {
+        const { timeout = 30000 } = opts;
+        if (this.closeConflictServer) await killRunningServer(this.port, this.host);
+        return new Promise((resolve, reject)=>{
+            if (this.listeningTimerFlag) return reject(new Error('already listening'));
+            this.listeningTimerFlag = true;
+            this.listeningTimeoutId = timeout ? setTimeout(()=>{
+                reject(new Error(`no extension connected after ${timeout}ms (${BridgeErrorCodeNoClientConnected})`));
+            }, timeout) : null;
+            this.connectionTipTimer = !timeout || timeout > 3000 ? setTimeout(()=>{
+                logMsg('waiting for bridge to connect...');
+            }, 2000) : null;
+            const httpServer = createServer();
+            httpServer.once('listening', ()=>{
+                resolve();
+            });
+            httpServer.once('error', (err)=>{
+                reject(new Error(`Bridge Listening Error: ${err.message}`));
+            });
+            if ('127.0.0.1' === this.host) httpServer.listen(this.port);
+            else httpServer.listen(this.port, this.host);
+            this.io = new Server(httpServer, {
+                maxHttpBufferSize: 104857600,
+                pingTimeout: 60000
+            });
+            this.io.use((socket, next)=>{
+                if (socket.handshake.url.includes(BridgeSignalKill)) return next();
+                if (this.socket?.connected) return next(new Error('server already connected by another client'));
+                next();
+            });
+            this.io.on('connection', (socket)=>{
+                const url = socket.handshake.url;
+                if (url.includes(BridgeSignalKill)) {
+                    console.warn('kill signal received, closing bridge server');
+                    return this.close();
+                }
+                this.connectionLost = false;
+                this.connectionLostReason = '';
+                this.listeningTimeoutId && clearTimeout(this.listeningTimeoutId);
+                this.listeningTimeoutId = null;
+                this.connectionTipTimer && clearTimeout(this.connectionTipTimer);
+                this.connectionTipTimer = null;
+                if (this.socket?.connected) {
+                    socket.emit(BridgeEvent.Refused);
+                    socket.disconnect();
+                    logMsg('refused new connection: server already connected by another client');
+                    return;
+                }
+                if (this.socket) {
+                    try {
+                        this.socket.disconnect();
+                    } catch (e) {
+                        logMsg(`failed to disconnect stale socket: ${e}`);
+                    }
+                    this.socket = null;
+                }
+                try {
+                    logMsg('one client connected');
+                    this.socket = socket;
+                    const clientVersion = socket.handshake.query.version;
+                    logMsg(`Bridge connected, cli-side version v1.7.10, browser-side version v${clientVersion}`);
+                    socket.on(BridgeEvent.CallResponse, (params)=>{
+                        const id = params.id;
+                        const response = params.response;
+                        const error = params.error;
+                        this.triggerCallResponseCallback(id, error, response);
+                    });
+                    socket.on('disconnect', (reason)=>{
+                        this.connectionLost = true;
+                        this.connectionLostReason = reason;
+                        this.socket = null;
+                        for(const id in this.calls){
+                            const call = this.calls[id];
+                            if (!call.responseTime) {
+                                const errorMessage = this.connectionLostErrorMsg();
+                                this.triggerCallResponseCallback(id, new Error(errorMessage), null);
+                            }
+                        }
+                        for(const id in this.calls)if (this.calls[id].responseTime) delete this.calls[id];
+                        this.onDisconnect?.(reason);
+                    });
+                    setTimeout(()=>{
+                        this.onConnect?.();
+                        const payload = {
+                            version: "1.7.10"
+                        };
+                        socket.emit(BridgeEvent.Connected, payload);
+                        Promise.resolve().then(()=>{
+                            for(const id in this.calls)if (0 === this.calls[id].callTime) this.emitCall(id);
+                        });
+                    }, 0);
+                } catch (e) {
+                    logMsg(`failed to handle connection event: ${e}`);
+                }
+            });
+            this.io.on('close', ()=>{
+                this.close();
+            });
+        });
+    }
+    async triggerCallResponseCallback(id, error, response) {
+        const call = this.calls[id];
+        if (!call) throw new Error(`call ${id} not found`);
+        if (error) call.error = error instanceof Error ? error : new Error('string' == typeof error ? error : String(error));
+        else call.error = void 0;
+        call.response = response;
+        call.responseTime = Date.now();
+        call.callback(call.error, response);
+    }
+    async emitCall(id) {
+        const call = this.calls[id];
+        if (!call) throw new Error(`call ${id} not found`);
+        if (this.connectionLost) {
+            const message = `Connection lost, reason: ${this.connectionLostReason}`;
+            call.callback(new Error(message), null);
+            return;
+        }
+        if (this.socket) {
+            this.socket.emit(BridgeEvent.Call, {
+                id,
+                method: call.method,
+                args: call.args
+            });
+            call.callTime = Date.now();
+        }
+    }
+    async call(method, args, timeout = BridgeCallTimeout) {
+        const id = `${this.callId++}`;
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
+                logMsg(`bridge call timeout, id=${id}, method=${method}, args=`, args);
+                this.calls[id].error = new Error(`Bridge call timeout after ${timeout}ms: ${method}`);
+                reject(this.calls[id].error);
+            }, timeout);
+            this.calls[id] = {
+                method,
+                args,
+                response: null,
+                callTime: 0,
+                responseTime: 0,
+                callback: (error, response)=>{
+                    clearTimeout(timeoutId);
+                    if (error) reject(error);
+                    else resolve(response);
+                }
+            };
+            this.emitCall(id);
+        });
+    }
+    async close() {
+        this.listeningTimeoutId && clearTimeout(this.listeningTimeoutId);
+        this.connectionTipTimer && clearTimeout(this.connectionTipTimer);
+        const closeProcess = this.io?.close();
+        this.io = null;
+        return closeProcess;
+    }
+    constructor(host, port, onConnect, onDisconnect, closeConflictServer){
+        _define_property(this, "host", void 0);
+        _define_property(this, "port", void 0);
+        _define_property(this, "onConnect", void 0);
+        _define_property(this, "onDisconnect", void 0);
+        _define_property(this, "closeConflictServer", void 0);
+        _define_property(this, "callId", void 0);
+        _define_property(this, "io", void 0);
+        _define_property(this, "socket", void 0);
+        _define_property(this, "listeningTimeoutId", void 0);
+        _define_property(this, "listeningTimerFlag", void 0);
+        _define_property(this, "connectionTipTimer", void 0);
+        _define_property(this, "calls", void 0);
+        _define_property(this, "connectionLost", void 0);
+        _define_property(this, "connectionLostReason", void 0);
+        _define_property(this, "connectionLostErrorMsg", void 0);
+        this.host = host;
+        this.port = port;
+        this.onConnect = onConnect;
+        this.onDisconnect = onDisconnect;
+        this.closeConflictServer = closeConflictServer;
+        this.callId = 0;
+        this.io = null;
+        this.socket = null;
+        this.listeningTimeoutId = null;
+        this.listeningTimerFlag = false;
+        this.connectionTipTimer = null;
+        this.calls = {};
+        this.connectionLost = false;
+        this.connectionLostReason = '';
+        this.connectionLostErrorMsg = ()=>`Connection lost, reason: ${this.connectionLostReason}`;
+    }
+}
+export { BridgeServer, killRunningServer };

package/dist/es/bridge-mode/page-browser-side.mjs

@@ -0,0 +1,119 @@
+import { assert } from "@godscene/shared/utils";
+import page from "../chrome-extension/page.mjs";
+import { BridgeEvent, DefaultBridgeServerPort, KeyboardEvent, MouseEvent } from "./common.mjs";
+import { BridgeClient } from "./io-client.mjs";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class ExtensionBridgePageBrowserSide extends page {
+    async setupBridgeClient() {
+        const endpoint = this.serverEndpoint || `ws://localhost:${DefaultBridgeServerPort}`;
+        let resolveConfirmationGate = ()=>{};
+        if (this.onConnectionRequest) this.confirmationPromise = new Promise((resolve)=>{
+            resolveConfirmationGate = resolve;
+        });
+        this.bridgeClient = new BridgeClient(endpoint, async (method, args)=>{
+            if (this.confirmationPromise) {
+                const allowed = await this.confirmationPromise;
+                if (!allowed) throw new Error('Connection denied by user');
+            }
+            this.onLogMessage(`bridge call from cli side: ${method}`, 'log');
+            if (method === BridgeEvent.ConnectNewTabWithUrl) return this.connectNewTabWithUrl.apply(this, args);
+            if (method === BridgeEvent.GetBrowserTabList) return this.getBrowserTabList.apply(this, args);
+            if (method === BridgeEvent.SetActiveTabId) return this.setActiveTabId.apply(this, args);
+            if (method === BridgeEvent.ConnectCurrentTab) return this.connectCurrentTab.apply(this, args);
+            if (method === BridgeEvent.UpdateAgentStatus) return this.onLogMessage(args[0], 'status');
+            const tabId = await this.getActiveTabId();
+            if (!tabId || 0 === tabId) throw new Error('no tab is connected');
+            if (method.startsWith(MouseEvent.PREFIX)) {
+                const actionName = method.split('.')[1];
+                return this.mouse[actionName].apply(this.mouse, args);
+            }
+            if (method.startsWith(KeyboardEvent.PREFIX)) {
+                const actionName = method.split('.')[1];
+                return this.keyboard[actionName].apply(this.keyboard, args);
+            }
+            if (!this[method]) return void this.onLogMessage(`method not found: ${method}`, 'log');
+            try {
+                const result = await this[method](...args);
+                return result;
+            } catch (e) {
+                const errorMessage = e instanceof Error ? e.message : 'Unknown error';
+                this.onLogMessage(`Error calling method: ${method}, ${errorMessage}`, 'log');
+                throw new Error(errorMessage, {
+                    cause: e
+                });
+            }
+        }, ()=>this.destroy());
+        await this.bridgeClient.connect();
+        if (this.onConnectionRequest) {
+            this.onLogMessage('Waiting for user confirmation...', 'log');
+            const allowed = await this.onConnectionRequest();
+            resolveConfirmationGate(allowed);
+            this.confirmationPromise = null;
+            if (!allowed) {
+                this.onLogMessage('Connection denied by user', 'log');
+                this.bridgeClient.disconnect();
+                this.bridgeClient = null;
+                throw new Error('Connection denied by user');
+            }
+        }
+        this.onLogMessage(`Bridge connected, cli-side version v${this.bridgeClient.serverVersion}, browser-side version v1.7.10`, 'log');
+    }
+    async connect() {
+        return await this.setupBridgeClient();
+    }
+    async connectNewTabWithUrl(url, options = {
+        forceSameTabNavigation: true
+    }) {
+        const tab = await chrome.tabs.create({
+            url
+        });
+        const tabId = tab.id;
+        assert(tabId, 'failed to get tabId after creating a new tab');
+        this.onLogMessage(`Creating new tab: ${url}`, 'log');
+        this.newlyCreatedTabIds.push(tabId);
+        if (options?.forceSameTabNavigation) this.forceSameTabNavigation = true;
+        await this.setActiveTabId(tabId);
+    }
+    async connectCurrentTab(options = {
+        forceSameTabNavigation: true
+    }) {
+        const tabs = await chrome.tabs.query({
+            active: true,
+            currentWindow: true
+        });
+        const tabId = tabs[0]?.id;
+        assert(tabId, 'failed to get tabId');
+        this.onLogMessage(`Connected to current tab: ${tabs[0]?.url}`, 'log');
+        if (options?.forceSameTabNavigation) this.forceSameTabNavigation = true;
+        await this.setActiveTabId(tabId);
+    }
+    async setDestroyOptions(options) {
+        this.destroyOptions = options;
+    }
+    async destroy() {
+        if (this.destroyOptions?.closeTab && this.newlyCreatedTabIds.length > 0) {
+            this.onLogMessage('Closing all newly created tabs by bridge...', 'log');
+            for (const tabId of this.newlyCreatedTabIds)await chrome.tabs.remove(tabId);
+            this.newlyCreatedTabIds = [];
+        }
+        await super.destroy();
+        if (this.bridgeClient) {
+            this.bridgeClient.disconnect();
+            this.bridgeClient = null;
+            this.onDisconnect();
+        }
+    }
+    constructor(serverEndpoint, onDisconnect = ()=>{}, onLogMessage = ()=>{}, forceSameTabNavigation = true, onConnectionRequest){
+        super(forceSameTabNavigation), _define_property(this, "serverEndpoint", void 0), _define_property(this, "onDisconnect", void 0), _define_property(this, "onLogMessage", void 0), _define_property(this, "onConnectionRequest", void 0), _define_property(this, "bridgeClient", void 0), _define_property(this, "destroyOptions", void 0), _define_property(this, "newlyCreatedTabIds", void 0), _define_property(this, "confirmationPromise", void 0), this.serverEndpoint = serverEndpoint, this.onDisconnect = onDisconnect, this.onLogMessage = onLogMessage, this.onConnectionRequest = onConnectionRequest, this.bridgeClient = null, this.newlyCreatedTabIds = [], this.confirmationPromise = null;
+    }
+}
+export { ExtensionBridgePageBrowserSide };

package/dist/es/cdp-proxy-constants.mjs

@@ -0,0 +1,7 @@
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+const PROXY_ENDPOINT_FILE = join(tmpdir(), 'midscene-cdp-proxy-endpoint');
+const PROXY_PID_FILE = join(tmpdir(), 'midscene-cdp-proxy-pid');
+const PROXY_UPSTREAM_FILE = join(tmpdir(), 'midscene-cdp-proxy-upstream');
+const TARGET_ID_FILE = join(tmpdir(), 'midscene-cdp-target-id');
+export { PROXY_ENDPOINT_FILE, PROXY_PID_FILE, PROXY_UPSTREAM_FILE, TARGET_ID_FILE };