@godscene/web 1.7.11

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

@@ -0,0 +1,273 @@
+"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__, {
+    killProxy: ()=>killProxy,
+    getProxyEndpoint: ()=>getProxyEndpoint,
+    readProxyUpstream: ()=>readProxyUpstream,
+    isProxyAlive: ()=>isProxyAlive,
+    readProxyEndpoint: ()=>readProxyEndpoint
+});
+const external_node_child_process_namespaceObject = require("node:child_process");
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_http_namespaceObject = require("node:http");
+var external_node_http_default = /*#__PURE__*/ __webpack_require__.n(external_node_http_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+const logger_namespaceObject = require("@godscene/shared/logger");
+const external_cdp_proxy_constants_js_namespaceObject = require("./cdp-proxy-constants.js");
+const external_cdp_target_store_js_namespaceObject = require("./cdp-target-store.js");
+const debug = (0, logger_namespaceObject.getDebug)('mcp:cdp:proxy');
+const PROXY_TERM_GRACE_MS = 2000;
+const PROXY_TERM_POLL_MS = 50;
+const PROXY_STDERR_BUFFER_LIMIT = 8192;
+const PROXY_STARTUP_TIMEOUT_MS = 10000;
+function isPageLevelEndpoint(endpoint) {
+    return /\/devtools\/page\//.test(endpoint);
+}
+function resolveBrowserEndpoint(pageEndpoint) {
+    return new Promise((resolve, reject)=>{
+        let host;
+        try {
+            const url = new URL(pageEndpoint);
+            host = url.host;
+        } catch  {
+            reject(new Error(`Invalid CDP endpoint URL: ${pageEndpoint}`));
+            return;
+        }
+        const req = external_node_http_default().get(`http://${host}/json/version`, {
+            timeout: 5000
+        }, (res)=>{
+            if (res.statusCode && res.statusCode >= 400) {
+                reject(new Error(`/json/version returned HTTP ${res.statusCode}`));
+                res.resume();
+                return;
+            }
+            let data = '';
+            res.on('data', (chunk)=>{
+                data += chunk.toString();
+            });
+            res.on('end', ()=>{
+                try {
+                    const info = JSON.parse(data);
+                    if (info.webSocketDebuggerUrl) resolve(info.webSocketDebuggerUrl);
+                    else reject(new Error('webSocketDebuggerUrl not found in /json/version response'));
+                } catch  {
+                    reject(new Error(`Failed to parse /json/version response: ${data}`));
+                }
+            });
+        });
+        req.on('error', (err)=>reject(new Error(`Failed to fetch /json/version: ${err.message}`)));
+        req.on('timeout', ()=>{
+            req.destroy();
+            reject(new Error('Timeout fetching /json/version'));
+        });
+    });
+}
+function isProxyAlive() {
+    if (!(0, external_node_fs_namespaceObject.existsSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_PID_FILE)) return false;
+    try {
+        const pid = Number((0, external_node_fs_namespaceObject.readFileSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_PID_FILE, 'utf-8').trim());
+        process.kill(pid, 0);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function readProxyEndpoint() {
+    if (!(0, external_node_fs_namespaceObject.existsSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_ENDPOINT_FILE)) return null;
+    try {
+        return (0, external_node_fs_namespaceObject.readFileSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_ENDPOINT_FILE, 'utf-8').trim();
+    } catch  {
+        return null;
+    }
+}
+function readProxyUpstream() {
+    if (!(0, external_node_fs_namespaceObject.existsSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_UPSTREAM_FILE)) return null;
+    try {
+        return (0, external_node_fs_namespaceObject.readFileSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_UPSTREAM_FILE, 'utf-8').trim();
+    } catch  {
+        return null;
+    }
+}
+function sweepProxyMetadataFiles() {
+    try {
+        if ((0, external_node_fs_namespaceObject.existsSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_ENDPOINT_FILE)) (0, external_node_fs_namespaceObject.unlinkSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_ENDPOINT_FILE);
+    } catch  {}
+    try {
+        if ((0, external_node_fs_namespaceObject.existsSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_PID_FILE)) (0, external_node_fs_namespaceObject.unlinkSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_PID_FILE);
+    } catch  {}
+    try {
+        if ((0, external_node_fs_namespaceObject.existsSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_UPSTREAM_FILE)) (0, external_node_fs_namespaceObject.unlinkSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_UPSTREAM_FILE);
+    } catch  {}
+}
+async function killProxy() {
+    (0, external_cdp_target_store_js_namespaceObject.cleanupTargetIdFile)();
+    if (!(0, external_node_fs_namespaceObject.existsSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_PID_FILE)) return;
+    let pid;
+    try {
+        pid = Number((0, external_node_fs_namespaceObject.readFileSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_PID_FILE, 'utf-8').trim());
+        if (!Number.isFinite(pid)) return void sweepProxyMetadataFiles();
+    } catch (err) {
+        debug('killProxy: cannot read pid file: %s', err);
+        sweepProxyMetadataFiles();
+        return;
+    }
+    try {
+        process.kill(pid, 'SIGTERM');
+        debug('Sent SIGTERM to proxy pid %d', pid);
+    } catch (err) {
+        debug('killProxy: SIGTERM failed (pid %d): %s', pid, err);
+        sweepProxyMetadataFiles();
+        return;
+    }
+    const deadline = Date.now() + PROXY_TERM_GRACE_MS;
+    while(Date.now() < deadline && (0, external_node_fs_namespaceObject.existsSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_PID_FILE))await new Promise((r)=>setTimeout(r, PROXY_TERM_POLL_MS));
+    if ((0, external_node_fs_namespaceObject.existsSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_PID_FILE)) {
+        debug('proxy pid %d did not clean up within %dms, forcing SIGKILL', pid, PROXY_TERM_GRACE_MS);
+        try {
+            process.kill(pid, 'SIGKILL');
+        } catch  {}
+        sweepProxyMetadataFiles();
+    }
+}
+function spawnProxy(chromeEndpoint) {
+    return new Promise((resolve, reject)=>{
+        const proxyScript = (0, external_node_path_namespaceObject.join)(__dirname, 'cdp-proxy.js');
+        const proc = (0, external_node_child_process_namespaceObject.spawn)(process.execPath, [
+            proxyScript,
+            chromeEndpoint
+        ], {
+            detached: true,
+            stdio: [
+                'ignore',
+                'pipe',
+                'pipe'
+            ]
+        });
+        proc.unref();
+        let output = '';
+        let stderrBuf = '';
+        let settled = false;
+        const appendStderr = (chunk)=>{
+            stderrBuf += chunk.toString();
+            if (stderrBuf.length > PROXY_STDERR_BUFFER_LIMIT) stderrBuf = stderrBuf.slice(-PROXY_STDERR_BUFFER_LIMIT);
+        };
+        proc.stderr.on('data', appendStderr);
+        const formatStderr = ()=>{
+            const trimmed = stderrBuf.trim();
+            return trimmed ? ` (stderr: ${trimmed})` : '';
+        };
+        const timer = setTimeout(()=>{
+            if (!settled) {
+                settled = true;
+                reject(new Error(`Proxy startup timeout (${PROXY_STARTUP_TIMEOUT_MS / 1000}s)${formatStderr()}`));
+            }
+        }, PROXY_STARTUP_TIMEOUT_MS);
+        const onData = (chunk)=>{
+            output += chunk.toString();
+            const lines = output.split('\n');
+            for (const line of lines)if (line.trim()) try {
+                const parsed = JSON.parse(line);
+                if (parsed.endpoint && !settled) {
+                    settled = true;
+                    clearTimeout(timer);
+                    proc.stdout.removeListener('data', onData);
+                    proc.stderr.removeListener('data', appendStderr);
+                    proc.stdout.destroy();
+                    proc.stderr.destroy();
+                    resolve(parsed.endpoint);
+                    return;
+                }
+            } catch  {}
+        };
+        proc.stdout.on('data', onData);
+        proc.on('error', (err)=>{
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                reject(new Error(`Failed to spawn proxy: ${err.message}`));
+            }
+        });
+        proc.on('exit', (code, signal)=>{
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                const how = signal ? `signal ${signal}` : `code ${code}`;
+                reject(new Error(`Proxy exited with ${how} before ready${formatStderr()}`));
+            }
+        });
+    });
+}
+async function getProxyEndpoint(chromeEndpoint) {
+    let browserEndpoint = chromeEndpoint;
+    if (isPageLevelEndpoint(chromeEndpoint)) {
+        debug('Page-level CDP endpoint detected, resolving via /json/version: %s', chromeEndpoint);
+        try {
+            browserEndpoint = await resolveBrowserEndpoint(chromeEndpoint);
+            debug('Resolved browser endpoint: %s', browserEndpoint);
+        } catch (err) {
+            throw new Error(`Cannot use page-level CDP endpoint directly. Puppeteer requires a browser-level endpoint (e.g., ws://host:port/devtools/browser/<id>). Auto-resolution via /json/version failed: ${err.message}. Please provide a browser-level CDP endpoint instead.`);
+        }
+    }
+    if (isProxyAlive()) {
+        const endpoint = readProxyEndpoint();
+        const savedUpstream = readProxyUpstream();
+        if (endpoint) if (!savedUpstream || savedUpstream === browserEndpoint) return endpoint;
+        else {
+            debug('Proxy connected to different upstream (%s), killing', savedUpstream);
+            await killProxy();
+        }
+    }
+    try {
+        return await spawnProxy(browserEndpoint);
+    } catch (err) {
+        console.warn(`[cdp] proxy failed, falling back to direct connection: ${err}`);
+        return browserEndpoint;
+    }
+}
+exports.getProxyEndpoint = __webpack_exports__.getProxyEndpoint;
+exports.isProxyAlive = __webpack_exports__.isProxyAlive;
+exports.killProxy = __webpack_exports__.killProxy;
+exports.readProxyEndpoint = __webpack_exports__.readProxyEndpoint;
+exports.readProxyUpstream = __webpack_exports__.readProxyUpstream;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getProxyEndpoint",
+    "isProxyAlive",
+    "killProxy",
+    "readProxyEndpoint",
+    "readProxyUpstream"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/cdp-proxy.js

@@ -0,0 +1,179 @@
+"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);
+})();
+var __webpack_exports__ = {};
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_http_namespaceObject = require("node:http");
+const external_ws_namespaceObject = require("ws");
+var external_ws_default = /*#__PURE__*/ __webpack_require__.n(external_ws_namespaceObject);
+const external_cdp_proxy_constants_js_namespaceObject = require("./cdp-proxy-constants.js");
+const IDLE_TIMEOUT_MS = 300000;
+const chromeEndpoint = process.argv[2];
+if (!chromeEndpoint) {
+    process.stderr.write('Usage: node cdp-proxy.js <chrome-ws-endpoint>\n');
+    process.exit(1);
+}
+function cleanupIfOwned() {
+    try {
+        if (!(0, external_node_fs_namespaceObject.existsSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_PID_FILE)) return;
+        const pid = Number((0, external_node_fs_namespaceObject.readFileSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_PID_FILE, 'utf-8').trim());
+        if (pid !== process.pid) return;
+    } catch  {
+        return;
+    }
+    try {
+        if ((0, external_node_fs_namespaceObject.existsSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_ENDPOINT_FILE)) (0, external_node_fs_namespaceObject.unlinkSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_ENDPOINT_FILE);
+    } catch  {}
+    try {
+        if ((0, external_node_fs_namespaceObject.existsSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_PID_FILE)) (0, external_node_fs_namespaceObject.unlinkSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_PID_FILE);
+    } catch  {}
+    try {
+        if ((0, external_node_fs_namespaceObject.existsSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_UPSTREAM_FILE)) (0, external_node_fs_namespaceObject.unlinkSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_UPSTREAM_FILE);
+    } catch  {}
+}
+const STDERR_FLUSH_FALLBACK_MS = 500;
+function exitWithStderr(message, code = 0) {
+    let exited = false;
+    const doExit = ()=>{
+        if (exited) return;
+        exited = true;
+        process.exit(code);
+    };
+    const fallback = setTimeout(doExit, STDERR_FLUSH_FALLBACK_MS);
+    fallback.unref?.();
+    try {
+        process.stderr.write(message, ()=>doExit());
+    } catch  {
+        doExit();
+    }
+}
+function shutdown(reason) {
+    cleanupIfOwned();
+    exitWithStderr(`[cdp-proxy] shutting down: ${reason}\n`, 0);
+}
+process.on('SIGTERM', ()=>shutdown('SIGTERM'));
+process.on('SIGINT', ()=>shutdown('SIGINT'));
+process.on('uncaughtException', (e)=>shutdown(`uncaught: ${e.message}`));
+let idleTimer = null;
+function resetIdleTimer() {
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(()=>shutdown('idle timeout (5min)'), IDLE_TIMEOUT_MS);
+}
+resetIdleTimer();
+const clients = new Set();
+let reconnecting = false;
+let needsUpstreamReconnect = false;
+const pendingUpstreamMessages = [];
+function createUpstream(endpoint) {
+    const ws = new (external_ws_default())(endpoint);
+    ws.on('error', (err)=>{
+        reconnecting = false;
+        shutdown(`upstream error: ${err.message}`);
+    });
+    ws.on('close', (code, reasonBuf)=>{
+        if (reconnecting) return;
+        const reason = reasonBuf?.toString?.() || '';
+        const detail = reason ? ` (code=${code}, reason=${reason})` : ` (code=${code})`;
+        shutdown(`upstream closed${detail}`);
+    });
+    ws.on('message', (data, isBinary)=>{
+        resetIdleTimer();
+        for (const client of clients)if (client.readyState === external_ws_default().OPEN) client.send(data, {
+            binary: isBinary
+        });
+    });
+    ws.on('open', ()=>{
+        reconnecting = false;
+        for (const msg of pendingUpstreamMessages)ws.send(msg.data, {
+            binary: msg.isBinary
+        });
+        pendingUpstreamMessages.length = 0;
+    });
+    return ws;
+}
+let upstream = createUpstream(chromeEndpoint);
+function reconnectUpstream() {
+    reconnecting = true;
+    upstream.removeAllListeners();
+    upstream.close();
+    upstream = createUpstream(chromeEndpoint);
+    resetIdleTimer();
+}
+const httpServer = (0, external_node_http_namespaceObject.createServer)((_req, res)=>{
+    res.writeHead(404);
+    res.end();
+});
+const wss = new external_ws_namespaceObject.WebSocketServer({
+    server: httpServer
+});
+wss.on('connection', (clientWs)=>{
+    if (needsUpstreamReconnect && upstream.readyState === external_ws_default().OPEN) {
+        reconnectUpstream();
+        needsUpstreamReconnect = false;
+    }
+    clients.add(clientWs);
+    resetIdleTimer();
+    clientWs.on('message', (data, isBinary)=>{
+        resetIdleTimer();
+        if (upstream.readyState === external_ws_default().OPEN) upstream.send(data, {
+            binary: isBinary
+        });
+        else pendingUpstreamMessages.push({
+            data,
+            isBinary
+        });
+    });
+    const removeClient = ()=>{
+        clients.delete(clientWs);
+        if (0 === clients.size) {
+            pendingUpstreamMessages.length = 0;
+            needsUpstreamReconnect = true;
+        }
+    };
+    clientWs.on('close', removeClient);
+    clientWs.on('error', removeClient);
+});
+upstream.once('open', ()=>{
+    if ((0, external_node_fs_namespaceObject.existsSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_PID_FILE)) try {
+        const existingPid = Number((0, external_node_fs_namespaceObject.readFileSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_PID_FILE, 'utf-8').trim());
+        if (existingPid !== process.pid) try {
+            process.kill(existingPid, 0);
+            exitWithStderr(`[cdp-proxy] duplicate proxy detected (existing pid=${existingPid})\n`, 0);
+            return;
+        } catch  {}
+    } catch  {}
+    httpServer.listen(0, '127.0.0.1', ()=>{
+        const addr = httpServer.address();
+        if (!addr || 'string' == typeof addr) return void shutdown('failed to get server address');
+        const proxyEndpoint = `ws://127.0.0.1:${addr.port}/devtools/browser`;
+        (0, external_node_fs_namespaceObject.writeFileSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_ENDPOINT_FILE, proxyEndpoint);
+        (0, external_node_fs_namespaceObject.writeFileSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_PID_FILE, String(process.pid));
+        (0, external_node_fs_namespaceObject.writeFileSync)(external_cdp_proxy_constants_js_namespaceObject.PROXY_UPSTREAM_FILE, chromeEndpoint);
+        process.stdout.write(`${JSON.stringify({
+            endpoint: proxyEndpoint
+        })}\n`);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/cdp-target-store.js

@@ -0,0 +1,66 @@
+"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__, {
+    saveTargetId: ()=>saveTargetId,
+    cleanupTargetIdFile: ()=>cleanupTargetIdFile,
+    readSavedTargetId: ()=>readSavedTargetId
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const logger_namespaceObject = require("@godscene/shared/logger");
+const external_cdp_proxy_constants_js_namespaceObject = require("./cdp-proxy-constants.js");
+const debug = (0, logger_namespaceObject.getDebug)('mcp:cdp:target-store');
+function readSavedTargetId() {
+    if (!(0, external_node_fs_namespaceObject.existsSync)(external_cdp_proxy_constants_js_namespaceObject.TARGET_ID_FILE)) return null;
+    try {
+        return (0, external_node_fs_namespaceObject.readFileSync)(external_cdp_proxy_constants_js_namespaceObject.TARGET_ID_FILE, 'utf-8').trim() || null;
+    } catch  {
+        return null;
+    }
+}
+function saveTargetId(targetId) {
+    try {
+        (0, external_node_fs_namespaceObject.writeFileSync)(external_cdp_proxy_constants_js_namespaceObject.TARGET_ID_FILE, targetId, 'utf-8');
+        debug('Saved targetId: %s', targetId);
+    } catch (err) {
+        debug('Failed to save targetId: %s', err);
+    }
+}
+function cleanupTargetIdFile() {
+    try {
+        if ((0, external_node_fs_namespaceObject.existsSync)(external_cdp_proxy_constants_js_namespaceObject.TARGET_ID_FILE)) (0, external_node_fs_namespaceObject.unlinkSync)(external_cdp_proxy_constants_js_namespaceObject.TARGET_ID_FILE);
+    } catch  {}
+}
+exports.cleanupTargetIdFile = __webpack_exports__.cleanupTargetIdFile;
+exports.readSavedTargetId = __webpack_exports__.readSavedTargetId;
+exports.saveTargetId = __webpack_exports__.saveTargetId;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "cleanupTargetIdFile",
+    "readSavedTargetId",
+    "saveTargetId"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/chrome-extension/agent.js

@@ -0,0 +1,42 @@
+"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__, {
+    ChromeExtensionProxyPageAgent: ()=>ChromeExtensionProxyPageAgent
+});
+const agent_namespaceObject = require("@godscene/core/agent");
+const base_page_js_namespaceObject = require("../puppeteer/base-page.js");
+class ChromeExtensionProxyPageAgent extends agent_namespaceObject.Agent {
+    isRetryableContextError(error) {
+        return error instanceof Error && base_page_js_namespaceObject.BROWSER_NAVIGATION_ERROR_PATTERN.test(error.message);
+    }
+}
+exports.ChromeExtensionProxyPageAgent = __webpack_exports__.ChromeExtensionProxyPageAgent;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ChromeExtensionProxyPageAgent"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});