@godscene/web 1.7.11

package/dist/lib/bridge-mode/agent-cli-side.js

@@ -0,0 +1,172 @@
+"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__, {
+    AgentOverChromeBridge: ()=>AgentOverChromeBridge,
+    getBridgePageInCliSide: ()=>getBridgePageInCliSide
+});
+const agent_namespaceObject = require("@godscene/core/agent");
+const utils_namespaceObject = require("@godscene/shared/utils");
+const external_web_page_js_namespaceObject = require("../web-page.js");
+const external_common_js_namespaceObject = require("./common.js");
+const external_io_server_js_namespaceObject = require("./io-server.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 sleep = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
+const getBridgePageInCliSide = (options)=>{
+    const host = options?.host || external_common_js_namespaceObject.DefaultBridgeServerHost;
+    const port = options?.port || external_common_js_namespaceObject.DefaultBridgeServerPort;
+    const server = new external_io_server_js_namespaceObject.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(external_common_js_namespaceObject.BridgeEvent.UpdateAgentStatus, [
+                message
+            ]);
+        }
+    };
+    const proxyPage = new Proxy(page, {
+        get (target, prop, receiver) {
+            (0, utils_namespaceObject.assert)('string' == typeof prop, 'prop must be a string');
+            if ('toJSON' === prop) return ()=>({
+                    interfaceType: external_common_js_namespaceObject.BridgePageType
+                });
+            if ('interfaceType' === prop) return external_common_js_namespaceObject.BridgePageType;
+            if ('actionSpace' === prop) return ()=>(0, external_web_page_js_namespaceObject.commonWebActionsForWebPage)(proxyPage);
+            if (Object.keys(page).includes(prop)) return page[prop];
+            if ('mouse' === prop) {
+                const mouse = {
+                    click: bridgeCaller(external_common_js_namespaceObject.MouseEvent.Click),
+                    wheel: bridgeCaller(external_common_js_namespaceObject.MouseEvent.Wheel),
+                    move: bridgeCaller(external_common_js_namespaceObject.MouseEvent.Move),
+                    drag: bridgeCaller(external_common_js_namespaceObject.MouseEvent.Drag)
+                };
+                return mouse;
+            }
+            if ('keyboard' === prop) {
+                const keyboard = {
+                    type: bridgeCaller(external_common_js_namespaceObject.KeyboardEvent.Type),
+                    press: bridgeCaller(external_common_js_namespaceObject.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_namespaceObject.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 = (0, external_common_js_namespaceObject.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;
+    }
+}
+exports.AgentOverChromeBridge = __webpack_exports__.AgentOverChromeBridge;
+exports.getBridgePageInCliSide = __webpack_exports__.getBridgePageInCliSide;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "AgentOverChromeBridge",
+    "getBridgePageInCliSide"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,36 @@
+"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__, {
+    ExtensionBridgePageBrowserSide: ()=>external_page_browser_side_js_namespaceObject.ExtensionBridgePageBrowserSide
+});
+const external_page_browser_side_js_namespaceObject = require("./page-browser-side.js");
+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/bridge-mode/common.js

@@ -0,0 +1,105 @@
+"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__, {
+    BridgeCallTimeout: ()=>BridgeCallTimeout,
+    BridgeErrorCodeNoClientConnected: ()=>BridgeErrorCodeNoClientConnected,
+    BridgeEvent: ()=>BridgeEvent,
+    BridgePageType: ()=>BridgePageType,
+    BridgeSignalKill: ()=>BridgeSignalKill,
+    DefaultBridgeServerHost: ()=>DefaultBridgeServerHost,
+    DefaultBridgeServerPort: ()=>DefaultBridgeServerPort,
+    DefaultLocalEndpoint: ()=>DefaultLocalEndpoint,
+    KeyboardEvent: ()=>KeyboardEvent,
+    MouseEvent: ()=>MouseEvent,
+    getBridgeServerHost: ()=>getBridgeServerHost
+});
+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 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 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 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';
+exports.BridgeCallTimeout = __webpack_exports__.BridgeCallTimeout;
+exports.BridgeErrorCodeNoClientConnected = __webpack_exports__.BridgeErrorCodeNoClientConnected;
+exports.BridgeEvent = __webpack_exports__.BridgeEvent;
+exports.BridgePageType = __webpack_exports__.BridgePageType;
+exports.BridgeSignalKill = __webpack_exports__.BridgeSignalKill;
+exports.DefaultBridgeServerHost = __webpack_exports__.DefaultBridgeServerHost;
+exports.DefaultBridgeServerPort = __webpack_exports__.DefaultBridgeServerPort;
+exports.DefaultLocalEndpoint = __webpack_exports__.DefaultLocalEndpoint;
+exports.KeyboardEvent = __webpack_exports__.KeyboardEvent;
+exports.MouseEvent = __webpack_exports__.MouseEvent;
+exports.getBridgeServerHost = __webpack_exports__.getBridgeServerHost;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BridgeCallTimeout",
+    "BridgeErrorCodeNoClientConnected",
+    "BridgeEvent",
+    "BridgePageType",
+    "BridgeSignalKill",
+    "DefaultBridgeServerHost",
+    "DefaultBridgeServerPort",
+    "DefaultLocalEndpoint",
+    "KeyboardEvent",
+    "MouseEvent",
+    "getBridgeServerHost"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/bridge-mode/index.js

@@ -0,0 +1,44 @@
+"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__, {
+    overrideAIConfig: ()=>env_namespaceObject.overrideAIConfig,
+    AgentOverChromeBridge: ()=>external_agent_cli_side_js_namespaceObject.AgentOverChromeBridge,
+    killRunningServer: ()=>external_io_server_js_namespaceObject.killRunningServer
+});
+const external_agent_cli_side_js_namespaceObject = require("./agent-cli-side.js");
+const env_namespaceObject = require("@godscene/shared/env");
+const external_io_server_js_namespaceObject = require("./io-server.js");
+exports.AgentOverChromeBridge = __webpack_exports__.AgentOverChromeBridge;
+exports.killRunningServer = __webpack_exports__.killRunningServer;
+exports.overrideAIConfig = __webpack_exports__.overrideAIConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "AgentOverChromeBridge",
+    "killRunningServer",
+    "overrideAIConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,133 @@
+"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__, {
+    BridgeClient: ()=>BridgeClient
+});
+const utils_namespaceObject = require("@godscene/shared/utils");
+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;
+}
+class BridgeClient {
+    async connect() {
+        return new Promise((resolve, reject)=>{
+            const forceWebSocket = "u" < typeof XMLHttpRequest;
+            this.socket = (0, external_socket_io_client_namespaceObject.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(external_common_js_namespaceObject.BridgeEvent.Connected, (payload)=>{
+                clearTimeout(timeout);
+                this.serverVersion = payload?.version || 'unknown';
+                resolve(this.socket);
+            });
+            this.socket.on(external_common_js_namespaceObject.BridgeEvent.Refused, (e)=>{
+                console.error('bridge-refused', e);
+                try {
+                    this.socket?.disconnect();
+                } catch (e) {}
+                reject(new Error(e || 'bridge refused'));
+            });
+            this.socket.on(external_common_js_namespaceObject.BridgeEvent.Call, (call)=>{
+                const id = call.id;
+                (0, utils_namespaceObject.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(external_common_js_namespaceObject.BridgeEvent.CallResponse, {
+                            id,
+                            error: errorContent
+                        });
+                    }
+                    this.socket?.emit(external_common_js_namespaceObject.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;
+    }
+}
+exports.BridgeClient = __webpack_exports__.BridgeClient;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BridgeClient"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});