@xcanwin/manyoyo 5.8.5 → 5.8.9

package/lib/global-config.js

@@ -4,6 +4,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const JSON5 = require('json5');
+const { findTopLevelPropertyValueRange } = require('./json5-text-edit');
 
 function getManyoyoConfigPath(homeDir = os.homedir()) {
     return path.join(homeDir, '.manyoyo', 'manyoyo.json');
@@ -36,204 +37,6 @@ function readManyoyoConfig(homeDir = os.homedir()) {
     }
 }
 
-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 skipWhitespace(text, index) {
-    let i = index;
-    while (i < text.length && /\s/.test(text[i])) {
-        i += 1;
-    }
-    return i;
-}
-
-function findTopLevelPropertyValueRange(text, propertyName) {
-    let depth = 0;
-    let inString = '';
-    let inLineComment = false;
-    let inBlockComment = false;
-
-    for (let i = 0; i < text.length; i += 1) {
-        const ch = text[i];
-        const next = text[i + 1];
-
-        if (inLineComment) {
-            if (ch === '\n') inLineComment = false;
-            continue;
-        }
-        if (inBlockComment) {
-            if (ch === '*' && next === '/') {
-                inBlockComment = false;
-                i += 1;
-            }
-            continue;
-        }
-        if (inString) {
-            if (ch === '\\') {
-                i += 1;
-                continue;
-            }
-            if (ch === inString) inString = '';
-            continue;
-        }
-
-        if (ch === '/' && next === '/') {
-            inLineComment = true;
-            i += 1;
-            continue;
-        }
-        if (ch === '/' && next === '*') {
-            inBlockComment = true;
-            i += 1;
-            continue;
-        }
-        if (depth === 1 && !/\s|,/.test(ch)) {
-            let property = '';
-            let cursor = i;
-            if (ch === '"' || ch === '\'') {
-                const token = readQuotedString(text, i);
-                if (!token) {
-                    return null;
-                }
-                property = token.value;
-                cursor = token.end;
-            } else if (isIdentifierStart(ch)) {
-                cursor = i + 1;
-                while (cursor < text.length && isIdentifierPart(text[cursor])) {
-                    cursor += 1;
-                }
-                property = text.slice(i, cursor);
-            }
-
-            if (property) {
-                const colonIndex = skipWhitespace(text, cursor);
-                if (text[colonIndex] === ':') {
-                    if (property !== propertyName) {
-                        i = colonIndex;
-                        continue;
-                    }
-
-                    let valueStart = skipWhitespace(text, colonIndex + 1);
-                    let valueEnd = valueStart;
-                    let valueString = '';
-                    let valueLineComment = false;
-                    let valueBlockComment = false;
-                    let valueDepth = 0;
-
-                    for (; valueEnd < text.length; valueEnd += 1) {
-                        const valueCh = text[valueEnd];
-                        const valueNext = text[valueEnd + 1];
-
-                        if (valueLineComment) {
-                            if (valueCh === '\n') valueLineComment = false;
-                            continue;
-                        }
-                        if (valueBlockComment) {
-                            if (valueCh === '*' && valueNext === '/') {
-                                valueBlockComment = false;
-                                valueEnd += 1;
-                            }
-                            continue;
-                        }
-                        if (valueString) {
-                            if (valueCh === '\\') {
-                                valueEnd += 1;
-                                continue;
-                            }
-                            if (valueCh === valueString) valueString = '';
-                            continue;
-                        }
-
-                        if (valueCh === '/' && valueNext === '/') {
-                            valueLineComment = true;
-                            valueEnd += 1;
-                            continue;
-                        }
-                        if (valueCh === '/' && valueNext === '*') {
-                            valueBlockComment = true;
-                            valueEnd += 1;
-                            continue;
-                        }
-                        if (valueCh === '"' || valueCh === '\'') {
-                            valueString = valueCh;
-                            continue;
-                        }
-                        if (valueCh === '{' || valueCh === '[' || valueCh === '(') {
-                            valueDepth += 1;
-                            continue;
-                        }
-                        if (valueCh === '}' || valueCh === ']' || valueCh === ')') {
-                            if (valueDepth === 0) {
-                                break;
-                            }
-                            valueDepth -= 1;
-                            continue;
-                        }
-                        if (valueDepth === 0 && valueCh === ',') {
-                            break;
-                        }
-                    }
-
-                    while (valueEnd > valueStart && /\s/.test(text[valueEnd - 1])) {
-                        valueEnd -= 1;
-                    }
-
-                    return {
-                        start: valueStart,
-                        end: valueEnd
-                    };
-                }
-            }
-        }
-
-        if (ch === '"' || ch === '\'') {
-            inString = ch;
-            continue;
-        }
-        if (ch === '{' || ch === '[') {
-            depth += 1;
-            continue;
-        }
-        if (ch === '}' || ch === ']') {
-            depth -= 1;
-            continue;
-        }
-    }
-
-    return null;
-}
-
 function insertTopLevelImageVersion(text, imageVersion) {
     const openBraceIndex = text.indexOf('{');
     if (openBraceIndex === -1) {

package/lib/image-build.js

@@ -230,15 +230,31 @@ function prepareGoplsBuildCache(ctx, cache, imageTool, arch) {
     }
 }
 
+function createBuildCacheArtifacts(ctx, cache, imageTool, archInfo) {
+    return [
+        {
+            name: 'node',
+            prepare: () => prepareNodeBuildCache(ctx, cache, archInfo.archNode)
+        },
+        {
+            name: 'jdtls',
+            prepare: () => prepareJdtlsBuildCache(ctx, cache, imageTool)
+        },
+        {
+            name: 'gopls',
+            prepare: () => prepareGoplsBuildCache(ctx, cache, imageTool, archInfo.arch)
+        }
+    ];
+}
+
 async function prepareBuildCache(ctx, imageTool) {
     const { CYAN, GREEN, NC } = ctx.colors;
     const cache = createBuildCacheContext(ctx);
-    const { arch, archNode } = resolveBuildCacheArch();
+    const archInfo = resolveBuildCacheArch();
+    const artifacts = createBuildCacheArtifacts(ctx, cache, imageTool, archInfo);
 
     ctx.log(`\n${CYAN}准备构建缓存...${NC}`);
-    prepareNodeBuildCache(ctx, cache, archNode);
-    prepareJdtlsBuildCache(ctx, cache, imageTool);
-    prepareGoplsBuildCache(ctx, cache, imageTool, arch);
+    artifacts.forEach(artifact => artifact.prepare());
     saveBuildCacheTimestamps(cache.timestampFile, cache.timestamps);
     ctx.log(`${GREEN}✅ 构建缓存准备完成${NC}\n`);
 }

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
+};