extension 3.13.5 → 3.14.0-next.0

package/dist/{728.cjs → 631.cjs}

@@ -1,6 +1,6 @@
 "use strict";
 exports.ids = [
-    "728"
+    "631"
 ];
 exports.modules = {
     "./browsers/run-chromium/chromium-launch/setup-cdp-after-launch.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
@@ -674,6 +674,7 @@ exports.modules = {
                             });
                             this.ws = null;
                         });
+                        this.transport = 'websocket';
                         this.startHeartbeat();
                         if (this.isDev()) console.log(messages.M3V(this.host, this.port));
                         resolve();
@@ -683,8 +684,54 @@ exports.modules = {
                     }
                 });
             }
+            async connectViaPipe(input, output) {
+                this.transport = 'pipe';
+                this.pipeIn = input;
+                this.pipeOut = output;
+                this.pipeBuffer = Buffer.alloc(0);
+                input.on('data', (chunk)=>{
+                    this.pipeBuffer = Buffer.concat([
+                        this.pipeBuffer,
+                        chunk
+                    ]);
+                    let idx;
+                    while(-1 !== (idx = this.pipeBuffer.indexOf(0))){
+                        const msg = this.pipeBuffer.subarray(0, idx).toString('utf-8');
+                        this.pipeBuffer = this.pipeBuffer.subarray(idx + 1);
+                        this.handleMessage(msg);
+                    }
+                });
+                input.on('error', (error)=>{
+                    if (this.isDev()) console.error(`[CDP] Pipe read error: ${error.message}`);
+                    this.rejectAllPending('CDP pipe read error');
+                });
+                input.on('close', ()=>{
+                    if (this.isDev()) console.log('[CDP] Pipe closed');
+                    this.rejectAllPending('CDP pipe closed');
+                    this.pipeIn = null;
+                });
+                this.startHeartbeat();
+                if (this.isDev()) console.log(messages.M3V(this.host, this.port));
+            }
+            rejectAllPending(reason) {
+                this.pendingRequests.forEach(({ reject, timeout }, id)=>{
+                    try {
+                        reject(new Error(reason));
+                    } catch  {}
+                    if (timeout) clearTimeout(timeout);
+                    this.pendingRequests.delete(id);
+                });
+            }
             disconnect() {
                 this.stopHeartbeat();
+                if ('pipe' === this.transport) {
+                    try {
+                        this.pipeIn?.removeAllListeners();
+                        this.pipeOut?.end();
+                    } catch  {}
+                    this.pipeIn = null;
+                    this.pipeOut = null;
+                }
                 if (this.ws) {
                     try {
                         this.ws.close();
@@ -712,6 +759,7 @@ exports.modules = {
                 }
             }
             isConnected() {
+                if ('pipe' === this.transport) return !!this.pipeIn && !this.pipeIn.destroyed && !!this.pipeOut && !this.pipeOut.destroyed;
                 return !!this.ws && this.ws.readyState === external_ws_default().OPEN;
             }
             onProtocolEvent(handler) {
@@ -747,7 +795,7 @@ exports.modules = {
             }
             async sendCommand(method, params = {}, sessionId, timeoutMs = constants.Ns) {
                 return new Promise((resolve, reject)=>{
-                    if (!this.ws || this.ws.readyState !== external_ws_default().OPEN) return reject(new Error('WebSocket is not open'));
+                    if (!this.isConnected()) return reject(new Error('CDP transport is not open'));
                     const id = ++this.messageId;
                     const message = {
                         id,
@@ -768,7 +816,9 @@ exports.modules = {
                             timeout,
                             method
                         });
-                        this.ws.send(JSON.stringify(message));
+                        const data = JSON.stringify(message);
+                        if ('pipe' === this.transport && this.pipeOut) this.pipeOut.write(data + '\0');
+                        else if (this.ws) this.ws.send(data);
                     } catch (error) {
                         const pending = this.pendingRequests.get(id);
                         if (pending?.timeout) clearTimeout(pending.timeout);
@@ -937,7 +987,11 @@ exports.modules = {
             constructor(port = 9222, host = '127.0.0.1'){
                 _define_property(this, "port", void 0);
                 _define_property(this, "host", void 0);
+                _define_property(this, "transport", 'websocket');
                 _define_property(this, "ws", null);
+                _define_property(this, "pipeIn", null);
+                _define_property(this, "pipeOut", null);
+                _define_property(this, "pipeBuffer", Buffer.alloc(0));
                 _define_property(this, "targetWebSocketUrl", null);
                 _define_property(this, "eventCallbacks", new Set());
                 _define_property(this, "messageId", 0);
@@ -949,14 +1003,32 @@ exports.modules = {
         }
         function isRecoverableBootstrapError(error) {
             const msg = String(error?.message || error || '').toLowerCase();
-            return msg.includes('econnreset') || msg.includes('websocket is not open') || msg.includes('cdp connection closed') || msg.includes('socket hang up') || msg.includes('timed out') || msg.includes('no cdp websocket url');
+            return msg.includes('econnreset') || msg.includes('websocket is not open') || msg.includes('cdp transport is not open') || msg.includes('cdp connection closed') || msg.includes('cdp pipe closed') || msg.includes('socket hang up') || msg.includes('timed out') || msg.includes('no cdp websocket url');
+        }
+        async function connectToChromeCdpViaPipe(pipeIn, pipeOut, cdpPort = 0, cdpHost = '127.0.0.1') {
+            const cdp = new CDPClient(cdpPort, cdpHost);
+            try {
+                await cdp.connectViaPipe(pipeIn, pipeOut);
+                await cdp.sendCommand('Target.setDiscoverTargets', {
+                    discover: true
+                });
+                await cdp.sendCommand('Target.setAutoAttach', {
+                    autoAttach: true,
+                    waitForDebuggerOnStart: false,
+                    flatten: true
+                });
+                return cdp;
+            } catch (error) {
+                cdp.disconnect();
+                throw error;
+            }
         }
-        async function connectToChromeCdp(cdpPort) {
+        async function connectToChromeCdp(cdpPort, cdpHost = '127.0.0.1') {
             let retries = 0;
             const maxRetries = 60;
             const backoffMs = 250;
             while(retries < maxRetries){
-                const ready = await (0, discovery.z)(cdpPort);
+                const ready = await (0, discovery.z)(cdpPort, cdpHost);
                 if (ready) break;
                 retries++;
                 await new Promise((r)=>setTimeout(r, backoffMs));
@@ -964,7 +1036,7 @@ exports.modules = {
             const maxBootstrapAttempts = 4;
             let lastError = null;
             for(let attempt = 1; attempt <= maxBootstrapAttempts; attempt++){
-                const cdp = new CDPClient(cdpPort, '127.0.0.1');
+                const cdp = new CDPClient(cdpPort, cdpHost);
                 try {
                     await cdp.connect();
                     await cdp.sendCommand('Target.setDiscoverTargets', {
@@ -992,18 +1064,7 @@ exports.modules = {
             }
             throw lastError instanceof Error ? lastError : new Error('Failed to bootstrap CDP connection');
         }
-        function readManifestInfo(outPath) {
-            try {
-                const manifestPath = external_path_.join(outPath, 'manifest.json');
-                const manifest = JSON.parse(external_fs_.readFileSync(manifestPath, 'utf-8'));
-                return {
-                    name: manifest?.name,
-                    version: manifest?.version
-                };
-            } catch  {
-                return null;
-            }
-        }
+        var ensure = __webpack_require__("./browsers/run-chromium/chromium-source-inspection/cdp-extension-controller/ensure.ts");
         function registerAutoEnableLogging(cdp, getExtensionId) {
             cdp.onProtocolEvent((message)=>{
                 try {
@@ -1050,6 +1111,11 @@ exports.modules = {
                 if (!this.cdp) throw new Error('CDP not connected');
                 const exists = external_fs_.existsSync(this.outPath);
                 if (!exists) throw new Error(`Output path not found: ${this.outPath}`);
+                if (!this.extensionId) try {
+                    const { loadUnpackedIfNeeded } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "./browsers/run-chromium/chromium-source-inspection/cdp-extension-controller/ensure.ts"));
+                    const cdpId = await loadUnpackedIfNeeded(this.cdp, this.outPath);
+                    if (cdpId) this.extensionId = cdpId;
+                } catch  {}
                 if (!this.extensionId) {
                     const id = await this.deriveExtensionIdFromTargets();
                     if (id) this.extensionId = id;
@@ -1089,7 +1155,7 @@ exports.modules = {
                         version = info?.extensionInfo?.version;
                     } catch (error) {
                         try {
-                            const manifest = readManifestInfo(this.outPath);
+                            const manifest = (0, ensure.M)(this.outPath);
                             name = String(manifest?.name || '') || void 0;
                             version = String(manifest?.version || '') || void 0;
                         } catch (e2) {
@@ -1407,7 +1473,8 @@ exports.modules = {
                 }
             }
             async connectFreshClient() {
-                this.cdp = await connectToChromeCdp(this.cdpPort);
+                if (this.pipeIn && this.pipeOut && !this.pipeIn.destroyed) this.cdp = await connectToChromeCdpViaPipe(this.pipeIn, this.pipeOut, this.cdpPort);
+                else this.cdp = await connectToChromeCdp(this.cdpPort);
                 try {
                     await this.cdp.sendCommand('Target.setDiscoverTargets', {
                         discover: true
@@ -1763,6 +1830,8 @@ exports.modules = {
                 cdp_extension_controller_define_property(this, "cdpPort", void 0);
                 cdp_extension_controller_define_property(this, "profilePath", void 0);
                 cdp_extension_controller_define_property(this, "extensionPaths", void 0);
+                cdp_extension_controller_define_property(this, "pipeIn", void 0);
+                cdp_extension_controller_define_property(this, "pipeOut", void 0);
                 cdp_extension_controller_define_property(this, "cdp", null);
                 cdp_extension_controller_define_property(this, "extensionId", null);
                 cdp_extension_controller_define_property(this, "lastRuntimeReinjectionReport", null);
@@ -1771,10 +1840,12 @@ exports.modules = {
                 this.cdpPort = args.cdpPort;
                 this.profilePath = args.profilePath;
                 this.extensionPaths = args.extensionPaths;
+                this.pipeIn = args.pipeIn;
+                this.pipeOut = args.pipeOut;
             }
         }
         var extension_output_path = __webpack_require__("./browsers/run-chromium/chromium-launch/extension-output-path.ts");
-        async function setupCdpAfterLaunch(compilation, plugin, chromiumArgs) {
+        async function setupCdpAfterLaunch(compilation, plugin, chromiumArgs, pipeStreams) {
             const loadExtensionFlag = chromiumArgs.find((flag)=>flag.startsWith('--load-extension='));
             const extensionOutputPath = (0, extension_output_path.W)(compilation, loadExtensionFlag);
             const extensionPaths = loadExtensionFlag ? loadExtensionFlag.replace('--load-extension=', '').split(',').map((s)=>s.trim()).filter(Boolean) : [];
@@ -1794,7 +1865,9 @@ exports.modules = {
                 browser: 'chromium-based' === plugin.browser ? 'chrome' : plugin.browser,
                 cdpPort: chromeRemoteDebugPort,
                 profilePath: userDataDir || void 0,
-                extensionPaths: selectedExtensionPaths
+                extensionPaths: selectedExtensionPaths,
+                pipeIn: pipeStreams?.input,
+                pipeOut: pipeStreams?.output
             });
             await cdpExtensionController.connect();
             if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(messages.M3V('127.0.0.1', chromeRemoteDebugPort));
@@ -1886,5 +1959,39 @@ exports.modules = {
             }
             plugin.cdpController = cdpExtensionController;
         }
+    },
+    "./browsers/run-chromium/chromium-source-inspection/cdp-extension-controller/ensure.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            M: ()=>readManifestInfo,
+            loadUnpackedIfNeeded: ()=>loadUnpackedIfNeeded
+        });
+        var fs__rspack_import_0 = __webpack_require__("fs");
+        var path__rspack_import_1 = __webpack_require__("path");
+        async function loadUnpackedIfNeeded(cdp, outPath) {
+            try {
+                const response = await cdp.sendCommand('Extensions.loadUnpacked', {
+                    extensionPath: outPath,
+                    options: {
+                        failOnError: false
+                    }
+                });
+                const id = String(response?.extensionId || '');
+                return id || null;
+            } catch  {
+                return null;
+            }
+        }
+        function readManifestInfo(outPath) {
+            try {
+                const manifestPath = path__rspack_import_1.join(outPath, 'manifest.json');
+                const manifest = JSON.parse(fs__rspack_import_0.readFileSync(manifestPath, 'utf-8'));
+                return {
+                    name: manifest?.name,
+                    version: manifest?.version
+                };
+            } catch  {
+                return null;
+            }
+        }
     }
 };