extension-develop 3.0.0-next.9 → 3.1.0-next.10

package/dist/323.js

@@ -0,0 +1,425 @@
+"use strict";
+exports.ids = [
+    "323"
+];
+exports.modules = {
+    "./webpack/plugin-browsers/run-chromium/chromium-launch/setup-cdp-after-launch.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            setupCdpAfterLaunch: ()=>setupCdpAfterLaunch
+        });
+        var messages = __webpack_require__("./webpack/plugin-browsers/browsers-lib/messages.ts");
+        var shared_utils = __webpack_require__("./webpack/plugin-browsers/browsers-lib/shared-utils.ts");
+        var banner = __webpack_require__("./webpack/plugin-browsers/browsers-lib/banner.ts");
+        var external_path_ = __webpack_require__("path");
+        var external_fs_ = __webpack_require__("fs");
+        async function deriveExtensionIdFromTargetsHelper(cdp, outPath, maxRetries = 20, backoffMs = 200) {
+            let expectedName;
+            try {
+                const manifest = JSON.parse(external_fs_.readFileSync(external_path_.join(outPath, 'manifest.json'), 'utf-8'));
+                expectedName = manifest?.name;
+            } catch  {}
+            let retries = 0;
+            while(retries <= maxRetries){
+                try {
+                    const targets = await cdp.getTargets();
+                    if (expectedName) for (const t of targets || []){
+                        const url = String(t?.url || '');
+                        const type = String(t?.type || '');
+                        if (!('service_worker' === type && url.startsWith('chrome-extension://'))) continue;
+                        const targetId = t?.targetId;
+                        if (targetId) try {
+                            const sessionId = await cdp.attachToTarget(targetId);
+                            if (!sessionId) continue;
+                            await cdp.sendCommand('Runtime.enable', {}, sessionId);
+                            const gotName = String(await cdp.evaluate(sessionId, '(()=>{try{return chrome.runtime.getManifest().name}catch(_){return null}})()'));
+                            if (gotName && String(gotName) === expectedName) {
+                                const gotIdStr = String(await cdp.evaluate(sessionId, '(()=>{try{return chrome.runtime.id}catch(_){return null}})()') || '');
+                                if (gotIdStr && gotIdStr.length > 0) return gotIdStr;
+                            }
+                        } catch  {}
+                    }
+                    for (const t of targets || []){
+                        const url = String(t?.url || '');
+                        const type = String(t?.type || '');
+                        if (!url.startsWith('chrome-extension://')) continue;
+                        const typeOk = [
+                            'service_worker',
+                            'background_page',
+                            'worker'
+                        ].includes(type);
+                        if (!typeOk) continue;
+                        const match = url.match(/^chrome-extension:\/\/([^\/]+)/);
+                        if (match && match[1]) return match[1];
+                    }
+                } catch  {}
+                await new Promise((r)=>setTimeout(r, backoffMs));
+                retries++;
+            }
+            return null;
+        }
+        var cdp_client = __webpack_require__("./webpack/plugin-browsers/run-chromium/chromium-source-inspection/cdp-client.ts");
+        var discovery = __webpack_require__("./webpack/plugin-browsers/run-chromium/chromium-source-inspection/discovery.ts");
+        async function connectToChromeCdp(cdpPort) {
+            let retries = 0;
+            const maxRetries = 60;
+            const backoffMs = 250;
+            while(retries < maxRetries){
+                const ready = await (0, discovery.z)(cdpPort);
+                if (ready) break;
+                retries++;
+                await new Promise((r)=>setTimeout(r, backoffMs));
+            }
+            const cdp = new cdp_client.n(cdpPort, '127.0.0.1');
+            await cdp.connect();
+            try {
+                await cdp.sendCommand('Target.setDiscoverTargets', {
+                    discover: true
+                });
+                await cdp.sendCommand('Target.setAutoAttach', {
+                    autoAttach: true,
+                    waitForDebuggerOnStart: false,
+                    flatten: true
+                });
+            } catch (error) {
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(messages.wXK(String(error?.message || error)));
+            }
+            return cdp;
+        }
+        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 = 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;
+            }
+        }
+        function registerAutoEnableLogging(cdp, getExtensionId) {
+            cdp.onProtocolEvent((message)=>{
+                try {
+                    if (!message || !message.method) return;
+                    if ('Target.attachedToTarget' === message.method) {
+                        const params = message.params || {};
+                        const targetInfo = params.targetInfo || {};
+                        const sessionId = params.sessionId;
+                        const url = String(targetInfo.url || '');
+                        const type = String(targetInfo.type || '');
+                        const extId = getExtensionId();
+                        const matchesExtension = !!(extId && url.includes(`chrome-extension://${extId}/`) || 'service_worker' === type);
+                        if (sessionId && matchesExtension) {
+                            cdp.sendCommand('Runtime.enable', {}, sessionId).catch(()=>{});
+                            cdp.sendCommand('Log.enable', {}, sessionId).catch(()=>{});
+                        }
+                    } else if ('Runtime.consoleAPICalled' === message.method || 'Log.entryAdded' === message.method) {
+                        if ('1' === String(process.env.EXTENSION_VERBOSE || '').trim()) {
+                            const ts = new Date().toISOString();
+                            console.log(messages.bvI(ts, message.params));
+                        }
+                    }
+                } catch (error) {
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(messages.KK1(String(error?.message || error)));
+                }
+            });
+        }
+        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 CDPExtensionController {
+            async connect() {
+                if (this.cdp) return;
+                this.cdp = await connectToChromeCdp(this.cdpPort);
+                try {
+                    await this.cdp.sendCommand('Target.setDiscoverTargets', {
+                        discover: true
+                    });
+                    await this.cdp.sendCommand('Target.setAutoAttach', {
+                        autoAttach: true,
+                        waitForDebuggerOnStart: false,
+                        flatten: true
+                    });
+                } catch (error) {
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(messages.wXK(String(error?.message || error)));
+                }
+                registerAutoEnableLogging(this.cdp, ()=>this.extensionId);
+            }
+            async ensureLoaded() {
+                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) {
+                    const id = await this.deriveExtensionIdFromTargets();
+                    if (id) this.extensionId = id;
+                }
+                if (this.extensionId) try {
+                    let info = null;
+                    try {
+                        info = await this.cdp.getExtensionInfo(this.extensionId);
+                    } catch  {}
+                    if (!info) {
+                        const manifest = JSON.parse(external_fs_.readFileSync(external_path_.join(this.outPath, 'manifest.json'), 'utf-8'));
+                        return {
+                            extensionId: this.extensionId,
+                            name: manifest.name,
+                            version: manifest.version
+                        };
+                    }
+                    return {
+                        extensionId: this.extensionId,
+                        name: info?.extensionInfo?.name,
+                        version: info?.extensionInfo?.version
+                    };
+                } catch  {}
+                try {
+                    if (!this.extensionId) {
+                        const id = await loadUnpackedIfNeeded(this.cdp, this.outPath);
+                        if (id) this.extensionId = id;
+                    }
+                    if (!this.extensionId) this.extensionId = await this.deriveExtensionIdFromTargets(60, 250);
+                    if (!this.extensionId) throw new Error('Failed to determine extension ID via CDP');
+                    await this.enableLogging();
+                    let name;
+                    let version;
+                    try {
+                        const info = await this.cdp.getExtensionInfo(this.extensionId);
+                        name = info?.extensionInfo?.name;
+                        version = info?.extensionInfo?.version;
+                    } catch (error) {
+                        try {
+                            const manifest = readManifestInfo(this.outPath);
+                            name = String(manifest?.name || '') || void 0;
+                            version = String(manifest?.version || '') || void 0;
+                        } catch (e2) {
+                            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn('[CDP] Fallback manifest read failed:', String(e2?.message || e2));
+                        }
+                    }
+                    return {
+                        extensionId: this.extensionId,
+                        name,
+                        version
+                    };
+                } catch (error) {
+                    throw new Error(`Failed to load extension from ${external_path_.resolve(this.outPath)}: ${String(error.message || error)}`);
+                }
+            }
+            async deriveExtensionIdFromTargets(maxRetries = 20, backoffMs = 200) {
+                if (!this.cdp) return null;
+                return await deriveExtensionIdFromTargetsHelper(this.cdp, this.outPath, maxRetries, backoffMs);
+            }
+            async hardReload() {
+                if (!this.cdp || !this.extensionId) return false;
+                try {
+                    return await this.cdp.forceReloadExtension(this.extensionId);
+                } catch  {
+                    return false;
+                }
+            }
+            onProtocolEvent(cb) {
+                if (!this.cdp) throw new Error('CDP not connected');
+                this.cdp.onProtocolEvent((raw)=>{
+                    const evt = raw;
+                    cb(evt);
+                });
+            }
+            clearProtocolEventHandler() {
+                if (!this.cdp) return;
+                this.cdp.onProtocolEvent(()=>{});
+            }
+            async enableUnifiedLogging() {
+                if (!this.cdp) return;
+                try {
+                    await this.cdp.enableAutoAttach();
+                    await this.cdp.enableRuntimeAndLog();
+                    try {
+                        const targets = await this.cdp.getTargets();
+                        for (const t of targets || []){
+                            const type = String(t?.type || '');
+                            if ('page' === type || 'service_worker' === type || 'background_page' === type || 'worker' === type) {
+                                const targetId = String(t?.targetId || '');
+                                if (!targetId) continue;
+                                const sessionId = await this.cdp.attachToTarget(targetId);
+                                await this.cdp.enableRuntimeAndLog(sessionId);
+                            }
+                        }
+                    } catch  {}
+                } catch  {}
+            }
+            async enableRuntimeForSession(sessionId) {
+                if (!this.cdp) return;
+                try {
+                    await this.cdp.enableRuntimeAndLog(sessionId);
+                } catch  {}
+            }
+            async enableLogging() {
+                if (!this.cdp) return;
+                try {
+                    const extId = this.extensionId;
+                    this.onProtocolEvent(async (message)=>{
+                        try {
+                            if (!message || !message.method) return;
+                            if ('Target.attachedToTarget' === message.method) {
+                                const params = message.params || {};
+                                const targetInfo = params.targetInfo || {
+                                    url: '',
+                                    type: ''
+                                };
+                                const sessionId = params.sessionId;
+                                const url = String(targetInfo.url || '');
+                                const type = String(targetInfo.type || '');
+                                const matchesExtension = !!(this.extensionId && url.includes(`chrome-extension://${this.extensionId}/`) || extId && url.includes(`chrome-extension://${extId}/`) || 'service_worker' === type);
+                                if (sessionId && matchesExtension) {
+                                    await this.cdp.sendCommand('Runtime.enable', {}, sessionId);
+                                    await this.cdp.sendCommand('Log.enable', {}, sessionId);
+                                }
+                            } else if ('Runtime.consoleAPICalled' === message.method || 'Log.entryAdded' === message.method) {
+                                const ts = new Date().toISOString();
+                                console.log(messages.bvI(ts, message.params));
+                            }
+                        } catch  {}
+                    });
+                } catch (e) {
+                    if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn('[CDP] enableLogging failed:', String(e));
+                }
+            }
+            async getInfoBestEffort() {
+                try {
+                    if (!this.cdp) return null;
+                    if (!this.extensionId) this.extensionId = await this.deriveExtensionIdFromTargets(20, 200);
+                    if (!this.extensionId) return null;
+                    let name;
+                    let version;
+                    try {
+                        const info = await this.cdp.getExtensionInfo(this.extensionId);
+                        name = info?.extensionInfo?.name;
+                        version = info?.extensionInfo?.version;
+                    } catch  {
+                        try {
+                            const manifest = JSON.parse(external_fs_.readFileSync(external_path_.join(this.outPath, 'manifest.json'), 'utf-8'));
+                            name = manifest?.name;
+                            version = manifest?.version;
+                        } catch  {}
+                    }
+                    return {
+                        extensionId: this.extensionId,
+                        name,
+                        version
+                    };
+                } catch (error) {
+                    return null;
+                }
+            }
+            constructor(args){
+                _define_property(this, "outPath", void 0);
+                _define_property(this, "browser", void 0);
+                _define_property(this, "cdpPort", void 0);
+                _define_property(this, "cdp", null);
+                _define_property(this, "extensionId", null);
+                this.outPath = args.outPath;
+                this.browser = args.browser;
+                this.cdpPort = args.cdpPort;
+            }
+        }
+        var extension_output_path = __webpack_require__("./webpack/plugin-browsers/run-chromium/chromium-launch/extension-output-path.ts");
+        async function setupCdpAfterLaunch(compilation, plugin, chromiumArgs) {
+            const loadExtensionFlag = chromiumArgs.find((flag)=>flag.startsWith('--load-extension='));
+            const extensionOutputPath = (0, extension_output_path.W)(compilation, loadExtensionFlag);
+            const remoteDebugPortFlag = chromiumArgs.find((flag)=>flag.startsWith('--remote-debugging-port='));
+            const chromeRemoteDebugPort = remoteDebugPortFlag ? parseInt(remoteDebugPortFlag.split('=')[1], 10) : (0, shared_utils.jl)(plugin.port, plugin.instanceId);
+            if ('true' === process.env.EXTENSION_AUTHOR_MODE) {
+                const userDataDirFlag = chromiumArgs.find((flag)=>flag.startsWith('--user-data-dir='));
+                if (userDataDirFlag) {
+                    const userDataDir = userDataDirFlag.replace('--user-data-dir=', '').replace(/^"|"$/g, '');
+                    console.log(messages.aIt(userDataDir));
+                }
+                console.log(messages.CYH(chromeRemoteDebugPort, chromeRemoteDebugPort));
+            }
+            const cdpExtensionController = new CDPExtensionController({
+                outPath: extensionOutputPath,
+                browser: 'chromium-based' === plugin.browser ? 'chrome' : plugin.browser,
+                cdpPort: chromeRemoteDebugPort
+            });
+            const retryAsync = async (operation, attempts = 5, initialDelayMs = 150)=>{
+                let lastError;
+                for(let attempt = 0; attempt < attempts; attempt++)try {
+                    return await operation();
+                } catch (error) {
+                    lastError = error;
+                    const backoffMs = initialDelayMs * Math.pow(2, attempt);
+                    await new Promise((resolve)=>setTimeout(resolve, backoffMs));
+                }
+                throw lastError;
+            };
+            await retryAsync(()=>cdpExtensionController.connect());
+            if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.log(messages.M3V('127.0.0.1', chromeRemoteDebugPort));
+            const extensionControllerInfo = await cdpExtensionController.ensureLoaded();
+            try {
+                const mode = compilation?.options?.mode || 'development';
+                if ('development' === mode) {
+                    const bannerPrinted = await (0, banner.a)({
+                        outPath: extensionOutputPath,
+                        browser: plugin.browser,
+                        hostPort: {
+                            host: '127.0.0.1',
+                            port: chromeRemoteDebugPort
+                        },
+                        getInfo: async ()=>extensionControllerInfo,
+                        browserVersionLine: plugin.browserVersionLine
+                    });
+                    if (!bannerPrinted) await (0, banner.a)({
+                        outPath: extensionOutputPath,
+                        browser: plugin.browser,
+                        hostPort: {
+                            host: '127.0.0.1',
+                            port: chromeRemoteDebugPort
+                        },
+                        getInfo: async ()=>cdpExtensionController.getInfoBestEffort(),
+                        browserVersionLine: plugin.browserVersionLine
+                    });
+                } else if ('production' === mode) await (0, banner.M)({
+                    browser: plugin.browser,
+                    outPath: extensionOutputPath,
+                    browserVersionLine: plugin.browserVersionLine,
+                    runtime: {
+                        extensionId: extensionControllerInfo.extensionId,
+                        name: extensionControllerInfo.name,
+                        version: extensionControllerInfo.version
+                    }
+                });
+            } catch (bannerErr) {
+                if ('true' === process.env.EXTENSION_AUTHOR_MODE) console.warn(messages.$wD(String(bannerErr)));
+                try {
+                    const mode = compilation?.options?.mode || 'development';
+                    if ('production' === mode) await (0, banner.M)({
+                        browser: plugin.browser,
+                        outPath: extensionOutputPath,
+                        browserVersionLine: plugin.browserVersionLine
+                    });
+                } catch  {}
+            }
+            plugin.cdpController = cdpExtensionController;
+        }
+    }
+};

package/dist/419.js

@@ -0,0 +1,44 @@
+"use strict";
+exports.ids = [
+    "419"
+];
+exports.modules = {
+    "./webpack/webpack-lib/zip.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            downloadAndExtractZip: ()=>downloadAndExtractZip
+        });
+        var path__rspack_import_0 = __webpack_require__("path");
+        var adm_zip__rspack_import_1 = __webpack_require__("adm-zip");
+        var adm_zip__rspack_import_1_default = /*#__PURE__*/ __webpack_require__.n(adm_zip__rspack_import_1);
+        var _messages__rspack_import_2 = __webpack_require__("./webpack/webpack-lib/messages.ts");
+        async function downloadAndExtractZip(url, targetPath) {
+            const urlNoSearchParams = url.split('?')[0];
+            try {
+                console.log(_messages__rspack_import_2.Ud(urlNoSearchParams));
+                const res = await fetch(url, {
+                    redirect: 'follow'
+                });
+                if (!res.ok || !res.body) throw new Error(`HTTP ${res.status} ${res.statusText}`);
+                const contentType = String(res.headers.get('content-type') || '');
+                const isZipExt = '.zip' === path__rspack_import_0.extname(urlNoSearchParams).toLowerCase();
+                const isZipType = /zip|octet-stream/i.test(contentType);
+                if (!isZipExt && !isZipType) throw new Error(`${_messages__rspack_import_2.tc(urlNoSearchParams, contentType)}`);
+                const extname = path__rspack_import_0.extname(urlNoSearchParams);
+                const basename = path__rspack_import_0.basename(urlNoSearchParams, extname);
+                const destinationPath = path__rspack_import_0.join(targetPath, basename);
+                console.log(_messages__rspack_import_2.gC(destinationPath));
+                const arrayBuffer = await res.arrayBuffer();
+                const zipBuffer = Buffer.from(arrayBuffer);
+                const zip = new (adm_zip__rspack_import_1_default())(zipBuffer);
+                zip.extractAllTo(destinationPath, true);
+                console.log(_messages__rspack_import_2.zM());
+                return destinationPath;
+            } catch (error) {
+                console.error(_messages__rspack_import_2.GW(error));
+                const err = new Error(`${_messages__rspack_import_2.GW(error)}`);
+                err.code = 'EZIP';
+                throw err;
+            }
+        }
+    }
+};