@xcanwin/manyoyo 5.8.9 → 5.8.11

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@xcanwin/manyoyo",
-    "version": "5.8.9",
+    "version": "5.8.11",
     "imageVersion": "1.9.0-common",
     "playwrightCliVersion": "0.1.1",
     "description": "AI Agent CLI Security Sandbox for Docker and Podman",

package/lib/plugin/playwright-bootstrap.js

@@ -1,116 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-function createPlaywrightBootstrapManager(options = {}) {
-    const plugin = options.plugin;
-    const isCliScene = options.isCliScene || (() => false);
-
-    return {
-        buildInitScriptContent() {
-            const lines = [
-                "'use strict';",
-                '(function () {',
-                `    const platformValue = ${JSON.stringify(plugin.config.navigatorPlatform)};`,
-                '    try {',
-                '        const navProto = Object.getPrototypeOf(navigator);',
-                "        Object.defineProperty(navProto, 'platform', {",
-                '            configurable: true,',
-                '            get: () => platformValue',
-                '        });',
-                '    } catch (_) {}'
-            ];
-
-            if (plugin.config.disableWebRTC) {
-                lines.push(
-                    '    try {',
-                    '        const scope = globalThis;',
-                    "        const blocked = ['RTCPeerConnection', 'webkitRTCPeerConnection', 'RTCIceCandidate', 'RTCRtpSender', 'RTCRtpReceiver', 'RTCRtpTransceiver', 'RTCDataChannel'];",
-                    '        for (const name of blocked) {',
-                    "            Object.defineProperty(scope, name, { configurable: true, writable: true, value: undefined });",
-                    '        }',
-                    '        if (navigator.mediaDevices) {',
-                    '            const errorFactory = () => {',
-                    '                try {',
-                    "                    return new DOMException('WebRTC is disabled', 'NotAllowedError');",
-                    '                } catch (_) {',
-                    "                    const error = new Error('WebRTC is disabled');",
-                    "                    error.name = 'NotAllowedError';",
-                    '                    return error;',
-                    '                }',
-                    '            };',
-                    "            Object.defineProperty(navigator.mediaDevices, 'getUserMedia', {",
-                    '                configurable: true,',
-                    '                writable: true,',
-                    '                value: async () => { throw errorFactory(); }',
-                    '            });',
-                    '        }',
-                    '    } catch (_) {}'
-                );
-            }
-
-            lines.push('})();', '');
-            return lines.join('\n');
-        },
-        ensureSceneInitScript(sceneName) {
-            const filePath = plugin.sceneInitScriptPath(sceneName);
-            const content = this.buildInitScriptContent();
-            fs.writeFileSync(filePath, content, 'utf8');
-            return filePath;
-        },
-        defaultBrowserName(sceneName) {
-            if (isCliScene(sceneName)) {
-                return 'chromium';
-            }
-            const cfg = plugin.buildSceneConfig(sceneName);
-            const browserName = cfg && cfg.browser && cfg.browser.browserName;
-            return String(browserName || 'chromium');
-        },
-        ensureContainerScenePrerequisites(sceneName) {
-            if (!plugin.sceneConfigMissing(sceneName)) {
-                return;
-            }
-            const tag = String(plugin.config.dockerTag || 'latest').trim() || 'latest';
-            const image = `mcr.microsoft.com/playwright/mcp:${tag}`;
-            plugin.runCmd([plugin.config.containerRuntime, 'pull', image], { check: true });
-        },
-        ensureHostScenePrerequisites(sceneName) {
-            if (!isCliScene(sceneName) && !plugin.sceneConfigMissing(sceneName)) {
-                return;
-            }
-            plugin.runCmd([plugin.playwrightBinPath(sceneName), 'install', '--with-deps', plugin.defaultBrowserName(sceneName)], { check: true });
-        },
-        localBinPath(binName) {
-            const filename = process.platform === 'win32' ? `${binName}.cmd` : binName;
-            const binPath = path.join(plugin.projectRoot, 'node_modules', '.bin', filename);
-            if (!fs.existsSync(binPath)) {
-                throw new Error(`local binary not found: ${binPath}. Run npm install first.`);
-            }
-            return binPath;
-        },
-        playwrightBinPath(sceneName) {
-            if (!isCliScene(sceneName)) {
-                return plugin.localBinPath('playwright');
-            }
-
-            const filename = process.platform === 'win32' ? 'playwright.cmd' : 'playwright';
-            const candidates = [
-                path.join(plugin.projectRoot, 'node_modules', '@playwright', 'mcp', 'node_modules', '.bin', filename),
-                path.join(plugin.projectRoot, 'node_modules', '.bin', filename)
-            ];
-
-            for (const candidate of candidates) {
-                if (fs.existsSync(candidate)) {
-                    return candidate;
-                }
-            }
-
-            throw new Error(`local binary not found for ${sceneName}. Run npm install first.`);
-        }
-    };
-}
-
-module.exports = {
-    createPlaywrightBootstrapManager
-};

package/lib/plugin/playwright-command-output.js

@@ -1,95 +0,0 @@
-'use strict';
-
-const os = require('os');
-
-function createPlaywrightCommandOutputManager(options = {}) {
-    const plugin = options.plugin;
-    const isMcpScene = options.isMcpScene || (() => false);
-    const playwrightCliVersion = options.playwrightCliVersion || '';
-
-    return {
-        detectCurrentIPv4() {
-            const interfaces = os.networkInterfaces();
-            for (const values of Object.values(interfaces)) {
-                if (!Array.isArray(values)) {
-                    continue;
-                }
-                for (const item of values) {
-                    if (!item || item.internal) {
-                        continue;
-                    }
-                    if (item.family === 'IPv4') {
-                        return item.address;
-                    }
-                }
-            }
-            return '';
-        },
-        resolveMcpAddHost(hostArg) {
-            if (!hostArg) {
-                return plugin.config.mcpDefaultHost;
-            }
-            const value = String(hostArg).trim();
-            if (!value) {
-                return '';
-            }
-            if (value === 'current-ip') {
-                return this.detectCurrentIPv4();
-            }
-            return value;
-        },
-        printMcpAdd(hostArg) {
-            const host = this.resolveMcpAddHost(hostArg);
-            if (!host) {
-                plugin.writeStderr('[mcp-add] failed: cannot determine host. Use --host <host> to set one explicitly.');
-                return 1;
-            }
-
-            const scenes = plugin.resolveTargets('all').filter(sceneName => isMcpScene(sceneName));
-            for (const sceneName of scenes) {
-                const url = `http://${host}:${plugin.scenePort(sceneName)}/mcp`;
-                plugin.writeStdout(`claude mcp add -t http -s user playwright-${sceneName} ${url}`);
-            }
-            plugin.writeStdout('');
-            for (const sceneName of scenes) {
-                const url = `http://${host}:${plugin.scenePort(sceneName)}/mcp`;
-                plugin.writeStdout(`codex mcp add playwright-${sceneName} --url ${url}`);
-            }
-            plugin.writeStdout('');
-            for (const sceneName of scenes) {
-                const url = `http://${host}:${plugin.scenePort(sceneName)}/mcp`;
-                plugin.writeStdout(`gemini mcp add -t http -s user playwright-${sceneName} ${url}`);
-            }
-
-            return 0;
-        },
-        printCliAdd() {
-            const lines = [
-                'PLAYWRIGHT_CLI_INSTALL_DIR="${TMPDIR:-/tmp}/manyoyo-playwright-cli-install-$$"',
-                'mkdir -p "$PLAYWRIGHT_CLI_INSTALL_DIR/.playwright"',
-                'echo \'{"browser":{"browserName":"chromium","launchOptions":{"channel":"chromium"}}}\' > "$PLAYWRIGHT_CLI_INSTALL_DIR/.playwright/cli.config.json"',
-                'cd "$PLAYWRIGHT_CLI_INSTALL_DIR"',
-                `npm install -g @playwright/cli@${playwrightCliVersion}`,
-                'playwright-cli install --skills',
-                'PLAYWRIGHT_CLI_SKILL_SOURCE="$PLAYWRIGHT_CLI_INSTALL_DIR/.claude/skills/playwright-cli"',
-                'for target in ~/.claude/skills/playwright-cli ~/.codex/skills/playwright-cli ~/.gemini/skills/playwright-cli; do',
-                '    mkdir -p "$target"',
-                '    cp -R "$PLAYWRIGHT_CLI_SKILL_SOURCE/." "$target/"',
-                'done',
-                'cd "$OLDPWD"',
-                'rm -rf "$PLAYWRIGHT_CLI_INSTALL_DIR"'
-            ];
-            plugin.writeStdout(lines.join('\n'));
-            return 0;
-        },
-        printSummary() {
-            const scenes = plugin.resolveTargets('all');
-            plugin.writeStdout(`playwright\truntime=${plugin.config.runtime}\tscenes=${scenes.join(',')}`);
-            return 0;
-        }
-    };
-}
-
-module.exports = {
-    createPlaywrightCommandOutputManager
-};

package/lib/plugin/playwright-container-runtime.js

@@ -1,94 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-function createPlaywrightContainerRuntimeManager(options = {}) {
-    const plugin = options.plugin;
-    const sceneDefs = options.sceneDefs || {};
-
-    return {
-        containerEnv(sceneName, cfgPath, actionOptions = {}) {
-            const def = sceneDefs[sceneName];
-            const requireVncPassword = actionOptions.requireVncPassword === true;
-            const env = {
-                ...process.env,
-                PLAYWRIGHT_MCP_DOCKER_TAG: plugin.config.dockerTag,
-                PLAYWRIGHT_MCP_PORT: String(plugin.scenePort(sceneName)),
-                PLAYWRIGHT_MCP_CONFIG_PATH: cfgPath,
-                PLAYWRIGHT_MCP_CONTAINER_NAME: def.containerName,
-                PLAYWRIGHT_MCP_IMAGE: plugin.config.headedImage,
-                PLAYWRIGHT_MCP_NOVNC_PORT: String(plugin.config.ports.mcpContHeadedNoVnc)
-            };
-
-            if (sceneName === 'mcp-cont-headed') {
-                const envKey = plugin.config.vncPasswordEnvKey;
-                let password = process.env[envKey];
-                if (!password) {
-                    password = plugin.randomAlnum(16);
-                    if (requireVncPassword) {
-                        plugin.writeStdout(`[up] mcp-cont-headed ${envKey} not set; generated random 16-char password: ${password}`);
-                    }
-                }
-                env.VNC_PASSWORD = password;
-            }
-
-            return env;
-        },
-        containerComposePath(sceneName) {
-            const def = sceneDefs[sceneName];
-            return path.join(plugin.config.composeDir, def.composeFile);
-        },
-        sceneComposeOverridePath(sceneName) {
-            return path.join(plugin.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(plugin.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;
-        },
-        ensureContainerRuntimeAvailable(action, sceneName) {
-            const runtime = plugin.config.containerRuntime;
-            if (!plugin.ensureCommandAvailable(runtime)) {
-                plugin.writeStderr(`[${action}] ${sceneName} failed: ${runtime} command not found.`);
-                return '';
-            }
-            return runtime;
-        },
-        buildContainerComposeCommand(sceneName, composeFiles = [], trailingArgs = []) {
-            const def = sceneDefs[sceneName];
-            const files = Array.isArray(composeFiles) && composeFiles.length > 0
-                ? composeFiles
-                : [this.containerComposePath(sceneName)];
-            const args = [
-                plugin.config.containerRuntime,
-                'compose',
-                '-p',
-                def.projectName
-            ];
-            files.forEach(filePath => {
-                args.push('-f', filePath);
-            });
-            args.push(...trailingArgs);
-            return args;
-        }
-    };
-}
-
-module.exports = {
-    createPlaywrightContainerRuntimeManager
-};

package/lib/plugin/playwright-extension-manager.js

@@ -1,265 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawnSync } = require('child_process');
-
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-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 PlaywrightExtensionManager {
-    constructor(options = {}) {
-        this.extensions = Array.isArray(options.extensions) ? options.extensions : [];
-        this.ensureCommandAvailable = options.ensureCommandAvailable;
-        this.runCmd = options.runCmd;
-        this.writeStdout = options.writeStdout;
-        this.writeStderr = options.writeStderr;
-        this.extensionDirPath = options.extensionDirPath;
-        this.extensionTmpDirPath = options.extensionTmpDirPath;
-        this.defaultProdversion = String(options.defaultProdversion || '132.0.0.0').trim();
-    }
-
-    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.defaultProdversion).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 this.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;
-    }
-}
-
-module.exports = {
-    buildCrxUrl,
-    convertManifestV2ToV3,
-    crxZipOffset,
-    PlaywrightExtensionManager
-};

package/lib/plugin/playwright-extension-paths.js

@@ -1,98 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-function createPlaywrightExtensionPathManager(options = {}) {
-    const plugin = options.plugin;
-    const asStringArray = options.asStringArray || ((value, fallback) => fallback);
-    const containerExtensionRoot = options.containerExtensionRoot || '/app/extensions';
-
-    return {
-        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(plugin.extensionDirPath());
-
-            return names.map(name => {
-                if (name.includes('/') || name.includes('\\') || name === '.' || name === '..') {
-                    throw new Error(`扩展名称无效: ${name}`);
-                }
-                return path.join(extensionRoot, name);
-            });
-        },
-        resolveExtensionInputs(inputOptions = {}) {
-            const extensionPaths = asStringArray(inputOptions.extensionPaths, []);
-            const namedPaths = this.resolveNamedExtensionPaths(inputOptions.extensionNames || []);
-            return this.resolveExtensionPaths([...extensionPaths, ...namedPaths]);
-        },
-        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(containerExtensionRoot, `ext-${idx + 1}-${safeName}`);
-                containerPaths.push(containerPath);
-                volumeMounts.push(`${hostPath}:${containerPath}:ro`);
-            });
-
-            return { containerPaths, volumeMounts };
-        }
-    };
-}
-
-module.exports = {
-    createPlaywrightExtensionPathManager
-};