@xcanwin/manyoyo 5.1.0 → 5.1.4

package/bin/manyoyo.js

@@ -14,7 +14,7 @@ const { buildContainerRunArgs, buildContainerRunCommand } = require('../lib/cont
 const { initAgentConfigs } = require('../lib/init-config');
 const { buildImage } = require('../lib/image-build');
 const { resolveAgentResumeArg, buildAgentResumeCommand } = require('../lib/agent-resume');
-const { runPluginCommand } = require('../lib/services');
+const { runPluginCommand } = require('../lib/plugin');
 const { version: BIN_VERSION, imageVersion: IMAGE_VERSION_DEFAULT } = require('../package.json');
 const IMAGE_VERSION_BASE = String(IMAGE_VERSION_DEFAULT || '1.0.0').split('-')[0];
 const IMAGE_VERSION_HELP_EXAMPLE = IMAGE_VERSION_DEFAULT || `${IMAGE_VERSION_BASE}-common`;
@@ -873,7 +873,10 @@ async function setupCommander() {
             pluginAction: params.action || 'ls',
             pluginName: params.pluginName || 'playwright',
             pluginScene: params.scene || 'host-headless',
-            pluginHost: params.host || ''
+            pluginHost: params.host || '',
+            pluginExtensionPaths: Array.isArray(params.extensionPaths) ? params.extensionPaths : [],
+            pluginExtensionNames: Array.isArray(params.extensionNames) ? params.extensionNames : [],
+            pluginProdversion: params.prodversion || ''
         });
     };
 
@@ -889,14 +892,22 @@ async function setupCommander() {
 
         const actions = ['up', 'down', 'status', 'health', 'logs'];
         actions.forEach(action => {
-            command.command(`${action} [scene]`)
+            const sceneCommand = command.command(`${action} [scene]`)
                 .description(`${action} playwright 场景，scene 默认 host-headless`)
-                .option('-r, --run <name>', '加载运行配置 (从 ~/.manyoyo/manyoyo.json 的 runs.<name> 读取)')
-                .action((scene, options) => selectPluginAction({
-                    action,
-                    pluginName: 'playwright',
-                    scene: scene || 'host-headless'
-                }, options));
+                .option('-r, --run <name>', '加载运行配置 (从 ~/.manyoyo/manyoyo.json 的 runs.<name> 读取)');
+
+            if (action === 'up') {
+                appendArrayOption(sceneCommand, '--ext-path <path>', '追加浏览器扩展目录（可多次传入；目录需包含 manifest.json）');
+                appendArrayOption(sceneCommand, '--ext-name <name>', '追加 ~/.manyoyo/plugin/playwright/extensions/ 下的扩展目录名（可多次传入）');
+            }
+
+            sceneCommand.action((scene, options) => selectPluginAction({
+                action,
+                pluginName: 'playwright',
+                scene: scene || 'host-headless',
+                extensionPaths: action === 'up' ? (options.extPath || []) : [],
+                extensionNames: action === 'up' ? (options.extName || []) : []
+            }, options));
         });
 
         command.command('mcp-add')
@@ -909,6 +920,16 @@ async function setupCommander() {
                 scene: 'all',
                 host: options.host || ''
             }, options));
+
+        command.command('ext-download')
+            .description('下载并解压 Playwright 扩展到 ~/.manyoyo/plugin/playwright/extensions/')
+            .option('--prodversion <ver>', 'CRX 下载使用的 Chrome 版本号 (默认 132.0.0.0)')
+            .action(options => selectPluginAction({
+                action: 'ext-download',
+                pluginName: 'playwright',
+                scene: 'all',
+                prodversion: options.prodversion || ''
+            }, options));
     };
 
     program
@@ -1095,7 +1116,10 @@ async function setupCommander() {
                 action: options.pluginAction,
                 pluginName: options.pluginName,
                 scene: options.pluginScene || 'host-headless',
-                host: options.pluginHost || ''
+                host: options.pluginHost || '',
+                extensionPaths: Array.isArray(options.pluginExtensionPaths) ? options.pluginExtensionPaths : [],
+                extensionNames: Array.isArray(options.pluginExtensionNames) ? options.pluginExtensionNames : [],
+                prodversion: options.pluginProdversion || ''
             },
             pluginGlobalConfig: config,
             pluginRunConfig: runConfig

package/config.example.json

@@ -36,6 +36,8 @@
             "mcpDefaultHost": "host.docker.internal",
             // cont-headed 场景读取的密码环境变量名（默认 VNC_PASSWORD）
             "vncPasswordEnvKey": "VNC_PASSWORD",
+            // playwright ext-download 的 CRX prodversion 参数
+            "extensionProdversion": "132.0.0.0",
             "ports": {
                 "contHeadless": 8931,
                 "contHeaded": 8932,

package/lib/{services → plugin}/index.js

@@ -52,7 +52,10 @@ async function runPluginCommand(request, options = {}) {
     return await plugin.run({
         action,
         scene: request.scene,
-        host: request.host
+        host: request.host,
+        extensionPaths: request.extensionPaths,
+        extensionNames: request.extensionNames,
+        prodversion: request.prodversion
     });
 }
 

package/lib/{services → plugin}/playwright.js

@@ -6,6 +6,14 @@ const os = require('os');
 const path = require('path');
 const { spawn, spawnSync } = require('child_process');
 
+const EXTENSIONS = [
+    ['ublock-origin-lite', 'ddkjiahejlhfcafbddmgiahcphecmpfh'],
+    ['adguard', 'bgnkhhnnamicmpeenaelnjfhikgbkllg'],
+    ['privacy-badger', 'pkehgijcmpdhfbdbbnkijodmdjhbjlgp'],
+    ['webrtc-leak-shield', 'bppamachkoflopbagkdoflbgfjflfnfl'],
+    ['webgl-fingerprint-defender', 'olnbjpaejebpnokblkepbphhembdicik']
+];
+
 const SCENE_ORDER = ['cont-headless', 'cont-headed', 'host-headless', 'host-headed'];
 
 const SCENE_DEFS = {
@@ -47,6 +55,7 @@ const SCENE_DEFS = {
 
 const VALID_RUNTIME = new Set(['container', 'host', 'mixed']);
 const VALID_ACTIONS = new Set(['up', 'down', 'status', 'health', 'logs']);
+const CONTAINER_EXTENSION_ROOT = '/app/extensions';
 
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
@@ -76,6 +85,129 @@ function asStringArray(value, fallback) {
         .filter(Boolean);
 }
 
+function isHostPermission(value) {
+    if (value === '<all_urls>') {
+        return true;
+    }
+    return /^(?:\*|http|https|file|ftp):\/\//.test(value);
+}
+
+function scriptSourcesFromHtml(htmlFile) {
+    const content = fs.readFileSync(htmlFile, { encoding: 'utf8' });
+    const scripts = [...content.matchAll(/<script[^>]+src=["']([^"']+)["']/gi)].map(m => m[1]);
+    return scripts.filter(src => !/^(?:https?:)?\/\//.test(src));
+}
+
+function convertManifestV2ToV3(extDir) {
+    const manifestFile = path.join(extDir, 'manifest.json');
+    const manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
+    if (manifest.manifest_version !== 2) {
+        return false;
+    }
+
+    manifest.manifest_version = 3;
+
+    if (manifest.browser_action && !manifest.action) {
+        manifest.action = manifest.browser_action;
+        delete manifest.browser_action;
+    }
+    if (manifest.page_action && !manifest.action) {
+        manifest.action = manifest.page_action;
+        delete manifest.page_action;
+    }
+
+    const background = manifest.background;
+    if (background && typeof background === 'object' && !Array.isArray(background)) {
+        let scripts = [];
+        if (Array.isArray(background.scripts)) {
+            scripts = background.scripts.filter(s => typeof s === 'string');
+        } else if (typeof background.page === 'string') {
+            const pagePath = path.join(extDir, background.page);
+            if (fs.existsSync(pagePath)) {
+                scripts = scriptSourcesFromHtml(pagePath);
+            }
+        }
+
+        if (scripts.length > 0) {
+            const swName = 'generated_background_sw.js';
+            const swFile = path.join(extDir, swName);
+            const swLines = [
+                '// Auto-generated by manyoyo playwright ext-download for MV3.',
+                `importScripts(${scripts.map(s => JSON.stringify(s)).join(', ')});`,
+                ''
+            ];
+            fs.writeFileSync(swFile, swLines.join('\n'), 'utf8');
+            manifest.background = { service_worker: swName };
+        } else {
+            delete manifest.background;
+        }
+    }
+
+    if (typeof manifest.content_security_policy === 'string') {
+        manifest.content_security_policy = { extension_pages: manifest.content_security_policy };
+    }
+
+    if (Array.isArray(manifest.permissions)) {
+        const hostPermissions = Array.isArray(manifest.host_permissions) ? [...manifest.host_permissions] : [];
+        const keptPermissions = [];
+
+        for (const perm of manifest.permissions) {
+            if (typeof perm === 'string' && isHostPermission(perm)) {
+                if (!hostPermissions.includes(perm)) {
+                    hostPermissions.push(perm);
+                }
+            } else {
+                keptPermissions.push(perm);
+            }
+        }
+
+        manifest.permissions = keptPermissions;
+        if (hostPermissions.length > 0) {
+            manifest.host_permissions = hostPermissions;
+        }
+    }
+
+    const war = manifest.web_accessible_resources;
+    if (Array.isArray(war) && war.length > 0 && war.every(v => typeof v === 'string')) {
+        manifest.web_accessible_resources = [
+            {
+                resources: war,
+                matches: ['<all_urls>']
+            }
+        ];
+    }
+
+    fs.writeFileSync(manifestFile, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    return true;
+}
+
+function buildCrxUrl(extId, prodversion) {
+    return (
+        'https://clients2.google.com/service/update2/crx' +
+        `?response=redirect&prodversion=${prodversion}` +
+        '&acceptformat=crx2,crx3' +
+        `&x=id%3D${extId}%26installsource%3Dondemand%26uc`
+    );
+}
+
+function crxZipOffset(data) {
+    if (data.subarray(0, 4).toString('ascii') !== 'Cr24') {
+        throw new Error('not a CRX file');
+    }
+
+    const version = data.readUInt32LE(4);
+    if (version === 2) {
+        const pubLen = data.readUInt32LE(8);
+        const sigLen = data.readUInt32LE(12);
+        return 16 + pubLen + sigLen;
+    }
+    if (version === 3) {
+        const headerLen = data.readUInt32LE(8);
+        return 12 + headerLen;
+    }
+    throw new Error(`unsupported CRX version: ${version}`);
+}
+
 class PlaywrightPlugin {
     constructor(options = {}) {
         this.projectRoot = options.projectRoot || path.join(__dirname, '..', '..');
@@ -88,6 +220,7 @@ class PlaywrightPlugin {
 
     resolveConfig() {
         const homeDir = os.homedir();
+        const pluginRootDir = path.join(homeDir, '.manyoyo', 'plugin', 'playwright');
         const defaultConfig = {
             runtime: 'mixed',
             enabledScenes: [...SCENE_ORDER],
@@ -98,8 +231,9 @@ class PlaywrightPlugin {
             containerRuntime: 'podman',
             vncPasswordEnvKey: 'VNC_PASSWORD',
             headedImage: 'localhost/xcanwin/manyoyo-playwright-headed',
-            configDir: path.join(homeDir, '.manyoyo', 'services', 'playwright', 'config'),
-            runDir: path.join(homeDir, '.manyoyo', 'services', 'playwright', 'run'),
+            configDir: path.join(pluginRootDir, 'config'),
+            runDir: path.join(pluginRootDir, 'run'),
+            extensionProdversion: '132.0.0.0',
             composeDir: path.join(__dirname, 'playwright-assets'),
             ports: {
                 contHeadless: 8931,
@@ -184,8 +318,15 @@ class PlaywrightPlugin {
     }
 
     ensureCommandAvailable(command) {
-        const check = this.runCmd([command, '--version'], { captureOutput: true, check: false });
-        return check.returncode === 0;
+        const name = String(command || '').trim();
+        if (!/^[A-Za-z0-9._-]+$/.test(name)) {
+            return false;
+        }
+        const result = spawnSync('sh', ['-c', `command -v ${name}`], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'ignore', 'ignore']
+        });
+        return result.status === 0;
     }
 
     scenePort(sceneName) {
@@ -198,6 +339,32 @@ class PlaywrightPlugin {
         return path.join(this.config.configDir, def.configFile);
     }
 
+    sceneConfigMissing(sceneName) {
+        return !fs.existsSync(this.sceneConfigPath(sceneName));
+    }
+
+    defaultBrowserName(sceneName) {
+        const cfg = this.buildSceneConfig(sceneName);
+        const browserName = cfg && cfg.browser && cfg.browser.browserName;
+        return String(browserName || 'chromium');
+    }
+
+    ensureContainerScenePrerequisites(sceneName) {
+        if (!this.sceneConfigMissing(sceneName)) {
+            return;
+        }
+        const tag = String(this.config.dockerTag || 'latest').trim() || 'latest';
+        const image = `mcr.microsoft.com/playwright/mcp:${tag}`;
+        this.runCmd([this.config.containerRuntime, 'pull', image], { check: true });
+    }
+
+    ensureHostScenePrerequisites(sceneName) {
+        if (!this.sceneConfigMissing(sceneName)) {
+            return;
+        }
+        this.runCmd(['npx', '-y', 'playwright-core', 'install', this.defaultBrowserName(sceneName)], { check: true });
+    }
+
     scenePidFile(sceneName) {
         return path.join(this.config.runDir, `${sceneName}.pid`);
     }
@@ -206,6 +373,14 @@ class PlaywrightPlugin {
         return path.join(this.config.runDir, `${sceneName}.log`);
     }
 
+    extensionDirPath() {
+        return path.join(os.homedir(), '.manyoyo', 'plugin', 'playwright', 'extensions');
+    }
+
+    extensionTmpDirPath() {
+        return path.join(os.homedir(), '.manyoyo', 'plugin', 'playwright', 'tmp-crx');
+    }
+
     resolveTargets(sceneName = 'all') {
         const requested = String(sceneName || 'all').trim();
         const enabledSet = new Set(this.config.enabledScenes);
@@ -237,9 +412,112 @@ class PlaywrightPlugin {
             .filter(scene => isAllowedByRuntime(scene));
     }
 
-    buildSceneConfig(sceneName) {
+    resolveExtensionPaths(extensionArgs = []) {
+        const inputs = asStringArray(extensionArgs, []);
+        const uniquePaths = [];
+        const seen = new Set();
+
+        for (const item of inputs) {
+            const absPath = path.resolve(item);
+            if (!fs.existsSync(absPath)) {
+                throw new Error(`扩展路径不存在: ${absPath}`);
+            }
+            const stat = fs.statSync(absPath);
+            if (!stat.isDirectory()) {
+                throw new Error(`扩展路径必须是目录: ${absPath}`);
+            }
+
+            const manifestPath = path.join(absPath, 'manifest.json');
+            if (fs.existsSync(manifestPath)) {
+                if (!seen.has(absPath)) {
+                    seen.add(absPath);
+                    uniquePaths.push(absPath);
+                }
+                continue;
+            }
+
+            const children = fs.readdirSync(absPath, { withFileTypes: true })
+                .filter(dirent => dirent.isDirectory())
+                .map(dirent => path.join(absPath, dirent.name))
+                .filter(child => fs.existsSync(path.join(child, 'manifest.json')));
+
+            if (children.length === 0) {
+                throw new Error(`目录下未找到扩展(manifest.json): ${absPath}`);
+            }
+
+            for (const childPath of children) {
+                if (!seen.has(childPath)) {
+                    seen.add(childPath);
+                    uniquePaths.push(childPath);
+                }
+            }
+        }
+
+        return uniquePaths;
+    }
+
+    resolveNamedExtensionPaths(extensionNames = []) {
+        const names = asStringArray(extensionNames, []);
+        const extensionRoot = path.resolve(this.extensionDirPath());
+
+        return names.map(name => {
+            if (name.includes('/') || name.includes('\\') || name === '.' || name === '..') {
+                throw new Error(`扩展名称无效: ${name}`);
+            }
+            return path.join(extensionRoot, name);
+        });
+    }
+
+    resolveExtensionInputs(options = {}) {
+        const extensionPaths = asStringArray(options.extensionPaths, []);
+        const namedPaths = this.resolveNamedExtensionPaths(options.extensionNames || []);
+        return this.resolveExtensionPaths([...extensionPaths, ...namedPaths]);
+    }
+
+    buildExtensionLaunchArgs(extensionPaths) {
+        const joined = extensionPaths.join(',');
+        return [
+            `--disable-extensions-except=${joined}`,
+            `--load-extension=${joined}`
+        ];
+    }
+
+    sanitizeExtensionMountName(value) {
+        const sanitized = String(value || '')
+            .trim()
+            .replace(/[^A-Za-z0-9._-]/g, '-')
+            .replace(/-+/g, '-')
+            .replace(/^-|-$/g, '');
+        return sanitized || 'ext';
+    }
+
+    buildContainerExtensionMounts(extensionPaths = []) {
+        const hostPaths = asStringArray(extensionPaths, []);
+        const containerPaths = [];
+        const volumeMounts = [];
+
+        hostPaths.forEach((hostPath, idx) => {
+            const safeName = this.sanitizeExtensionMountName(path.basename(hostPath));
+            const containerPath = path.posix.join(CONTAINER_EXTENSION_ROOT, `ext-${idx + 1}-${safeName}`);
+            containerPaths.push(containerPath);
+            volumeMounts.push(`${hostPath}:${containerPath}:ro`);
+        });
+
+        return { containerPaths, volumeMounts };
+    }
+
+    buildSceneConfig(sceneName, options = {}) {
         const def = SCENE_DEFS[sceneName];
         const port = this.scenePort(sceneName);
+        const extensionPaths = asStringArray(options.extensionPaths, []);
+        const launchOptions = {
+            channel: 'chromium',
+            headless: def.headless
+        };
+
+        if (extensionPaths.length > 0) {
+            launchOptions.args = this.buildExtensionLaunchArgs(extensionPaths);
+        }
 
         return {
             server: {
@@ -255,10 +533,7 @@ class PlaywrightPlugin {
             browser: {
                 chromiumSandbox: true,
                 browserName: 'chromium',
-                launchOptions: {
-                    channel: 'chromium',
-                    headless: def.headless
-                },
+                launchOptions,
                 contextOptions: {
                     userAgent: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36'
                 }
@@ -266,9 +541,9 @@ class PlaywrightPlugin {
         };
     }
 
-    ensureSceneConfig(sceneName) {
+    ensureSceneConfig(sceneName, options = {}) {
         fs.mkdirSync(this.config.configDir, { recursive: true });
-        const payload = this.buildSceneConfig(sceneName);
+        const payload = this.buildSceneConfig(sceneName, options);
         const filePath = this.sceneConfigPath(sceneName);
         fs.writeFileSync(filePath, `${JSON.stringify(payload, null, 4)}\n`, 'utf8');
         return filePath;
@@ -339,28 +614,74 @@ class PlaywrightPlugin {
         return path.join(this.config.composeDir, def.composeFile);
     }
 
-    async startContainer(sceneName) {
+    sceneComposeOverridePath(sceneName) {
+        return path.join(this.config.runDir, `${sceneName}.compose.override.yaml`);
+    }
+
+    ensureContainerComposeOverride(sceneName, volumeMounts = []) {
+        const overridePath = this.sceneComposeOverridePath(sceneName);
+        if (!Array.isArray(volumeMounts) || volumeMounts.length === 0) {
+            fs.rmSync(overridePath, { force: true });
+            return '';
+        }
+
+        fs.mkdirSync(this.config.runDir, { recursive: true });
+        const lines = [
+            'services:',
+            '  playwright:',
+            '    volumes:'
+        ];
+        volumeMounts.forEach(item => {
+            lines.push(`      - ${JSON.stringify(String(item))}`);
+        });
+        fs.writeFileSync(overridePath, `${lines.join('\n')}\n`, 'utf8');
+        return overridePath;
+    }
+
+    async startContainer(sceneName, options = {}) {
         const runtime = this.config.containerRuntime;
         if (!this.ensureCommandAvailable(runtime)) {
             this.writeStderr(`[up] ${sceneName} failed: ${runtime} command not found.`);
             return 1;
         }
 
-        const cfgPath = this.ensureSceneConfig(sceneName);
+        try {
+            this.ensureContainerScenePrerequisites(sceneName);
+        } catch (error) {
+            return error.returncode || 1;
+        }
+
+        const incomingExtensionPaths = asStringArray(options.extensionPaths, []);
+        let configOptions = { ...options, extensionPaths: incomingExtensionPaths };
+        const composeFiles = [this.containerComposePath(sceneName)];
+
+        if (incomingExtensionPaths.length > 0) {
+            const mapped = this.buildContainerExtensionMounts(incomingExtensionPaths);
+            const overridePath = this.ensureContainerComposeOverride(sceneName, mapped.volumeMounts);
+            if (overridePath) {
+                composeFiles.push(overridePath);
+            }
+            configOptions = { ...options, extensionPaths: mapped.containerPaths };
+        } else {
+            this.ensureContainerComposeOverride(sceneName, []);
+        }
+
+        const cfgPath = this.ensureSceneConfig(sceneName, configOptions);
         const env = this.containerEnv(sceneName, cfgPath, { requireVncPassword: true });
         const def = SCENE_DEFS[sceneName];
 
         try {
-            this.runCmd([
+            const args = [
                 runtime,
                 'compose',
                 '-p',
-                def.projectName,
-                '-f',
-                this.containerComposePath(sceneName),
-                'up',
-                '-d'
-            ], { env, check: true });
+                def.projectName
+            ];
+            composeFiles.forEach(filePath => {
+                args.push('-f', filePath);
+            });
+            args.push('up', '-d');
+            this.runCmd(args, { env, check: true });
         } catch (error) {
             return error.returncode || 1;
         }
@@ -382,6 +703,7 @@ class PlaywrightPlugin {
             return 1;
         }
 
+        this.ensureContainerComposeOverride(sceneName, []);
         const cfgPath = this.sceneConfigPath(sceneName);
         const env = this.containerEnv(sceneName, cfgPath);
         const def = SCENE_DEFS[sceneName];
@@ -520,14 +842,20 @@ class PlaywrightPlugin {
         return [];
     }
 
-    async startHost(sceneName) {
+    async startHost(sceneName, options = {}) {
         if (!this.ensureCommandAvailable('npx')) {
             this.writeStderr(`[up] ${sceneName} failed: npx command not found.`);
             return 1;
         }
 
+        try {
+            this.ensureHostScenePrerequisites(sceneName);
+        } catch (error) {
+            return error.returncode || 1;
+        }
+
         fs.mkdirSync(this.config.runDir, { recursive: true });
-        const cfgPath = this.ensureSceneConfig(sceneName);
+        const cfgPath = this.ensureSceneConfig(sceneName, options);
         const pidFile = this.scenePidFile(sceneName);
         const logFile = this.sceneLogFile(sceneName);
         const port = this.scenePort(sceneName);
@@ -665,6 +993,118 @@ class PlaywrightPlugin {
         return 0;
     }
 
+    async downloadFile(url, output, retries = 3, timeoutMs = 60_000) {
+        const timeoutSec = Math.max(1, Math.ceil(timeoutMs / 1000));
+        if (!this.ensureCommandAvailable('curl')) {
+            throw new Error('curl command not found');
+        }
+
+        let lastError = null;
+        for (let i = 1; i <= retries; i += 1) {
+            try {
+                const result = this.runCmd([
+                    'curl',
+                    '--fail',
+                    '--location',
+                    '--silent',
+                    '--show-error',
+                    '--connect-timeout',
+                    String(timeoutSec),
+                    '--max-time',
+                    String(timeoutSec),
+                    '--output',
+                    output,
+                    url
+                ], { captureOutput: true, check: false });
+                if (result.returncode !== 0) {
+                    throw new Error(result.stderr || `curl failed with exit code ${result.returncode}`);
+                }
+                return;
+            } catch (error) {
+                lastError = error;
+                if (i < retries) {
+                    // eslint-disable-next-line no-await-in-loop
+                    await sleep(1000);
+                }
+            }
+        }
+
+        throw new Error(`download failed after ${retries} attempts: ${url}; ${String(lastError)}`);
+    }
+
+    extractZipBuffer(zipBuffer, outDir) {
+        fs.mkdirSync(outDir, { recursive: true });
+        const tempZip = path.join(os.tmpdir(), `manyoyo-playwright-ext-${process.pid}-${Date.now()}.zip`);
+        fs.writeFileSync(tempZip, zipBuffer);
+
+        const result = spawnSync('unzip', ['-oq', tempZip, '-d', outDir], { encoding: 'utf8' });
+        fs.rmSync(tempZip, { force: true });
+
+        if (result.error) {
+            throw result.error;
+        }
+        if (result.status !== 0) {
+            throw new Error(result.stderr || `unzip failed with exit code ${result.status}`);
+        }
+    }
+
+    extractCrx(crxFile, outDir) {
+        const data = fs.readFileSync(crxFile);
+        const offset = crxZipOffset(data);
+        const zipBuffer = data.subarray(offset);
+
+        this.extractZipBuffer(zipBuffer, outDir);
+
+        const manifest = path.join(outDir, 'manifest.json');
+        if (!fs.existsSync(manifest)) {
+            throw new Error(`${crxFile} extracted but manifest.json missing`);
+        }
+
+        if (convertManifestV2ToV3(outDir)) {
+            this.writeStdout(`[manifest] upgraded to MV3: ${path.basename(outDir)}`);
+        }
+    }
+
+    async downloadExtensions(options = {}) {
+        if (!this.ensureCommandAvailable('unzip')) {
+            this.writeStderr('[ext-download] failed: unzip command not found.');
+            return 1;
+        }
+
+        const prodversion = String(options.prodversion || this.config.extensionProdversion || '132.0.0.0').trim();
+        const extDir = path.resolve(this.extensionDirPath());
+        const tmpDir = path.resolve(this.extensionTmpDirPath());
+
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        fs.mkdirSync(extDir, { recursive: true });
+        fs.mkdirSync(tmpDir, { recursive: true });
+
+        try {
+            this.writeStdout(`[info] ext dir: ${extDir}`);
+            this.writeStdout(`[info] tmp dir: ${tmpDir}`);
+
+            for (const [name, extId] of EXTENSIONS) {
+                const url = buildCrxUrl(extId, prodversion);
+                const crxFile = path.join(tmpDir, `${name}.crx`);
+                const outDir = path.join(extDir, name);
+
+                this.writeStdout(`[download] ${name}`);
+                // eslint-disable-next-line no-await-in-loop
+                await this.downloadFile(url, crxFile);
+
+                this.writeStdout(`[extract] ${name}`);
+                fs.rmSync(outDir, { recursive: true, force: true });
+                this.extractCrx(crxFile, outDir);
+            }
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+            this.writeStdout(`[cleanup] removed ${tmpDir}`);
+        }
+
+        this.writeStdout(`[done] all extensions are ready: ${extDir}`);
+        return 0;
+    }
+
     detectCurrentIPv4() {
         const interfaces = os.networkInterfaces();
         for (const values of Object.values(interfaces)) {
@@ -724,12 +1164,12 @@ class PlaywrightPlugin {
         return 0;
     }
 
-    async runOnScene(action, sceneName) {
+    async runOnScene(action, sceneName, options = {}) {
         const def = SCENE_DEFS[sceneName];
         if (action === 'up') {
             return def.type === 'container'
-                ? await this.startContainer(sceneName)
-                : await this.startHost(sceneName);
+                ? await this.startContainer(sceneName, options)
+                : await this.startHost(sceneName, options);
         }
         if (action === 'down') {
             return def.type === 'container'
@@ -753,7 +1193,7 @@ class PlaywrightPlugin {
         return 1;
     }
 
-    async run({ action, scene = 'host-headless', host = '' }) {
+    async run({ action, scene = 'host-headless', host = '', extensionPaths = [], extensionNames = [], prodversion = '' }) {
         if (action === 'ls') {
             return this.printSummary();
         }
@@ -762,6 +1202,10 @@ class PlaywrightPlugin {
             return this.printMcpAdd(host);
         }
 
+        if (action === 'ext-download') {
+            return await this.downloadExtensions({ prodversion });
+        }
+
         if (!VALID_ACTIONS.has(action)) {
             throw new Error(`未知 plugin 动作: ${action}`);
         }
@@ -772,10 +1216,14 @@ class PlaywrightPlugin {
             return 1;
         }
 
+        const resolvedExtensionPaths = action === 'up'
+            ? this.resolveExtensionInputs({ extensionPaths, extensionNames })
+            : [];
+
         let rc = 0;
         for (const sceneName of targets) {
             // eslint-disable-next-line no-await-in-loop
-            const code = await this.runOnScene(action, sceneName);
+            const code = await this.runOnScene(action, sceneName, { extensionPaths: resolvedExtensionPaths });
             if (code !== 0) {
                 rc = 1;
             }
@@ -786,6 +1234,7 @@ class PlaywrightPlugin {
 }
 
 module.exports = {
+    EXTENSIONS,
     SCENE_ORDER,
     SCENE_DEFS,
     PlaywrightPlugin

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@xcanwin/manyoyo",
-    "version": "5.1.0",
+    "version": "5.1.4",
     "imageVersion": "1.8.1-common",
     "description": "AI Agent CLI Security Sandbox for Docker and Podman",
     "keywords": [