@godscene/web 1.7.11

package/dist/lib/bridge-mode/io-server.js

@@ -0,0 +1,255 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    killRunningServer: ()=>killRunningServer,
+    BridgeServer: ()=>BridgeServer
+});
+const external_node_http_namespaceObject = require("node:http");
+const utils_namespaceObject = require("@godscene/core/utils");
+const shared_utils_namespaceObject = require("@godscene/shared/utils");
+const external_socket_io_namespaceObject = require("socket.io");
+const external_socket_io_client_namespaceObject = require("socket.io-client");
+const external_common_js_namespaceObject = require("./common.js");
+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 = (0, external_socket_io_client_namespaceObject.io)(`ws://${host}:${port || external_common_js_namespaceObject.DefaultBridgeServerPort}`, {
+            query: {
+                [external_common_js_namespaceObject.BridgeSignalKill]: 1
+            }
+        });
+        await (0, utils_namespaceObject.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 (${external_common_js_namespaceObject.BridgeErrorCodeNoClientConnected})`));
+            }, timeout) : null;
+            this.connectionTipTimer = !timeout || timeout > 3000 ? setTimeout(()=>{
+                (0, shared_utils_namespaceObject.logMsg)('waiting for bridge to connect...');
+            }, 2000) : null;
+            const httpServer = (0, external_node_http_namespaceObject.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 external_socket_io_namespaceObject.Server(httpServer, {
+                maxHttpBufferSize: 104857600,
+                pingTimeout: 60000
+            });
+            this.io.use((socket, next)=>{
+                if (socket.handshake.url.includes(external_common_js_namespaceObject.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(external_common_js_namespaceObject.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(external_common_js_namespaceObject.BridgeEvent.Refused);
+                    socket.disconnect();
+                    (0, shared_utils_namespaceObject.logMsg)('refused new connection: server already connected by another client');
+                    return;
+                }
+                if (this.socket) {
+                    try {
+                        this.socket.disconnect();
+                    } catch (e) {
+                        (0, shared_utils_namespaceObject.logMsg)(`failed to disconnect stale socket: ${e}`);
+                    }
+                    this.socket = null;
+                }
+                try {
+                    (0, shared_utils_namespaceObject.logMsg)('one client connected');
+                    this.socket = socket;
+                    const clientVersion = socket.handshake.query.version;
+                    (0, shared_utils_namespaceObject.logMsg)(`Bridge connected, cli-side version v1.7.10, browser-side version v${clientVersion}`);
+                    socket.on(external_common_js_namespaceObject.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(external_common_js_namespaceObject.BridgeEvent.Connected, payload);
+                        Promise.resolve().then(()=>{
+                            for(const id in this.calls)if (0 === this.calls[id].callTime) this.emitCall(id);
+                        });
+                    }, 0);
+                } catch (e) {
+                    (0, shared_utils_namespaceObject.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(external_common_js_namespaceObject.BridgeEvent.Call, {
+                id,
+                method: call.method,
+                args: call.args
+            });
+            call.callTime = Date.now();
+        }
+    }
+    async call(method, args, timeout = external_common_js_namespaceObject.BridgeCallTimeout) {
+        const id = `${this.callId++}`;
+        return new Promise((resolve, reject)=>{
+            const timeoutId = setTimeout(()=>{
+                (0, shared_utils_namespaceObject.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}`;
+    }
+}
+exports.BridgeServer = __webpack_exports__.BridgeServer;
+exports.killRunningServer = __webpack_exports__.killRunningServer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BridgeServer",
+    "killRunningServer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/bridge-mode/page-browser-side.js

@@ -0,0 +1,163 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ExtensionBridgePageBrowserSide: ()=>ExtensionBridgePageBrowserSide
+});
+const utils_namespaceObject = require("@godscene/shared/utils");
+const page_js_namespaceObject = require("../chrome-extension/page.js");
+var page_js_default = /*#__PURE__*/ __webpack_require__.n(page_js_namespaceObject);
+const external_common_js_namespaceObject = require("./common.js");
+const external_io_client_js_namespaceObject = require("./io-client.js");
+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_js_default() {
+    async setupBridgeClient() {
+        const endpoint = this.serverEndpoint || `ws://localhost:${external_common_js_namespaceObject.DefaultBridgeServerPort}`;
+        let resolveConfirmationGate = ()=>{};
+        if (this.onConnectionRequest) this.confirmationPromise = new Promise((resolve)=>{
+            resolveConfirmationGate = resolve;
+        });
+        this.bridgeClient = new external_io_client_js_namespaceObject.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 === external_common_js_namespaceObject.BridgeEvent.ConnectNewTabWithUrl) return this.connectNewTabWithUrl.apply(this, args);
+            if (method === external_common_js_namespaceObject.BridgeEvent.GetBrowserTabList) return this.getBrowserTabList.apply(this, args);
+            if (method === external_common_js_namespaceObject.BridgeEvent.SetActiveTabId) return this.setActiveTabId.apply(this, args);
+            if (method === external_common_js_namespaceObject.BridgeEvent.ConnectCurrentTab) return this.connectCurrentTab.apply(this, args);
+            if (method === external_common_js_namespaceObject.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(external_common_js_namespaceObject.MouseEvent.PREFIX)) {
+                const actionName = method.split('.')[1];
+                return this.mouse[actionName].apply(this.mouse, args);
+            }
+            if (method.startsWith(external_common_js_namespaceObject.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;
+        (0, utils_namespaceObject.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;
+        (0, utils_namespaceObject.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;
+    }
+}
+exports.ExtensionBridgePageBrowserSide = __webpack_exports__.ExtensionBridgePageBrowserSide;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ExtensionBridgePageBrowserSide"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/cdp-proxy-constants.js

@@ -0,0 +1,50 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    PROXY_ENDPOINT_FILE: ()=>PROXY_ENDPOINT_FILE,
+    TARGET_ID_FILE: ()=>TARGET_ID_FILE,
+    PROXY_PID_FILE: ()=>PROXY_PID_FILE,
+    PROXY_UPSTREAM_FILE: ()=>PROXY_UPSTREAM_FILE
+});
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+const PROXY_ENDPOINT_FILE = (0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), 'midscene-cdp-proxy-endpoint');
+const PROXY_PID_FILE = (0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), 'midscene-cdp-proxy-pid');
+const PROXY_UPSTREAM_FILE = (0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), 'midscene-cdp-proxy-upstream');
+const TARGET_ID_FILE = (0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), 'midscene-cdp-target-id');
+exports.PROXY_ENDPOINT_FILE = __webpack_exports__.PROXY_ENDPOINT_FILE;
+exports.PROXY_PID_FILE = __webpack_exports__.PROXY_PID_FILE;
+exports.PROXY_UPSTREAM_FILE = __webpack_exports__.PROXY_UPSTREAM_FILE;
+exports.TARGET_ID_FILE = __webpack_exports__.TARGET_ID_FILE;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "PROXY_ENDPOINT_FILE",
+    "PROXY_PID_FILE",
+    "PROXY_UPSTREAM_FILE",
+    "TARGET_ID_FILE"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});