@xcanwin/manyoyo 5.8.6 → 5.8.9

package/lib/init-config.js

@@ -251,6 +251,25 @@ function collectOpenCodeInitData(homeDir, ctx) {
     return { keys, values, notes, volumes: dedupeList(volumes) };
 }
 
+const AGENT_INIT_SPECS = {
+    claude: {
+        yolo: 'c',
+        collect: (homeDir, ctx) => collectClaudeInitData(homeDir, ctx)
+    },
+    codex: {
+        yolo: 'cx',
+        collect: (homeDir, ctx) => collectCodexInitData(homeDir, ctx)
+    },
+    gemini: {
+        yolo: 'gm',
+        collect: (homeDir) => collectGeminiInitData(homeDir)
+    },
+    opencode: {
+        yolo: 'oc',
+        collect: (homeDir, ctx) => collectOpenCodeInitData(homeDir, ctx)
+    }
+};
+
 function buildInitRunEnv(keys, values) {
     const envMap = {};
     const missingKeys = [];
@@ -338,24 +357,17 @@ async function initAgentConfigs(rawAgents, options = {}) {
         runsMap = { ...manyoyoConfig.runs };
     }
 
-    const extractors = {
-        claude: homeDir => collectClaudeInitData(homeDir, ctx),
-        codex: homeDir => collectCodexInitData(homeDir, ctx),
-        gemini: collectGeminiInitData,
-        opencode: homeDir => collectOpenCodeInitData(homeDir, ctx)
-    };
-    const yoloMap = { claude: 'c', codex: 'cx', gemini: 'gm', opencode: 'oc' };
-
     let hasConfigChanged = false;
     ctx.log(`${CYAN}🧭 正在初始化 MANYOYO 配置: ${agents.join(', ')}${NC}`);
 
     for (const agent of agents) {
-        const data = extractors[agent](ctx.homeDir);
+        const spec = AGENT_INIT_SPECS[agent];
+        const data = spec.collect(ctx.homeDir, ctx);
         const shouldWriteRun = await shouldOverwriteInitRunEntry(agent, Object.prototype.hasOwnProperty.call(runsMap, agent), ctx);
 
         let writeResult = { missingKeys: [], unsafeKeys: [] };
         if (shouldWriteRun) {
-            const buildResult = buildInitRunProfile(agent, yoloMap[agent], data.volumes, data.keys, data.values);
+            const buildResult = buildInitRunProfile(agent, spec.yolo, data.volumes, data.keys, data.values);
             runsMap[agent] = buildResult.runProfile;
             writeResult = { missingKeys: buildResult.missingKeys, unsafeKeys: buildResult.unsafeKeys };
             hasConfigChanged = true;

package/lib/json5-text-edit.js

@@ -0,0 +1,238 @@
+'use strict';
+
+function readQuotedString(text, startIndex) {
+    const quote = text[startIndex];
+    let value = '';
+
+    for (let i = startIndex + 1; i < text.length; i += 1) {
+        const ch = text[i];
+        if (ch === '\\') {
+            value += ch;
+            if (i + 1 < text.length) {
+                value += text[i + 1];
+                i += 1;
+            }
+            continue;
+        }
+        if (ch === quote) {
+            return {
+                value,
+                end: i + 1
+            };
+        }
+        value += ch;
+    }
+
+    return null;
+}
+
+function isIdentifierStart(ch) {
+    return /[A-Za-z_$]/.test(ch);
+}
+
+function isIdentifierPart(ch) {
+    return /[A-Za-z0-9_$]/.test(ch);
+}
+
+function skipTrivia(text, index) {
+    let cursor = index;
+    while (cursor < text.length) {
+        const ch = text[cursor];
+        const next = text[cursor + 1];
+        if (/\s/.test(ch)) {
+            cursor += 1;
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            cursor += 2;
+            while (cursor < text.length && text[cursor] !== '\n') {
+                cursor += 1;
+            }
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            cursor += 2;
+            while (cursor + 1 < text.length && !(text[cursor] === '*' && text[cursor + 1] === '/')) {
+                cursor += 1;
+            }
+            cursor = cursor + 1 < text.length ? cursor + 2 : text.length;
+            continue;
+        }
+        break;
+    }
+    return cursor;
+}
+
+function scanValueEnd(text, startIndex) {
+    let cursor = startIndex;
+    let stringQuote = '';
+    let lineComment = false;
+    let blockComment = false;
+    let depth = 0;
+
+    for (; cursor < text.length; cursor += 1) {
+        const ch = text[cursor];
+        const next = text[cursor + 1];
+
+        if (lineComment) {
+            if (ch === '\n') {
+                lineComment = false;
+            }
+            continue;
+        }
+        if (blockComment) {
+            if (ch === '*' && next === '/') {
+                blockComment = false;
+                cursor += 1;
+            }
+            continue;
+        }
+        if (stringQuote) {
+            if (ch === '\\') {
+                cursor += 1;
+                continue;
+            }
+            if (ch === stringQuote) {
+                stringQuote = '';
+            }
+            continue;
+        }
+
+        if (ch === '/' && next === '/') {
+            lineComment = true;
+            cursor += 1;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            blockComment = true;
+            cursor += 1;
+            continue;
+        }
+        if (ch === '"' || ch === '\'') {
+            stringQuote = ch;
+            continue;
+        }
+        if (ch === '{' || ch === '[' || ch === '(') {
+            depth += 1;
+            continue;
+        }
+        if (ch === '}' || ch === ']' || ch === ')') {
+            if (depth === 0) {
+                break;
+            }
+            depth -= 1;
+            continue;
+        }
+        if (depth === 0 && ch === ',') {
+            break;
+        }
+    }
+
+    let end = cursor;
+    while (end > startIndex && /\s/.test(text[end - 1])) {
+        end -= 1;
+    }
+    return end;
+}
+
+function findRootObjectStart(text) {
+    const source = String(text || '');
+    const start = skipTrivia(source, 0);
+    return source[start] === '{' ? start : -1;
+}
+
+function readPropertyToken(text, startIndex) {
+    const ch = text[startIndex];
+    if (ch === '"' || ch === '\'') {
+        return readQuotedString(text, startIndex);
+    }
+    if (!isIdentifierStart(ch)) {
+        return null;
+    }
+
+    let end = startIndex + 1;
+    while (end < text.length && isIdentifierPart(text[end])) {
+        end += 1;
+    }
+    return {
+        value: text.slice(startIndex, end),
+        end
+    };
+}
+
+function findObjectPropertyValueRange(text, objectStartIndex, propertyName) {
+    let cursor = skipTrivia(text, objectStartIndex + 1);
+    while (cursor < text.length) {
+        cursor = skipTrivia(text, cursor);
+        if (text[cursor] === '}') {
+            return null;
+        }
+        const token = readPropertyToken(text, cursor);
+        if (!token) {
+            return null;
+        }
+        cursor = skipTrivia(text, token.end);
+        if (text[cursor] !== ':') {
+            return null;
+        }
+        const valueStart = skipTrivia(text, cursor + 1);
+        const valueEnd = scanValueEnd(text, valueStart);
+        if (token.value === propertyName) {
+            return { start: valueStart, end: valueEnd };
+        }
+        cursor = skipTrivia(text, valueEnd);
+        if (text[cursor] === ',') {
+            cursor += 1;
+            continue;
+        }
+        if (text[cursor] === '}') {
+            return null;
+        }
+    }
+    return null;
+}
+
+function findValueRangeByPath(text, pathParts) {
+    if (!Array.isArray(pathParts) || pathParts.length === 0) {
+        return null;
+    }
+
+    let objectStart = findRootObjectStart(text);
+    if (objectStart === -1) {
+        return null;
+    }
+
+    let range = null;
+    for (let i = 0; i < pathParts.length; i += 1) {
+        range = findObjectPropertyValueRange(text, objectStart, pathParts[i]);
+        if (!range) {
+            return null;
+        }
+        if (i === pathParts.length - 1) {
+            return range;
+        }
+        const nextObjectStart = skipTrivia(text, range.start);
+        if (text[nextObjectStart] !== '{') {
+            return null;
+        }
+        objectStart = nextObjectStart;
+    }
+    return range;
+}
+
+function findTopLevelPropertyValueRange(text, propertyName) {
+    return findValueRangeByPath(text, [propertyName]);
+}
+
+function applyTextReplacements(text, replacements) {
+    return replacements
+        .slice()
+        .sort((a, b) => b.start - a.start)
+        .reduce((result, item) => `${result.slice(0, item.start)}${item.text}${result.slice(item.end)}`, text);
+}
+
+module.exports = {
+    findTopLevelPropertyValueRange,
+    findValueRangeByPath,
+    applyTextReplacements
+};

package/lib/plugin/playwright-bootstrap.js

@@ -0,0 +1,116 @@
+'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

@@ -0,0 +1,95 @@
+'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

@@ -0,0 +1,94 @@
+'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
+};