@xcanwin/manyoyo 5.8.6 → 5.8.10

package/bin/manyoyo.js

@@ -16,6 +16,11 @@ const { buildImage } = require('../lib/image-build');
 const { resolveAgentResumeArg, buildAgentResumeCommand } = require('../lib/agent-resume');
 const { runPluginCommand, createPlugin } = require('../lib/plugin');
 const { buildManyoyoLogPath } = require('../lib/log-path');
+const { resolveRuntimeConfig } = require('../lib/runtime-resolver');
+const {
+    parseEnvEntry: parseEnvEntryOrThrow,
+    normalizeVolume
+} = require('../lib/runtime-normalizers');
 const {
     sanitizeSensitiveData,
     sanitizeServeLogText,
@@ -454,23 +459,13 @@ async function askQuestion(prompt) {
  * @param {string} env - 环境变量字符串 (KEY=VALUE)
  */
 function parseEnvEntry(env) {
-    const envText = String(env);
-    const idx = envText.indexOf('=');
-    if (idx <= 0) {
-        console.error(`${RED}⚠️  错误: env 格式应为 KEY=VALUE: ${envText}${NC}`);
-        process.exit(1);
-    }
-    const key = envText.slice(0, idx);
-    const value = envText.slice(idx + 1);
-    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
-        console.error(`${RED}⚠️  错误: env key 非法: ${key}${NC}`);
-        process.exit(1);
-    }
-    if (/[\r\n\0]/.test(value) || /[;&|`$<>]/.test(value)) {
-        console.error(`${RED}⚠️  错误: env value 含非法字符: ${key}${NC}`);
+    try {
+        return parseEnvEntryOrThrow(env);
+    } catch (e) {
+        const message = e && e.message ? e.message : String(e);
+        console.error(`${RED}⚠️  错误: ${message}${NC}`);
         process.exit(1);
     }
-    return { key, value };
 }
 
 function normalizeJsonEnvMap(envConfig, sourceLabel) {
@@ -570,42 +565,6 @@ function addEnvFile(envFile) {
     return addEnvFileTo(CONTAINER_ENVS, envFile);
 }
 
-function expandHomeAliasPath(filePath) {
-    const text = String(filePath || '').trim();
-    const homeDir = process.env.HOME || os.homedir();
-
-    if (text === '~') {
-        return homeDir;
-    }
-    if (text.startsWith('~/')) {
-        return path.join(homeDir, text.slice(2));
-    }
-    if (text === '$HOME') {
-        return homeDir;
-    }
-    if (text.startsWith('$HOME/')) {
-        return path.join(homeDir, text.slice('$HOME/'.length));
-    }
-
-    return text;
-}
-
-function normalizeVolume(volume) {
-    const text = String(volume || '').trim();
-    if (!text.startsWith('~') && !text.startsWith('$HOME')) {
-        return text;
-    }
-
-    const separatorIndex = text.indexOf(':');
-    if (separatorIndex === -1) {
-        return expandHomeAliasPath(text);
-    }
-
-    const hostPath = text.slice(0, separatorIndex);
-    const rest = text.slice(separatorIndex);
-    return `${expandHomeAliasPath(hostPath)}${rest}`;
-}
-
 function hasEnvKey(targetEnvs, key) {
     for (let i = 0; i < targetEnvs.length; i += 2) {
         if (targetEnvs[i] !== '--env') {
@@ -1367,47 +1326,44 @@ Notes:
     const globalFirstConfig = normalizeFirstConfig(config.first, '全局配置');
     const runFirstConfig = normalizeFirstConfig(runConfig.first, '运行配置');
 
-    // Merge configs: command line > run config > global config > defaults
-    // Override mode (scalar values): use first defined value
-    HOST_PATH = pickConfigValue(options.hostPath, runConfig.hostPath, config.hostPath, HOST_PATH) || HOST_PATH;
-    const mergedContainerName = pickConfigValue(options.contName, runConfig.containerName, config.containerName);
-    if (mergedContainerName) {
-        CONTAINER_NAME = mergedContainerName;
-    }
-    CONTAINER_NAME = resolveContainerNameTemplate(CONTAINER_NAME);
-    const mergedContainerPath = pickConfigValue(options.contPath, runConfig.containerPath, config.containerPath);
-    if (mergedContainerPath) {
-        CONTAINER_PATH = mergedContainerPath;
-    }
-    IMAGE_NAME = pickConfigValue(options.imageName, runConfig.imageName, config.imageName, IMAGE_NAME) || IMAGE_NAME;
-    const mergedImageVersion = pickConfigValue(options.imageVer, runConfig.imageVersion, config.imageVersion);
-    if (mergedImageVersion) {
-        IMAGE_VERSION = mergedImageVersion;
-    }
-    const mergedShellPrefix = pickConfigValue(options.shellPrefix, runConfig.shellPrefix, config.shellPrefix);
-    if (mergedShellPrefix) {
-        EXEC_COMMAND_PREFIX = `${mergedShellPrefix} `;
-    }
-    const mergedShell = pickConfigValue(options.shell, runConfig.shell, config.shell);
-    if (mergedShell) {
-        EXEC_COMMAND = mergedShell;
-    }
-    const mergedShellSuffix = pickConfigValue(options.shellSuffix, runConfig.shellSuffix, config.shellSuffix);
-    if (mergedShellSuffix) {
-        EXEC_COMMAND_SUFFIX = normalizeCommandSuffix(mergedShellSuffix);
-    }
-    const mergedFirstShellPrefix = pickConfigValue(options.firstShellPrefix, runFirstConfig.shellPrefix, globalFirstConfig.shellPrefix);
-    if (mergedFirstShellPrefix) {
-        FIRST_EXEC_COMMAND_PREFIX = `${mergedFirstShellPrefix} `;
-    }
-    const mergedFirstShell = pickConfigValue(options.firstShell, runFirstConfig.shell, globalFirstConfig.shell);
-    if (mergedFirstShell) {
-        FIRST_EXEC_COMMAND = mergedFirstShell;
-    }
-    const mergedFirstShellSuffix = pickConfigValue(options.firstShellSuffix, runFirstConfig.shellSuffix, globalFirstConfig.shellSuffix);
-    if (mergedFirstShellSuffix) {
-        FIRST_EXEC_COMMAND_SUFFIX = normalizeCommandSuffix(mergedFirstShellSuffix);
-    }
+    const resolvedRuntime = resolveRuntimeConfig({
+        cliOptions: options,
+        globalConfig: config,
+        runConfig,
+        globalFirstConfig,
+        runFirstConfig,
+        defaults: {
+            hostPath: HOST_PATH,
+            containerName: CONTAINER_NAME,
+            containerPath: CONTAINER_PATH,
+            imageName: IMAGE_NAME,
+            imageVersion: IMAGE_VERSION
+        },
+        envVars: process.env,
+        argv: process.argv,
+        isServerMode,
+        isServerStopMode,
+        pickConfigValue,
+        resolveContainerNameTemplate,
+        normalizeCommandSuffix,
+        normalizeJsonEnvMap,
+        normalizeCliEnvMap,
+        mergeArrayConfig,
+        normalizeVolume,
+        parseServerListen
+    });
+
+    HOST_PATH = resolvedRuntime.hostPath;
+    CONTAINER_NAME = resolvedRuntime.containerName;
+    CONTAINER_PATH = resolvedRuntime.containerPath;
+    IMAGE_NAME = resolvedRuntime.imageName;
+    IMAGE_VERSION = resolvedRuntime.imageVersion;
+    EXEC_COMMAND_PREFIX = resolvedRuntime.exec.prefix;
+    EXEC_COMMAND = resolvedRuntime.exec.shell;
+    EXEC_COMMAND_SUFFIX = resolvedRuntime.exec.suffix;
+    FIRST_EXEC_COMMAND_PREFIX = resolvedRuntime.first.exec.prefix;
+    FIRST_EXEC_COMMAND = resolvedRuntime.first.exec.shell;
+    FIRST_EXEC_COMMAND_SUFFIX = resolvedRuntime.first.exec.suffix;
 
     // Basic name validation to reduce injection risk
     validateName('containerName', CONTAINER_NAME, SAFE_CONTAINER_NAME_PATTERN);
@@ -1415,97 +1371,47 @@ Notes:
     validateImageVersion(IMAGE_VERSION);
 
     // Merge mode (array values): concatenate all sources
-    const toArray = (val) => Array.isArray(val) ? val : (val ? [val] : []);
-    const envFileList = [
-        ...toArray(config.envFile),
-        ...toArray(runConfig.envFile),
-        ...(options.envFile || [])
-    ].filter(Boolean);
+    const envFileList = resolvedRuntime.envFile;
     envFileList.forEach(ef => addEnvFile(ef));
 
-    // env in JSON config uses map type, and is merged by key with CLI priority.
-    const envMap = {
-        ...normalizeJsonEnvMap(config.env, '全局配置'),
-        ...normalizeJsonEnvMap(runConfig.env, '运行配置'),
-        ...normalizeCliEnvMap(options.env)
-    };
+    const envMap = resolvedRuntime.env;
     Object.entries(envMap).forEach(([key, value]) => addEnv(`${key}=${value}`));
 
-    const firstEnvFileList = [
-        ...toArray(globalFirstConfig.envFile),
-        ...toArray(runFirstConfig.envFile),
-        ...(options.firstEnvFile || [])
-    ].filter(Boolean);
+    const firstEnvFileList = resolvedRuntime.first.envFile;
     firstEnvFileList.forEach(ef => addEnvFileTo(FIRST_CONTAINER_ENVS, ef));
 
-    const firstEnvMap = {
-        ...normalizeJsonEnvMap(globalFirstConfig.env, '全局配置 first'),
-        ...normalizeJsonEnvMap(runFirstConfig.env, '运行配置 first'),
-        ...normalizeCliEnvMap(options.firstEnv)
-    };
+    const firstEnvMap = resolvedRuntime.first.env;
     Object.entries(firstEnvMap).forEach(([key, value]) => addEnvTo(FIRST_CONTAINER_ENVS, `${key}=${value}`));
 
     applyPlaywrightCliSessionIntegration(config, runConfig);
 
-    const volumeList = mergeArrayConfig(config.volumes, runConfig.volumes, options.volume)
-        .map(normalizeVolume);
+    const volumeList = resolvedRuntime.volumes;
     volumeList.forEach(v => addVolume(v));
 
-    const portList = mergeArrayConfig(config.ports, runConfig.ports, options.port);
+    const portList = resolvedRuntime.ports;
     portList.forEach(p => addPort(p));
 
-    const buildArgList = mergeArrayConfig(config.imageBuildArgs, runConfig.imageBuildArgs, options.imageBuildArg);
+    const buildArgList = resolvedRuntime.imageBuildArgs;
     buildArgList.forEach(arg => addImageBuildArg(arg));
 
-    // Override mode for special options
-    const yoloValue = pickConfigValue(options.yolo, runConfig.yolo, config.yolo);
+    const yoloValue = resolvedRuntime.yolo;
     if (yoloValue) setYolo(yoloValue);
 
-    const contModeValue = pickConfigValue(options.contMode, runConfig.containerMode, config.containerMode);
+    const contModeValue = resolvedRuntime.containerMode;
     if (contModeValue) setContMode(contModeValue);
 
-    const quietValue = pickConfigValue(options.quiet, runConfig.quiet, config.quiet);
+    const quietValue = resolvedRuntime.quiet;
     if (quietValue) setQuiet(quietValue);
 
-    // Handle shell-full (variadic arguments)
-    if (options.shellFull) {
-        EXEC_COMMAND = options.shellFull.join(' ');
-        EXEC_COMMAND_PREFIX = "";
-        EXEC_COMMAND_SUFFIX = "";
-    }
-
-    // Handle -- suffix arguments
-    if (!options.shellFull) {
-        const doubleDashIndex = process.argv.indexOf('--');
-        if (doubleDashIndex !== -1 && doubleDashIndex < process.argv.length - 1) {
-            EXEC_COMMAND_SUFFIX = normalizeCommandSuffix(process.argv.slice(doubleDashIndex + 1).join(' '));
-        }
-    }
-
     if (options.rmOnExit) {
         RM_ON_EXIT = true;
     }
 
-    if (isServerMode) {
-        const serverListen = parseServerListen(options.server);
-        SERVER_HOST = serverListen.host;
-        SERVER_PORT = serverListen.port;
-    }
-
-    const serverUserValue = pickConfigValue(options.serverUser, runConfig.serverUser, config.serverUser, process.env.MANYOYO_SERVER_USER);
-    if (serverUserValue) {
-        SERVER_AUTH_USER = String(serverUserValue);
-    }
-
-    const serverPassValue = pickConfigValue(options.serverPass, runConfig.serverPass, config.serverPass, process.env.MANYOYO_SERVER_PASS);
-    if (serverPassValue) {
-        SERVER_AUTH_PASS = String(serverPassValue);
-        SERVER_AUTH_PASS_AUTO = false;
-    }
-
-    if (isServerMode && !isServerStopMode) {
-        ensureWebServerAuthCredentials();
-    }
+    SERVER_HOST = resolvedRuntime.serverHost || SERVER_HOST;
+    SERVER_PORT = resolvedRuntime.serverPort || SERVER_PORT;
+    SERVER_AUTH_USER = resolvedRuntime.serverUser || '';
+    SERVER_AUTH_PASS = resolvedRuntime.serverPass || '';
+    SERVER_AUTH_PASS_AUTO = Boolean(resolvedRuntime.serverPassAuto);
 
     if (isShowConfigMode) {
         const finalConfig = {

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;