@xcanwin/manyoyo 4.1.1 → 4.1.10

package/bin/manyoyo.js

@@ -1,9 +1,5 @@
 #!/usr/bin/env node
 
-// ==============================================================================
-// manyoyo - AI Agent CLI Sandbox - xcanwin
-// ==============================================================================
-
 const { execSync, spawnSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
@@ -14,6 +10,10 @@ const readline = require('readline');
 const { Command } = require('commander');
 const JSON5 = require('json5');
 const { startWebServer } = require('../lib/web/server');
+const { buildContainerRunArgs, buildContainerRunCommand } = require('../lib/container-run');
+const { initAgentConfigs } = require('../lib/init-config');
+const { buildImage } = require('../lib/image-build');
+const { resolveAgentResumeArg } = require('../lib/agent-resume');
 const { version: BIN_VERSION, imageVersion: IMAGE_VERSION_DEFAULT } = require('../package.json');
 const IMAGE_VERSION_BASE = String(IMAGE_VERSION_DEFAULT || '1.0.0').split('-')[0];
 const IMAGE_VERSION_HELP_EXAMPLE = IMAGE_VERSION_DEFAULT || `${IMAGE_VERSION_BASE}-common`;
@@ -40,12 +40,7 @@ function detectCommandName() {
     return baseName || 'manyoyo';
 }
 
-// ==============================================================================
-// Configuration Constants
-// ==============================================================================
-
 const CONFIG = {
-    CACHE_TTL_DAYS: 2,                    // 缓存过期天数
     CONTAINER_READY_MAX_RETRIES: 30,      // 容器就绪最大重试次数
     CONTAINER_READY_INITIAL_DELAY: 100,   // 容器就绪初始延迟(ms)
     CONTAINER_READY_MAX_DELAY: 2000,      // 容器就绪最大延迟(ms)
@@ -60,14 +55,12 @@ let IMAGE_VERSION = IMAGE_VERSION_DEFAULT || `${IMAGE_VERSION_BASE}-common`;
 let EXEC_COMMAND = "";
 let EXEC_COMMAND_PREFIX = "";
 let EXEC_COMMAND_SUFFIX = "";
-let ENV_FILE = "";
 let SHOULD_REMOVE = false;
 let IMAGE_BUILD_NEED = false;
 let IMAGE_BUILD_ARGS = [];
 let CONTAINER_ENVS = [];
 let CONTAINER_VOLUMES = [];
 let MANYOYO_NAME = detectCommandName();
-let CONT_MODE = "";
 let CONT_MODE_ARGS = [];
 let QUIET = {};
 let SHOW_COMMAND = false;
@@ -94,10 +87,6 @@ const IMAGE_VERSION_TAG_PATTERN = /^(\d+\.\d+\.\d+)-([A-Za-z0-9][A-Za-z0-9_.-]*)
 let DOCKER_CMD = 'docker';
 const SUPPORTED_INIT_AGENTS = ['claude', 'codex', 'gemini', 'opencode'];
 
-// ==============================================================================
-// SECTION: Utility Functions
-// ==============================================================================
-
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
@@ -116,6 +105,19 @@ function resolveContainerNameTemplate(name) {
     return name.replace(/\{now\}|\$\{now\}/g, nowValue);
 }
 
+function pickConfigValue(...values) {
+    for (const value of values) {
+        if (value) {
+            return value;
+        }
+    }
+    return undefined;
+}
+
+function mergeArrayConfig(globalValue, runValue, cliValue) {
+    return [...(globalValue || []), ...(runValue || []), ...(cliValue || [])];
+}
+
 function validateServerHost(host, rawServer) {
     const value = String(host || '').trim();
     const isIp = net.isIP(value) !== 0;
@@ -185,18 +187,6 @@ function ensureWebServerAuthCredentials() {
     }
 }
 
-/**
- * 计算文件的 SHA256 哈希值（跨平台）
- * @param {string} filePath - 文件路径
- * @returns {string} SHA256 哈希值（十六进制）
- */
-function getFileSha256(filePath) {
-    const fileBuffer = fs.readFileSync(filePath);
-    const hashSum = crypto.createHash('sha256');
-    hashSum.update(fileBuffer);
-    return hashSum.digest('hex');
-}
-
 /**
  * 敏感信息脱敏（用于 --show-config 输出）
  * @param {Object} obj - 配置对象
@@ -240,10 +230,6 @@ function sanitizeSensitiveData(obj) {
     return result;
 }
 
-// ==============================================================================
-// SECTION: Configuration Management
-// ==============================================================================
-
 /**
  * @typedef {Object} Config
  * @property {string} [containerName] - 容器名称
@@ -305,466 +291,15 @@ function loadRunConfig(name, config) {
     return runConfig;
 }
 
-function readJsonFileSafely(filePath, label) {
-    if (!fs.existsSync(filePath)) {
-        return null;
-    }
-    try {
-        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-    } catch (e) {
-        console.log(`${YELLOW}⚠️  ${label} 解析失败: ${filePath}${NC}`);
-        return null;
-    }
-}
-
-function parseSimpleToml(content) {
-    const result = {};
-    let current = result;
-    const lines = String(content || '').split('\n');
-
-    for (const rawLine of lines) {
-        const line = rawLine.trim();
-        if (!line || line.startsWith('#')) {
-            continue;
-        }
-
-        const sectionMatch = line.match(/^\[([^\]]+)\]$/);
-        if (sectionMatch) {
-            const parts = sectionMatch[1].split('.').map(p => p.trim()).filter(Boolean);
-            current = result;
-            for (const part of parts) {
-                if (!current[part] || typeof current[part] !== 'object' || Array.isArray(current[part])) {
-                    current[part] = {};
-                }
-                current = current[part];
-            }
-            continue;
-        }
-
-        const keyValueMatch = line.match(/^([A-Za-z0-9_.-]+)\s*=\s*(.+)$/);
-        if (!keyValueMatch) {
-            continue;
-        }
-
-        const key = keyValueMatch[1];
-        let valueText = keyValueMatch[2].trim();
-        if ((valueText.startsWith('"') && valueText.endsWith('"')) || (valueText.startsWith("'") && valueText.endsWith("'"))) {
-            valueText = valueText.slice(1, -1);
-        } else if (valueText === 'true') {
-            valueText = true;
-        } else if (valueText === 'false') {
-            valueText = false;
-        } else if (/^-?\d+(\.\d+)?$/.test(valueText)) {
-            valueText = Number(valueText);
-        }
-
-        current[key] = valueText;
-    }
-
-    return result;
-}
-
-function readTomlFileSafely(filePath, label) {
-    if (!fs.existsSync(filePath)) {
-        return null;
-    }
-    try {
-        const content = fs.readFileSync(filePath, 'utf-8');
-        return parseSimpleToml(content);
-    } catch (e) {
-        console.log(`${YELLOW}⚠️  ${label} 解析失败: ${filePath}${NC}`);
-        return null;
-    }
-}
-
-function normalizeInitConfigAgents(rawAgents) {
-    const aliasMap = {
-        all: 'all',
-        claude: 'claude',
-        c: 'claude',
-        cc: 'claude',
-        codex: 'codex',
-        cx: 'codex',
-        gemini: 'gemini',
-        gm: 'gemini',
-        g: 'gemini',
-        opencode: 'opencode',
-        oc: 'opencode'
-    };
-
-    if (rawAgents === true || rawAgents === undefined || rawAgents === null || rawAgents === '') {
-        return [...SUPPORTED_INIT_AGENTS];
-    }
-
-    const tokens = String(rawAgents).split(/[,\s]+/).map(v => v.trim().toLowerCase()).filter(Boolean);
-    if (tokens.length === 0) {
-        return [...SUPPORTED_INIT_AGENTS];
-    }
-
-    const normalized = [];
-    for (const token of tokens) {
-        const mapped = aliasMap[token];
-        if (!mapped) {
-            console.error(`${RED}⚠️  错误: --init-config 不支持的 Agent: ${token}${NC}`);
-            console.error(`${YELLOW}支持: ${SUPPORTED_INIT_AGENTS.join(', ')} 或 all${NC}`);
-            process.exit(1);
-        }
-        if (mapped === 'all') {
-            return [...SUPPORTED_INIT_AGENTS];
-        }
-        if (!normalized.includes(mapped)) {
-            normalized.push(mapped);
-        }
-    }
-    return normalized;
-}
-
-function isSafeInitEnvValue(value) {
-    if (value === undefined || value === null) {
-        return false;
-    }
-    const text = String(value).replace(/[\r\n\0]/g, '').trim();
-    if (!text) {
-        return false;
-    }
-    if (/[\$\(\)\`\|\&\*\{\};<>]/.test(text)) {
-        return false;
-    }
-    if (/^\(/.test(text)) {
-        return false;
-    }
-    return true;
-}
-
-function setInitValue(values, key, value) {
-    if (value === undefined || value === null) {
-        return;
-    }
-    const text = String(value).replace(/[\r\n\0]/g, '').trim();
-    if (!text) {
-        return;
-    }
-    values[key] = text;
-}
-
-function dedupeList(list) {
-    return Array.from(new Set((list || []).filter(Boolean)));
-}
-
-function resolveEnvPlaceholder(value) {
-    if (typeof value !== 'string') {
-        return "";
-    }
-    const match = value.match(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}/);
-    if (!match) {
-        return "";
-    }
-    const envName = match[1];
-    return process.env[envName] ? String(process.env[envName]).trim() : "";
-}
-
-function collectClaudeInitData(homeDir) {
-    const keys = [
-        'ANTHROPIC_AUTH_TOKEN',
-        'CLAUDE_CODE_OAUTH_TOKEN',
-        'ANTHROPIC_BASE_URL',
-        'ANTHROPIC_MODEL',
-        'ANTHROPIC_DEFAULT_OPUS_MODEL',
-        'ANTHROPIC_DEFAULT_SONNET_MODEL',
-        'ANTHROPIC_DEFAULT_HAIKU_MODEL',
-        'CLAUDE_CODE_SUBAGENT_MODEL'
-    ];
-    const values = {};
-    const notes = [];
-    const volumes = [];
-
-    const claudeDir = path.join(homeDir, '.claude');
-    const claudeSettingsPath = path.join(claudeDir, 'settings.json');
-    const settingsJson = readJsonFileSafely(claudeSettingsPath, 'Claude settings');
-
-    keys.forEach(key => setInitValue(values, key, process.env[key]));
-
-    if (settingsJson && settingsJson.env && typeof settingsJson.env === 'object') {
-        keys.forEach(key => setInitValue(values, key, settingsJson.env[key]));
-    }
-
-    return { keys, values, notes, volumes: dedupeList(volumes) };
-}
-
-function collectGeminiInitData(homeDir) {
-    const keys = [
-        'GOOGLE_GEMINI_BASE_URL',
-        'GEMINI_API_KEY',
-        'GEMINI_MODEL'
-    ];
-    const values = {};
-    const notes = [];
-    const volumes = [];
-    const geminiDir = path.join(homeDir, '.gemini');
-
-    keys.forEach(key => setInitValue(values, key, process.env[key]));
-
-    if (fs.existsSync(geminiDir)) {
-        volumes.push(`${geminiDir}:/root/.gemini`);
-    } else {
-        notes.push('未检测到 Gemini 本地配置目录（~/.gemini），已生成占位模板。');
-    }
-
-    return { keys, values, notes, volumes: dedupeList(volumes) };
-}
-
-function collectCodexInitData(homeDir) {
-    const keys = [
-        'OPENAI_API_KEY',
-        'OPENAI_BASE_URL',
-        'OPENAI_MODEL'
-    ];
-    const values = {};
-    const notes = [];
-    const volumes = [];
-
-    const codexDir = path.join(homeDir, '.codex');
-    const authPath = path.join(codexDir, 'auth.json');
-    const configPath = path.join(codexDir, 'config.toml');
-    const authJson = readJsonFileSafely(authPath, 'Codex auth');
-    const configToml = readTomlFileSafely(configPath, 'Codex TOML');
-
-    keys.forEach(key => setInitValue(values, key, process.env[key]));
-
-    if (authJson && typeof authJson === 'object') {
-        setInitValue(values, 'OPENAI_API_KEY', authJson.OPENAI_API_KEY);
-    }
-
-    if (configToml && typeof configToml === 'object') {
-        setInitValue(values, 'OPENAI_MODEL', configToml.model);
-
-        let providerConfig = null;
-        const providers = configToml.model_providers;
-        if (providers && typeof providers === 'object') {
-            if (typeof configToml.model_provider === 'string' && providers[configToml.model_provider]) {
-                providerConfig = providers[configToml.model_provider];
-            } else {
-                const firstProviderName = Object.keys(providers)[0];
-                if (firstProviderName) {
-                    providerConfig = providers[firstProviderName];
-                }
-            }
-        }
-        if (providerConfig && typeof providerConfig === 'object') {
-            setInitValue(values, 'OPENAI_BASE_URL', providerConfig.base_url);
-        }
-    }
-
-    if (fs.existsSync(codexDir)) {
-        volumes.push(`${codexDir}:/root/.codex`);
-    } else {
-        notes.push('未检测到 Codex 本地配置目录（~/.codex），已生成占位模板。');
-    }
-
-    return { keys, values, notes, volumes: dedupeList(volumes) };
-}
-
-function collectOpenCodeInitData(homeDir) {
-    const keys = [
-        'OPENAI_API_KEY',
-        'OPENAI_BASE_URL',
-        'OPENAI_MODEL'
-    ];
-    const values = {};
-    const notes = [];
-    const volumes = [];
-
-    const opencodeDir = path.join(homeDir, '.config', 'opencode');
-    const opencodePath = path.join(opencodeDir, 'opencode.json');
-    const opencodeAuthPath = path.join(homeDir, '.local', 'share', 'opencode', 'auth.json');
-    const opencodeJson = readJsonFileSafely(opencodePath, 'OpenCode config');
-
-    keys.forEach(key => setInitValue(values, key, process.env[key]));
-
-    if (opencodeJson && typeof opencodeJson === 'object') {
-        const providers = opencodeJson.provider && typeof opencodeJson.provider === 'object'
-            ? Object.values(opencodeJson.provider).filter(v => v && typeof v === 'object')
-            : [];
-        const provider = providers[0];
-
-        if (provider) {
-            const options = provider.options && typeof provider.options === 'object' ? provider.options : {};
-            const apiKeyValue = resolveEnvPlaceholder(options.apiKey) || options.apiKey;
-            const baseUrlValue = resolveEnvPlaceholder(options.baseURL) || options.baseURL;
-            setInitValue(values, 'OPENAI_API_KEY', apiKeyValue);
-            setInitValue(values, 'OPENAI_BASE_URL', baseUrlValue);
-
-            if (provider.models && typeof provider.models === 'object') {
-                const firstModelName = Object.keys(provider.models)[0];
-                if (firstModelName) {
-                    setInitValue(values, 'OPENAI_MODEL', firstModelName);
-                }
-            }
-        }
-
-        if (typeof opencodeJson.model === 'string') {
-            const modelFromEnv = resolveEnvPlaceholder(opencodeJson.model);
-            if (modelFromEnv) {
-                setInitValue(values, 'OPENAI_MODEL', modelFromEnv);
-            }
-        }
-    }
-
-    if (fs.existsSync(opencodePath)) {
-        volumes.push(`${opencodePath}:/root/.config/opencode/opencode.json`);
-    } else {
-        notes.push('未检测到 OpenCode 配置文件（~/.config/opencode/opencode.json），已生成占位模板。');
-    }
-    if (fs.existsSync(opencodeAuthPath)) {
-        volumes.push(`${opencodeAuthPath}:/root/.local/share/opencode/auth.json`);
-    }
-
-    return { keys, values, notes, volumes: dedupeList(volumes) };
-}
-
-function buildInitRunEnv(keys, values) {
-    const envMap = {};
-    const missingKeys = [];
-    const unsafeKeys = [];
-
-    for (const key of keys) {
-        const value = values[key];
-        if (isSafeInitEnvValue(value)) {
-            envMap[key] = String(value).replace(/[\r\n\0]/g, '');
-        } else if (value !== undefined && value !== null && String(value).trim() !== '') {
-            envMap[key] = "";
-            unsafeKeys.push(key);
-        } else {
-            envMap[key] = "";
-            missingKeys.push(key);
-        }
-    }
-    return { envMap, missingKeys, unsafeKeys };
-}
-
-function buildInitRunProfile(agent, yolo, volumes, keys, values) {
-    const envBuildResult = buildInitRunEnv(keys, values);
-    const runProfile = {
-        containerName: `my-${agent}-{now}`,
-        env: envBuildResult.envMap,
-        yolo
-    };
-    const volumeList = dedupeList(volumes);
-    if (volumeList.length > 0) {
-        runProfile.volumes = volumeList;
-    }
-    return {
-        runProfile,
-        missingKeys: envBuildResult.missingKeys,
-        unsafeKeys: envBuildResult.unsafeKeys
-    };
-}
-
-async function shouldOverwriteInitRunEntry(runName, exists) {
-    if (!exists) {
-        return true;
-    }
-
-    if (YES_MODE) {
-        console.log(`${YELLOW}⚠️  runs.${runName} 已存在，--yes 模式自动覆盖${NC}`);
-        return true;
-    }
-
-    const reply = await askQuestion(`❔ runs.${runName} 已存在，是否覆盖? [y/N]: `);
-    const firstChar = String(reply || '').trim().toLowerCase()[0];
-    if (firstChar === 'y') {
-        return true;
-    }
-    console.log(`${YELLOW}⏭️  已保留原配置: runs.${runName}${NC}`);
-    return false;
-}
-
-async function initAgentConfigs(rawAgents) {
-    const agents = normalizeInitConfigAgents(rawAgents);
-    const homeDir = os.homedir();
-    const manyoyoHome = path.join(homeDir, '.manyoyo');
-    const manyoyoConfigPath = path.join(manyoyoHome, 'manyoyo.json');
-
-    fs.mkdirSync(manyoyoHome, { recursive: true });
-
-    const manyoyoConfig = loadConfig();
-    let runsMap = {};
-    if (manyoyoConfig.runs !== undefined) {
-        if (typeof manyoyoConfig.runs !== 'object' || manyoyoConfig.runs === null || Array.isArray(manyoyoConfig.runs)) {
-            console.error(`${RED}⚠️  错误: ~/.manyoyo/manyoyo.json 的 runs 必须是对象(map)${NC}`);
-            process.exit(1);
-        }
-        runsMap = { ...manyoyoConfig.runs };
-    }
-    let hasConfigChanged = false;
-
-    const extractors = {
-        claude: collectClaudeInitData,
-        codex: collectCodexInitData,
-        gemini: collectGeminiInitData,
-        opencode: collectOpenCodeInitData
-    };
-    const yoloMap = {
-        claude: 'c',
-        codex: 'cx',
-        gemini: 'gm',
-        opencode: 'oc'
-    };
-
-    console.log(`${CYAN}🧭 正在初始化 MANYOYO 配置: ${agents.join(', ')}${NC}`);
-
-    for (const agent of agents) {
-        const data = extractors[agent](homeDir);
-        const shouldWriteRun = await shouldOverwriteInitRunEntry(
-            agent,
-            Object.prototype.hasOwnProperty.call(runsMap, agent)
-        );
-
-        let writeResult = { missingKeys: [], unsafeKeys: [] };
-        if (shouldWriteRun) {
-            const buildResult = buildInitRunProfile(agent, yoloMap[agent], data.volumes, data.keys, data.values);
-            runsMap[agent] = buildResult.runProfile;
-            writeResult = {
-                missingKeys: buildResult.missingKeys,
-                unsafeKeys: buildResult.unsafeKeys
-            };
-            hasConfigChanged = true;
-        }
-
-        if (shouldWriteRun) {
-            console.log(`${GREEN}✅ [${agent}] 初始化完成${NC}`);
-        } else {
-            console.log(`${YELLOW}⚠️  [${agent}] 已跳过（配置保留）${NC}`);
-        }
-        console.log(`   run: ${shouldWriteRun ? '已写入' : '保留'} runs.${agent}`);
-
-        if (shouldWriteRun && writeResult.missingKeys.length > 0) {
-            console.log(`${YELLOW}⚠️  [${agent}] 以下变量未找到，请手动填写:${NC} ${writeResult.missingKeys.join(', ')}`);
-        }
-        if (shouldWriteRun && writeResult.unsafeKeys.length > 0) {
-            console.log(`${YELLOW}⚠️  [${agent}] 以下变量包含不安全字符，已留空 env 键:${NC} ${writeResult.unsafeKeys.join(', ')}`);
-        }
-        if (data.notes && data.notes.length > 0) {
-            data.notes.forEach(note => console.log(`${YELLOW}⚠️  [${agent}] ${note}${NC}`));
-        }
-    }
-
-    if (hasConfigChanged || !fs.existsSync(manyoyoConfigPath)) {
-        manyoyoConfig.runs = runsMap;
-        fs.writeFileSync(manyoyoConfigPath, `${JSON.stringify(manyoyoConfig, null, 4)}\n`);
-    }
-}
-
-// ==============================================================================
-// SECTION: UI Functions
-// ==============================================================================
-
-function getHelloTip(containerName, defaultCommand) {
+function getHelloTip(containerName, defaultCommand, runningCommand) {
     if ( !(QUIET.tip || QUIET.full) ) {
+        const resumeArg = resolveAgentResumeArg(runningCommand);
         console.log("");
         console.log(`${BLUE}----------------------------------------${NC}`);
         console.log(`📦 首次命令        : ${defaultCommand}`);
-        console.log(`⚫ 恢复首次命令会话: ${CYAN}${MANYOYO_NAME} -n ${containerName} -- -c${NC}`);
+        if (resumeArg) {
+            console.log(`⚫ 恢复首次命令会话: ${CYAN}${MANYOYO_NAME} -n ${containerName} -- ${resumeArg}${NC}`);
+        }
         console.log(`⚫ 执行首次命令    : ${GREEN}${MANYOYO_NAME} -n ${containerName}${NC}`);
         console.log(`⚫ 执行指定命令    : ${GREEN}${MANYOYO_NAME} -n ${containerName} -x /bin/bash${NC}`);
         console.log(`⚫ 执行指定命令    : ${GREEN}docker exec -it ${containerName} /bin/bash${NC}`);
@@ -833,10 +368,6 @@ function isValidContainerName(value) {
     return typeof value === 'string' && SAFE_CONTAINER_NAME_PATTERN.test(value);
 }
 
-// ==============================================================================
-// SECTION: Environment Variables and Volume Handling
-// ==============================================================================
-
 async function askQuestion(prompt) {
     const rl = readline.createInterface({
         input: process.stdin,
@@ -851,10 +382,6 @@ async function askQuestion(prompt) {
     });
 }
 
-// ==============================================================================
-// Configuration Functions
-// ==============================================================================
-
 /**
  * 添加环境变量
  * @param {string} env - 环境变量字符串 (KEY=VALUE)
@@ -923,7 +450,6 @@ function addEnvFile(envFile) {
         process.exit(1);
     }
 
-    ENV_FILE = filePath;
     if (fs.existsSync(filePath)) {
         const content = fs.readFileSync(filePath, 'utf-8');
         const lines = content.split('\n');
@@ -962,34 +488,31 @@ function addVolume(volume) {
     CONTAINER_VOLUMES.push("--volume", volume);
 }
 
-// ==============================================================================
-// SECTION: YOLO Mode and Container Mode Configuration
-// ==============================================================================
+function addImageBuildArg(value) {
+    IMAGE_BUILD_ARGS.push("--build-arg", value);
+}
+
+const YOLO_COMMAND_MAP = {
+    claude: "IS_SANDBOX=1 claude --dangerously-skip-permissions",
+    cc: "IS_SANDBOX=1 claude --dangerously-skip-permissions",
+    c: "IS_SANDBOX=1 claude --dangerously-skip-permissions",
+    gemini: "gemini --yolo",
+    gm: "gemini --yolo",
+    g: "gemini --yolo",
+    codex: "codex --dangerously-bypass-approvals-and-sandbox",
+    cx: "codex --dangerously-bypass-approvals-and-sandbox",
+    opencode: "OPENCODE_PERMISSION='{\"*\":\"allow\"}' opencode",
+    oc: "OPENCODE_PERMISSION='{\"*\":\"allow\"}' opencode"
+};
 
 function setYolo(cli) {
-    switch (cli) {
-        case 'claude':
-        case 'cc':
-        case 'c':
-            EXEC_COMMAND = "IS_SANDBOX=1 claude --dangerously-skip-permissions";
-            break;
-        case 'gemini':
-        case 'gm':
-        case 'g':
-            EXEC_COMMAND = "gemini --yolo";
-            break;
-        case 'codex':
-        case 'cx':
-            EXEC_COMMAND = "codex --dangerously-bypass-approvals-and-sandbox";
-            break;
-        case 'opencode':
-        case 'oc':
-            EXEC_COMMAND = "OPENCODE_PERMISSION='{\"*\":\"allow\"}' opencode";
-            break;
-        default:
-            console.log(`${RED}⚠️  未知LLM CLI: ${cli}${NC}`);
-            process.exit(0);
+    const key = String(cli || '').trim().toLowerCase();
+    const mappedCommand = YOLO_COMMAND_MAP[key];
+    if (!mappedCommand) {
+        console.log(`${RED}⚠️  未知LLM CLI: ${cli}${NC}`);
+        process.exit(0);
     }
+    EXEC_COMMAND = mappedCommand;
 }
 
 /**
@@ -997,49 +520,41 @@ function setYolo(cli) {
  * @param {string} mode - 模式名称 (common, dind, sock)
  */
 function setContMode(mode) {
-    switch (mode) {
-        case 'common':
-            CONT_MODE = "";
-            CONT_MODE_ARGS = [];
-            break;
-        case 'docker-in-docker':
-        case 'dind':
-        case 'd':
-            CONT_MODE = "--privileged";
-            CONT_MODE_ARGS = ['--privileged'];
-            console.log(`${GREEN}✅ 开启安全的容器嵌套容器模式, 手动在容器内启动服务: nohup dockerd &${NC}`);
-            break;
-        case 'mount-docker-socket':
-        case 'sock':
-        case 's':
-            CONT_MODE = "--privileged --volume /var/run/docker.sock:/var/run/docker.sock --env DOCKER_HOST=unix:///var/run/docker.sock --env CONTAINER_HOST=unix:///var/run/docker.sock";
-            CONT_MODE_ARGS = [
-                '--privileged',
-                '--volume', '/var/run/docker.sock:/var/run/docker.sock',
-                '--env', 'DOCKER_HOST=unix:///var/run/docker.sock',
-                '--env', 'CONTAINER_HOST=unix:///var/run/docker.sock'
-            ];
-            console.log(`${RED}⚠️  开启危险的容器嵌套容器模式, 危害: 容器可访问宿主机文件${NC}`);
-            break;
-        default:
-            console.log(`${RED}⚠️  未知模式: ${mode}${NC}`);
-            process.exit(0);
+    const modeAliasMap = {
+        common: 'common',
+        'docker-in-docker': 'dind',
+        dind: 'dind',
+        d: 'dind',
+        'mount-docker-socket': 'sock',
+        sock: 'sock',
+        s: 'sock'
+    };
+    const normalizedMode = modeAliasMap[String(mode || '').trim().toLowerCase()];
+
+    if (normalizedMode === 'common') {
+        CONT_MODE_ARGS = [];
+        return;
     }
-}
 
-// ==============================================================================
-// Docker Helper Functions
-// ==============================================================================
+    if (normalizedMode === 'dind') {
+        CONT_MODE_ARGS = ['--privileged'];
+        console.log(`${GREEN}✅ 开启安全的容器嵌套容器模式, 手动在容器内启动服务: nohup dockerd &${NC}`);
+        return;
+    }
 
-function dockerExec(cmd, options = {}) {
-    try {
-        return execSync(cmd, { encoding: 'utf-8', ...options });
-    } catch (e) {
-        if (options.ignoreError) {
-            return e.stdout || '';
-        }
-        throw e;
+    if (normalizedMode === 'sock') {
+        CONT_MODE_ARGS = [
+            '--privileged',
+            '--volume', '/var/run/docker.sock:/var/run/docker.sock',
+            '--env', 'DOCKER_HOST=unix:///var/run/docker.sock',
+            '--env', 'CONTAINER_HOST=unix:///var/run/docker.sock'
+        ];
+        console.log(`${RED}⚠️  开启危险的容器嵌套容器模式, 危害: 容器可访问宿主机文件${NC}`);
+        return;
     }
+
+    console.log(`${RED}⚠️  未知模式: ${mode}${NC}`);
+    process.exit(0);
 }
 
 function showImagePullHint(err) {
@@ -1092,10 +607,6 @@ function removeContainer(name) {
     if ( !(QUIET.crm || QUIET.full) ) console.log(`${GREEN}✅ 已彻底删除。${NC}`);
 }
 
-// ==============================================================================
-// SECTION: Docker Operations
-// ==============================================================================
-
 function ensureDocker() {
     const commands = ['docker', 'podman'];
     for (const cmd of commands) {
@@ -1163,279 +674,34 @@ function pruneDanglingImages() {
     console.log(`${GREEN}✅ 清理完成${NC}`);
 }
 
-// ==============================================================================
-// SECTION: Image Build System
-// ==============================================================================
-
-/**
- * 准备构建缓存（Node.js、JDT LSP、gopls）
- * @param {string} imageTool - 构建工具类型
- */
-async function prepareBuildCache(imageTool) {
-    const cacheDir = path.join(__dirname, '../docker/cache');
-    const timestampFile = path.join(cacheDir, '.timestamps.json');
-
-    // 从配置文件读取 TTL，默认 2 天
-    const config = loadConfig();
-    const cacheTTLDays = config.cacheTTL || CONFIG.CACHE_TTL_DAYS;
-
-    // 镜像源优先级：用户配置 > 腾讯云 > 官方
-    const nodeMirrors = [
-        config.nodeMirror,
-        'https://mirrors.tencent.com/nodejs-release',
-        'https://nodejs.org/dist'
-    ].filter(Boolean);
-
-    console.log(`\n${CYAN}准备构建缓存...${NC}`);
-
-    // Create cache directory
-    if (!fs.existsSync(cacheDir)) {
-        fs.mkdirSync(cacheDir, { recursive: true });
-    }
-
-    // Load timestamps
-    let timestamps = {};
-    if (fs.existsSync(timestampFile)) {
-        try {
-            timestamps = JSON.parse(fs.readFileSync(timestampFile, 'utf-8'));
-        } catch (e) {
-            timestamps = {};
-        }
-    }
-
-    const now = new Date();
-    const isExpired = (key) => {
-        if (!timestamps[key]) return true;
-        const cachedTime = new Date(timestamps[key]);
-        const diffDays = (now - cachedTime) / (1000 * 60 * 60 * 24);
-        return diffDays > cacheTTLDays;
-    };
-
-    // Determine architecture
-    const arch = process.arch === 'x64' ? 'amd64' : process.arch === 'arm64' ? 'arm64' : process.arch;
-    const archNode = arch === 'amd64' ? 'x64' : 'arm64';
-
-    // Prepare Node.js cache
-    const nodeCacheDir = path.join(cacheDir, 'node');
-    const nodeVersion = 24;
-    const nodeKey = 'node/';  // 使用目录级别的相对路径
-
-    if (!fs.existsSync(nodeCacheDir)) {
-        fs.mkdirSync(nodeCacheDir, { recursive: true });
-    }
-
-    const hasNodeCache = fs.existsSync(nodeCacheDir) && fs.readdirSync(nodeCacheDir).some(f => f.startsWith('node-') && f.includes(`linux-${archNode}`));
-    if (!hasNodeCache || isExpired(nodeKey)) {
-        console.log(`${YELLOW}下载 Node.js ${nodeVersion} (${archNode})...${NC}`);
-
-        // 尝试多个镜像源
-        let downloadSuccess = false;
-        for (const mirror of nodeMirrors) {
-            try {
-                console.log(`${BLUE}尝试镜像源: ${mirror}${NC}`);
-                const shasumUrl = `${mirror}/latest-v${nodeVersion}.x/SHASUMS256.txt`;
-                const shasumContent = execSync(`curl -sL ${shasumUrl}`, { encoding: 'utf-8' });
-                const shasumLine = shasumContent.split('\n').find(line => line.includes(`linux-${archNode}.tar.gz`));
-                if (!shasumLine) continue;
-
-                const [expectedHash, fileName] = shasumLine.trim().split(/\s+/);
-                const nodeUrl = `${mirror}/latest-v${nodeVersion}.x/${fileName}`;
-                const nodeTargetPath = path.join(nodeCacheDir, fileName);
-
-                // 下载文件
-                runCmd('curl', ['-fsSL', nodeUrl, '-o', nodeTargetPath], { stdio: 'inherit' });
-
-                // SHA256 校验（使用 Node.js crypto 模块，跨平台）
-                const actualHash = getFileSha256(nodeTargetPath);
-                if (actualHash !== expectedHash) {
-                    console.log(`${RED}SHA256 校验失败，删除文件${NC}`);
-                    fs.unlinkSync(nodeTargetPath);
-                    continue;
-                }
-
-                console.log(`${GREEN}✓ SHA256 校验通过${NC}`);
-                timestamps[nodeKey] = now.toISOString();
-                fs.writeFileSync(timestampFile, JSON.stringify(timestamps, null, 4));
-                console.log(`${GREEN}✓ Node.js 下载完成${NC}`);
-                downloadSuccess = true;
-                break;
-            } catch (e) {
-                console.log(`${YELLOW}镜像源 ${mirror} 失败，尝试下一个...${NC}`);
-            }
-        }
-
-        if (!downloadSuccess) {
-            console.error(`${RED}错误: Node.js 下载失败（所有镜像源均不可用）${NC}`);
-            throw new Error('Node.js download failed');
-        }
-    } else {
-        console.log(`${GREEN}✓ Node.js 缓存已存在${NC}`);
-    }
-
-    // Prepare JDT LSP cache (for java variant)
-    if (imageTool === 'full' || imageTool.includes('java')) {
-        const jdtlsCacheDir = path.join(cacheDir, 'jdtls');
-        const jdtlsKey = 'jdtls/jdt-language-server-latest.tar.gz';  // 使用相对路径
-        const jdtlsPath = path.join(cacheDir, jdtlsKey);
-
-        if (!fs.existsSync(jdtlsCacheDir)) {
-            fs.mkdirSync(jdtlsCacheDir, { recursive: true });
-        }
-
-        if (!fs.existsSync(jdtlsPath) || isExpired(jdtlsKey)) {
-            console.log(`${YELLOW}下载 JDT Language Server...${NC}`);
-            const apkUrl = 'https://mirrors.tencent.com/alpine/latest-stable/community/x86_64/jdtls-1.53.0-r0.apk';
-            const tmpDir = path.join(jdtlsCacheDir, '.tmp-apk');
-            const apkPath = path.join(tmpDir, 'jdtls.apk');
-            try {
-                fs.mkdirSync(tmpDir, { recursive: true });
-                runCmd('curl', ['-fsSL', apkUrl, '-o', apkPath], { stdio: 'inherit' });
-                runCmd('tar', ['-xzf', apkPath, '-C', tmpDir], { stdio: 'inherit' });
-                const srcDir = path.join(tmpDir, 'usr', 'share', 'jdtls');
-                runCmd('tar', ['-czf', jdtlsPath, '-C', srcDir, '.'], { stdio: 'inherit' });
-                timestamps[jdtlsKey] = now.toISOString();
-                fs.writeFileSync(timestampFile, JSON.stringify(timestamps, null, 4));
-                console.log(`${GREEN}✓ JDT LSP 下载完成${NC}`);
-            } catch (e) {
-                console.error(`${RED}错误: JDT LSP 下载失败${NC}`);
-                throw e;
-            } finally {
-                try { runCmd('rm', ['-rf', tmpDir], { stdio: 'inherit', ignoreError: true }); } catch {}
-            }
-        } else {
-            console.log(`${GREEN}✓ JDT LSP 缓存已存在${NC}`);
-        }
-    }
-
-    // Prepare gopls cache (for go variant)
-    if (imageTool === 'full' || imageTool.includes('go')) {
-        const goplsCacheDir = path.join(cacheDir, 'gopls');
-        const goplsKey = `gopls/gopls-linux-${arch}`;  // 使用相对路径
-        const goplsPath = path.join(cacheDir, goplsKey);
-
-        if (!fs.existsSync(goplsCacheDir)) {
-            fs.mkdirSync(goplsCacheDir, { recursive: true });
-        }
-
-        if (!fs.existsSync(goplsPath) || isExpired(goplsKey)) {
-            console.log(`${YELLOW}下载 gopls (${arch})...${NC}`);
-            try {
-                // Download using go install in temporary environment
-                const tmpGoPath = path.join(cacheDir, '.tmp-go');
-
-                // Clean up existing temp directory (with go clean for mod cache)
-                if (fs.existsSync(tmpGoPath)) {
-                    try {
-                        execSync(`GOPATH="${tmpGoPath}" go clean -modcache 2>/dev/null || true`, { stdio: 'inherit' });
-                        execSync(`chmod -R u+w "${tmpGoPath}" 2>/dev/null || true`, { stdio: 'inherit' });
-                        execSync(`rm -rf "${tmpGoPath}"`, { stdio: 'inherit' });
-                    } catch (e) {
-                        // Ignore cleanup errors
-                    }
-                }
-                fs.mkdirSync(tmpGoPath, { recursive: true });
-
-                runCmd('go', ['install', 'golang.org/x/tools/gopls@latest'], {
-                    stdio: 'inherit',
-                    env: { ...process.env, GOPATH: tmpGoPath, GOOS: 'linux', GOARCH: arch }
-                });
-                execSync(`cp "${tmpGoPath}/bin/linux_${arch}/gopls" "${goplsPath}" || cp "${tmpGoPath}/bin/gopls" "${goplsPath}"`, { stdio: 'inherit' });
-                runCmd('chmod', ['+x', goplsPath], { stdio: 'inherit' });
-
-                // Save timestamp immediately after successful download
-                timestamps[goplsKey] = now.toISOString();
-                fs.writeFileSync(timestampFile, JSON.stringify(timestamps, null, 4));
-                console.log(`${GREEN}✓ gopls 下载完成${NC}`);
-
-                // Clean up temp directory (with go clean for mod cache)
-                try {
-                    execSync(`GOPATH="${tmpGoPath}" go clean -modcache 2>/dev/null || true`, { stdio: 'inherit' });
-                    execSync(`chmod -R u+w "${tmpGoPath}" 2>/dev/null || true`, { stdio: 'inherit' });
-                    execSync(`rm -rf "${tmpGoPath}"`, { stdio: 'inherit' });
-                } catch (e) {
-                    console.log(`${YELLOW}提示: 临时目录清理失败，可手动删除 ${tmpGoPath}${NC}`);
-                }
-            } catch (e) {
-                console.error(`${RED}错误: gopls 下载失败${NC}`);
-                throw e;
-            }
-        } else {
-            console.log(`${GREEN}✓ gopls 缓存已存在${NC}`);
-        }
+function maybeHandleDockerPluginMetadata(argv) {
+    if (argv[2] !== 'docker-cli-plugin-metadata') {
+        return false;
     }
-
-    // Save timestamps
-    fs.writeFileSync(timestampFile, JSON.stringify(timestamps, null, 4));
-    console.log(`${GREEN}✅ 构建缓存准备完成${NC}\n`);
-}
-
-function addImageBuildArg(string) {
-    IMAGE_BUILD_ARGS.push("--build-arg", string);
+    console.log(JSON.stringify({
+        "SchemaVersion": "0.1.0",
+        "Vendor": "xcanwin",
+        "Version": "v1.0.0",
+        "Description": "AI Agent CLI Sandbox"
+    }, null, 4));
+    return true;
 }
 
-async function buildImage(IMAGE_BUILD_ARGS, imageName, imageVersionTag) {
-    const versionTag = imageVersionTag || IMAGE_VERSION_DEFAULT || `${IMAGE_VERSION_BASE}-common`;
-    const parsedVersion = parseImageVersionTag(versionTag);
-    if (!parsedVersion) {
-        console.error(`${RED}错误: 镜像版本格式错误，必须为 <x.y.z-后缀>，例如 1.7.4-common: ${versionTag}${NC}`);
-        process.exit(1);
-    }
-
-    const version = parsedVersion.baseVersion;
-    let imageTool = parsedVersion.tool;
-    const toolFromArgs = IMAGE_BUILD_ARGS.filter(v => v.startsWith("TOOL=")).at(-1)?.slice("TOOL=".length);
-
-    if (!toolFromArgs) {
-        IMAGE_BUILD_ARGS = [...IMAGE_BUILD_ARGS, "--build-arg", `TOOL=${imageTool}`];
-    } else {
-        imageTool = toolFromArgs;
-    }
-
-    const fullImageTag = `${imageName}:${version}-${imageTool}`;
-
-    console.log(`${CYAN}🔨 正在构建镜像: ${YELLOW}${fullImageTag}${NC}`);
-    console.log(`${BLUE}构建组件类型: ${imageTool}${NC}\n`);
-
-    // Prepare cache (自动检测并下载缺失的文件)
-    await prepareBuildCache(imageTool);
-
-    // Find Dockerfile path
-    const dockerfilePath = path.join(__dirname, '../docker/manyoyo.Dockerfile');
-    if (!fs.existsSync(dockerfilePath)) {
-        console.error(`${RED}错误: 找不到 Dockerfile: ${dockerfilePath}${NC}`);
-        process.exit(1);
-    }
-
-    // Build command
-    const imageBuildArgs = IMAGE_BUILD_ARGS.join(' ');
-    const buildCmd = `${DOCKER_CMD} build -t "${fullImageTag}" -f "${dockerfilePath}" "${path.join(__dirname, '..')}" ${imageBuildArgs} --load --progress=plain --no-cache`;
-
-    console.log(`${BLUE}准备执行命令:${NC}`);
-    console.log(`${buildCmd}\n`);
-
-    if (!YES_MODE) {
-        await askQuestion(`❔ 是否继续构建? [ 直接回车=继续, ctrl+c=取消 ]: `);
-        console.log("");
+function normalizeDockerPluginArgv(argv) {
+    const dockerPluginPath = path.join(process.env.HOME || '', '.docker/cli-plugins/docker-manyoyo');
+    if (argv[1] === dockerPluginPath && argv[2] === 'manyoyo') {
+        argv.splice(2, 1);
     }
+}
 
-    try {
-        execSync(buildCmd, { stdio: 'inherit' });
-        console.log(`\n${GREEN}✅ 镜像构建成功: ${fullImageTag}${NC}`);
-        console.log(`${BLUE}使用镜像:${NC}`);
-        console.log(`  ${MANYOYO_NAME} -n test --in ${imageName} --iv ${version}-${imageTool} -y c`);
-
-        // Prune dangling images
-        pruneDanglingImages();
-    } catch (e) {
-        console.error(`${RED}错误: 镜像构建失败${NC}`);
-        process.exit(1);
+function normalizeShellFullArgv(argv) {
+    const shellFullIndex = argv.findIndex(arg => arg === '-x' || arg === '--shell-full');
+    if (shellFullIndex !== -1 && shellFullIndex < argv.length - 1) {
+        const shellFullArgs = argv.slice(shellFullIndex + 1).join(' ');
+        argv.splice(shellFullIndex + 1, argv.length - (shellFullIndex + 1), shellFullArgs);
     }
 }
 
-// ==============================================================================
-// SECTION: Command Line Interface
-// ==============================================================================
-
 async function setupCommander() {
     // Load config file
     const config = loadConfig();
@@ -1505,21 +771,12 @@ async function setupCommander() {
         .option('-q, --quiet <item>', '静默显示 (可多次使用: cnew,crm,tip,cmd,full)', (value, previous) => [...(previous || []), value], []);
 
     // Docker CLI plugin metadata check
-    if (process.argv[2] === 'docker-cli-plugin-metadata') {
-        console.log(JSON.stringify({
-            "SchemaVersion": "0.1.0",
-            "Vendor": "xcanwin",
-            "Version": "v1.0.0",
-            "Description": "AI Agent CLI Sandbox"
-        }, null, 4));
+    if (maybeHandleDockerPluginMetadata(process.argv)) {
         process.exit(0);
     }
 
     // Docker CLI plugin mode - remove first arg if running as plugin
-    const dockerPluginPath = path.join(process.env.HOME || '', '.docker/cli-plugins/docker-manyoyo');
-    if (process.argv[1] === dockerPluginPath && process.argv[2] === 'manyoyo') {
-        process.argv.splice(2, 1);
-    }
+    normalizeDockerPluginArgv(process.argv);
 
     // No args: show help instead of starting container
     if (process.argv.length <= 2) {
@@ -1534,11 +791,7 @@ async function setupCommander() {
     }
 
     // Pre-handle -x/--shell-full: treat all following args as a single command
-    const shellFullIndex = process.argv.findIndex(arg => arg === '-x' || arg === '--shell-full');
-    if (shellFullIndex !== -1 && shellFullIndex < process.argv.length - 1) {
-        const shellFullArgs = process.argv.slice(shellFullIndex + 1).join(' ');
-        process.argv.splice(shellFullIndex + 1, process.argv.length - (shellFullIndex + 1), shellFullArgs);
-    }
+    normalizeShellFullArgv(process.argv);
 
     // Parse arguments
     program.allowUnknownOption(false);
@@ -1551,7 +804,13 @@ async function setupCommander() {
     }
 
     if (options.initConfig !== undefined) {
-        await initAgentConfigs(options.initConfig);
+        await initAgentConfigs(options.initConfig, {
+            yesMode: YES_MODE,
+            askQuestion,
+            loadConfig,
+            supportedAgents: SUPPORTED_INIT_AGENTS,
+            colors: { RED, GREEN, YELLOW, CYAN, NC }
+        });
         process.exit(0);
     }
 
@@ -1560,26 +819,32 @@ async function setupCommander() {
 
     // Merge configs: command line > run config > global config > defaults
     // Override mode (scalar values): use first defined value
-    HOST_PATH = options.hostPath || runConfig.hostPath || config.hostPath || HOST_PATH;
-    if (options.contName || runConfig.containerName || config.containerName) {
-        CONTAINER_NAME = options.contName || runConfig.containerName || config.containerName;
+    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);
-    if (options.contPath || runConfig.containerPath || config.containerPath) {
-        CONTAINER_PATH = options.contPath || runConfig.containerPath || config.containerPath;
+    const mergedContainerPath = pickConfigValue(options.contPath, runConfig.containerPath, config.containerPath);
+    if (mergedContainerPath) {
+        CONTAINER_PATH = mergedContainerPath;
     }
-    IMAGE_NAME = options.imageName || runConfig.imageName || config.imageName || IMAGE_NAME;
-    if (options.imageVer || runConfig.imageVersion || config.imageVersion) {
-        IMAGE_VERSION = options.imageVer || runConfig.imageVersion || config.imageVersion;
+    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;
     }
-    if (options.shellPrefix || runConfig.shellPrefix || config.shellPrefix) {
-        EXEC_COMMAND_PREFIX = (options.shellPrefix || runConfig.shellPrefix || config.shellPrefix) + " ";
+    const mergedShellPrefix = pickConfigValue(options.shellPrefix, runConfig.shellPrefix, config.shellPrefix);
+    if (mergedShellPrefix) {
+        EXEC_COMMAND_PREFIX = `${mergedShellPrefix} `;
     }
-    if (options.shell || runConfig.shell || config.shell) {
-        EXEC_COMMAND = options.shell || runConfig.shell || config.shell;
+    const mergedShell = pickConfigValue(options.shell, runConfig.shell, config.shell);
+    if (mergedShell) {
+        EXEC_COMMAND = mergedShell;
     }
-    if (options.shellSuffix || runConfig.shellSuffix || config.shellSuffix) {
-        EXEC_COMMAND_SUFFIX = normalizeCommandSuffix(options.shellSuffix || runConfig.shellSuffix || config.shellSuffix);
+    const mergedShellSuffix = pickConfigValue(options.shellSuffix, runConfig.shellSuffix, config.shellSuffix);
+    if (mergedShellSuffix) {
+        EXEC_COMMAND_SUFFIX = normalizeCommandSuffix(mergedShellSuffix);
     }
 
     // Basic name validation to reduce injection risk
@@ -1604,20 +869,20 @@ async function setupCommander() {
     };
     Object.entries(envMap).forEach(([key, value]) => addEnv(`${key}=${value}`));
 
-    const volumeList = [...(config.volumes || []), ...(runConfig.volumes || []), ...(options.volume || [])];
+    const volumeList = mergeArrayConfig(config.volumes, runConfig.volumes, options.volume);
     volumeList.forEach(v => addVolume(v));
 
-    const buildArgList = [...(config.imageBuildArgs || []), ...(runConfig.imageBuildArgs || []), ...(options.imageBuildArg || [])];
+    const buildArgList = mergeArrayConfig(config.imageBuildArgs, runConfig.imageBuildArgs, options.imageBuildArg);
     buildArgList.forEach(arg => addImageBuildArg(arg));
 
     // Override mode for special options
-    const yoloValue = options.yolo || runConfig.yolo || config.yolo;
+    const yoloValue = pickConfigValue(options.yolo, runConfig.yolo, config.yolo);
     if (yoloValue) setYolo(yoloValue);
 
-    const contModeValue = options.contMode || runConfig.containerMode || config.containerMode;
+    const contModeValue = pickConfigValue(options.contMode, runConfig.containerMode, config.containerMode);
     if (contModeValue) setContMode(contModeValue);
 
-    const quietValue = options.quiet || runConfig.quiet || config.quiet;
+    const quietValue = pickConfigValue(options.quiet, runConfig.quiet, config.quiet);
     if (quietValue) setQuiet(quietValue);
 
     // Handle shell-full (variadic arguments)
@@ -1635,10 +900,6 @@ async function setupCommander() {
         }
     }
 
-    if (options.yes) {
-        YES_MODE = true;
-    }
-
     if (options.rmOnExit) {
         RM_ON_EXIT = true;
     }
@@ -1650,12 +911,12 @@ async function setupCommander() {
         SERVER_PORT = serverListen.port;
     }
 
-    const serverUserValue = options.serverUser || runConfig.serverUser || config.serverUser || process.env.MANYOYO_SERVER_USER;
+    const serverUserValue = pickConfigValue(options.serverUser, runConfig.serverUser, config.serverUser, process.env.MANYOYO_SERVER_USER);
     if (serverUserValue) {
         SERVER_AUTH_USER = String(serverUserValue);
     }
 
-    const serverPassValue = options.serverPass || runConfig.serverPass || config.serverPass || process.env.MANYOYO_SERVER_PASS;
+    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;
@@ -1712,27 +973,54 @@ async function setupCommander() {
     return program;
 }
 
-function handleRemoveContainer() {
-    if (SHOULD_REMOVE) {
-        try {
-            if (containerExists(CONTAINER_NAME)) {
-                removeContainer(CONTAINER_NAME);
-            } else {
-                console.log(`${RED}⚠️  错误: 未找到名为 ${CONTAINER_NAME} 的容器。${NC}`);
-            }
-        } catch (e) {
-            console.log(`${RED}⚠️  错误: 未找到名为 ${CONTAINER_NAME} 的容器。${NC}`);
+function createRuntimeContext() {
+    return {
+        containerName: CONTAINER_NAME,
+        hostPath: HOST_PATH,
+        containerPath: CONTAINER_PATH,
+        imageName: IMAGE_NAME,
+        imageVersion: IMAGE_VERSION,
+        execCommand: EXEC_COMMAND,
+        execCommandPrefix: EXEC_COMMAND_PREFIX,
+        execCommandSuffix: EXEC_COMMAND_SUFFIX,
+        contModeArgs: CONT_MODE_ARGS,
+        containerEnvs: CONTAINER_ENVS,
+        containerVolumes: CONTAINER_VOLUMES,
+        quiet: QUIET,
+        showCommand: SHOW_COMMAND,
+        rmOnExit: RM_ON_EXIT,
+        serverMode: SERVER_MODE,
+        serverHost: SERVER_HOST,
+        serverPort: SERVER_PORT,
+        serverAuthUser: SERVER_AUTH_USER,
+        serverAuthPass: SERVER_AUTH_PASS,
+        serverAuthPassAuto: SERVER_AUTH_PASS_AUTO
+    };
+}
+
+function handleRemoveContainer(runtime) {
+    if (!SHOULD_REMOVE) {
+        return false;
+    }
+
+    try {
+        if (containerExists(runtime.containerName)) {
+            removeContainer(runtime.containerName);
+        } else {
+            console.log(`${RED}⚠️  错误: 未找到名为 ${runtime.containerName} 的容器。${NC}`);
         }
-        process.exit(0);
+    } catch (e) {
+        console.log(`${RED}⚠️  错误: 未找到名为 ${runtime.containerName} 的容器。${NC}`);
     }
+    return true;
 }
 
-function validateHostPath() {
-    if (!fs.existsSync(HOST_PATH)) {
-        console.log(`${RED}⚠️  错误: 宿主机路径不存在: ${HOST_PATH}${NC}`);
+function validateHostPath(runtime) {
+    if (!fs.existsSync(runtime.hostPath)) {
+        console.log(`${RED}⚠️  错误: 宿主机路径不存在: ${runtime.hostPath}${NC}`);
         process.exit(1);
     }
-    const realHostPath = fs.realpathSync(HOST_PATH);
+    const realHostPath = fs.realpathSync(runtime.hostPath);
     const homeDir = process.env.HOME || '/home';
     if (realHostPath === '/' || realHostPath === '/home' || realHostPath === homeDir) {
         console.log(`${RED}⚠️  错误: 不允许挂载根目录或home目录。${NC}`);
@@ -1774,28 +1062,34 @@ async function waitForContainerReady(containerName) {
     process.exit(1);
 }
 
-// ==============================================================================
-// SECTION: Container Lifecycle Management
-// ==============================================================================
+function joinExecCommand(prefix, command, suffix) {
+    return `${prefix || ''}${command || ''}${suffix || ''}`;
+}
 
 /**
  * 创建新容器
  * @returns {Promise<string>} 默认命令
  */
-async function createNewContainer() {
-    if ( !(QUIET.cnew || QUIET.full) ) console.log(`${CYAN}📦 manyoyo by xcanwin 正在创建新容器: ${YELLOW}${CONTAINER_NAME}${NC}`);
+async function createNewContainer(runtime) {
+    if (!(runtime.quiet.cnew || runtime.quiet.full)) {
+        console.log(`${CYAN}📦 manyoyo by xcanwin 正在创建新容器: ${YELLOW}${runtime.containerName}${NC}`);
+    }
 
-    EXEC_COMMAND = `${EXEC_COMMAND_PREFIX}${EXEC_COMMAND}${EXEC_COMMAND_SUFFIX}`;
-    const defaultCommand = EXEC_COMMAND;
+    runtime.execCommand = joinExecCommand(
+        runtime.execCommandPrefix,
+        runtime.execCommand,
+        runtime.execCommandSuffix
+    );
+    const defaultCommand = runtime.execCommand;
 
-    if (SHOW_COMMAND) {
-        console.log(buildDockerRunCmd());
+    if (runtime.showCommand) {
+        console.log(buildDockerRunCmd(runtime));
         process.exit(0);
     }
 
     // 使用数组参数执行命令（安全方式）
     try {
-        const args = buildDockerRunArgs();
+        const args = buildDockerRunArgs(runtime);
         dockerExecArgs(args, { stdio: 'pipe' });
     } catch (e) {
         showImagePullHint(e);
@@ -1803,7 +1097,7 @@ async function createNewContainer() {
     }
 
     // Wait for container to be ready
-    await waitForContainerReady(CONTAINER_NAME);
+    await waitForContainerReady(runtime.containerName);
 
     return defaultCommand;
 }
@@ -1812,97 +1106,94 @@ async function createNewContainer() {
  * 构建 Docker run 命令参数数组（安全方式，避免命令注入）
  * @returns {string[]} 命令参数数组
  */
-function buildDockerRunArgs() {
-    const fullImage = `${IMAGE_NAME}:${IMAGE_VERSION}`;
-    const safeLabelCmd = EXEC_COMMAND.replace(/[\r\n]/g, ' ');
-
-    const args = [
-        'run', '-d',
-        '--name', CONTAINER_NAME,
-        '--entrypoint', '',
-        ...CONT_MODE_ARGS,
-        ...CONTAINER_ENVS,
-        ...CONTAINER_VOLUMES,
-        '--volume', `${HOST_PATH}:${CONTAINER_PATH}`,
-        '--workdir', CONTAINER_PATH,
-        '--label', `manyoyo.default_cmd=${safeLabelCmd}`,
-        fullImage,
-        'tail', '-f', '/dev/null'
-    ];
-
-    return args;
+function buildDockerRunArgs(runtime) {
+    return buildContainerRunArgs({
+        containerName: runtime.containerName,
+        hostPath: runtime.hostPath,
+        containerPath: runtime.containerPath,
+        imageName: runtime.imageName,
+        imageVersion: runtime.imageVersion,
+        contModeArgs: runtime.contModeArgs,
+        containerEnvs: runtime.containerEnvs,
+        containerVolumes: runtime.containerVolumes,
+        defaultCommand: runtime.execCommand
+    });
 }
 
 /**
  * 构建 Docker run 命令字符串（用于显示）
  * @returns {string} 命令字符串
  */
-function buildDockerRunCmd() {
-    const args = buildDockerRunArgs();
-    // 对包含空格或特殊字符的参数加引号
-    const quotedArgs = args.map(arg => {
-        if (arg.includes(' ') || arg.includes('"') || arg.includes('=')) {
-            return `"${arg.replace(/"/g, '\\"')}"`;
-        }
-        return arg;
-    });
-    return `${DOCKER_CMD} ${quotedArgs.join(' ')}`;
+function buildDockerRunCmd(runtime) {
+    const args = buildDockerRunArgs(runtime);
+    return buildContainerRunCommand(DOCKER_CMD, args);
 }
 
-async function connectExistingContainer() {
-    if ( !(QUIET.cnew || QUIET.full) ) console.log(`${CYAN}🔄 manyoyo by xcanwin 正在连接到现有容器: ${YELLOW}${CONTAINER_NAME}${NC}`);
+async function connectExistingContainer(runtime) {
+    if (!(runtime.quiet.cnew || runtime.quiet.full)) {
+        console.log(`${CYAN}🔄 manyoyo by xcanwin 正在连接到现有容器: ${YELLOW}${runtime.containerName}${NC}`);
+    }
 
     // Start container if stopped
-    const status = getContainerStatus(CONTAINER_NAME);
+    const status = getContainerStatus(runtime.containerName);
     if (status !== 'running') {
-        dockerExecArgs(['start', CONTAINER_NAME], { stdio: 'pipe' });
+        dockerExecArgs(['start', runtime.containerName], { stdio: 'pipe' });
     }
 
     // Get default command from label
-    const defaultCommand = dockerExecArgs(['inspect', '-f', '{{index .Config.Labels "manyoyo.default_cmd"}}', CONTAINER_NAME]).trim();
+    const defaultCommand = dockerExecArgs(['inspect', '-f', '{{index .Config.Labels "manyoyo.default_cmd"}}', runtime.containerName]).trim();
 
-    if (!EXEC_COMMAND) {
-        EXEC_COMMAND = `${EXEC_COMMAND_PREFIX}${defaultCommand}${EXEC_COMMAND_SUFFIX}`;
+    if (!runtime.execCommand) {
+        runtime.execCommand = joinExecCommand(runtime.execCommandPrefix, defaultCommand, runtime.execCommandSuffix);
     } else {
-        EXEC_COMMAND = `${EXEC_COMMAND_PREFIX}${EXEC_COMMAND}${EXEC_COMMAND_SUFFIX}`;
+        runtime.execCommand = joinExecCommand(runtime.execCommandPrefix, runtime.execCommand, runtime.execCommandSuffix);
     }
 
     return defaultCommand;
 }
 
-async function setupContainer() {
-    if (SHOW_COMMAND) {
-        if (containerExists(CONTAINER_NAME)) {
-            const defaultCommand = dockerExecArgs(['inspect', '-f', '{{index .Config.Labels "manyoyo.default_cmd"}}', CONTAINER_NAME]).trim();
-            const execCmd = EXEC_COMMAND
-                ? `${EXEC_COMMAND_PREFIX}${EXEC_COMMAND}${EXEC_COMMAND_SUFFIX}`
-                : `${EXEC_COMMAND_PREFIX}${defaultCommand}${EXEC_COMMAND_SUFFIX}`;
-            console.log(`${DOCKER_CMD} exec -it ${CONTAINER_NAME} /bin/bash -c "${execCmd.replace(/"/g, '\\"')}"`);
+async function setupContainer(runtime) {
+    if (runtime.showCommand) {
+        if (containerExists(runtime.containerName)) {
+            const defaultCommand = dockerExecArgs(['inspect', '-f', '{{index .Config.Labels "manyoyo.default_cmd"}}', runtime.containerName]).trim();
+            const execCmd = runtime.execCommand
+                ? joinExecCommand(runtime.execCommandPrefix, runtime.execCommand, runtime.execCommandSuffix)
+                : joinExecCommand(runtime.execCommandPrefix, defaultCommand, runtime.execCommandSuffix);
+            console.log(`${DOCKER_CMD} exec -it ${runtime.containerName} /bin/bash -c "${execCmd.replace(/"/g, '\\"')}"`);
             process.exit(0);
         }
-        EXEC_COMMAND = `${EXEC_COMMAND_PREFIX}${EXEC_COMMAND}${EXEC_COMMAND_SUFFIX}`;
-        console.log(buildDockerRunCmd());
+        runtime.execCommand = joinExecCommand(runtime.execCommandPrefix, runtime.execCommand, runtime.execCommandSuffix);
+        console.log(buildDockerRunCmd(runtime));
         process.exit(0);
     }
-    if (!containerExists(CONTAINER_NAME)) {
-        return await createNewContainer();
+    if (!containerExists(runtime.containerName)) {
+        return await createNewContainer(runtime);
     } else {
-        return await connectExistingContainer();
+        return await connectExistingContainer(runtime);
     }
 }
 
-function executeInContainer(defaultCommand) {
-    getHelloTip(CONTAINER_NAME, defaultCommand);
-    if ( !(QUIET.cmd || QUIET.full) ) {
+function executeInContainer(runtime, defaultCommand) {
+    if (!containerExists(runtime.containerName)) {
+        throw new Error(`未找到容器: ${runtime.containerName}`);
+    }
+
+    const status = getContainerStatus(runtime.containerName);
+    if (status !== 'running') {
+        dockerExecArgs(['start', runtime.containerName], { stdio: 'pipe' });
+    }
+
+    getHelloTip(runtime.containerName, defaultCommand, runtime.execCommand);
+    if (!(runtime.quiet.cmd || runtime.quiet.full)) {
         console.log(`${BLUE}----------------------------------------${NC}`);
-        console.log(`💻 执行命令: ${YELLOW}${EXEC_COMMAND || '交互式 Shell'}${NC}`);
+        console.log(`💻 执行命令: ${YELLOW}${runtime.execCommand || '交互式 Shell'}${NC}`);
     }
 
     // Execute command in container
-    if (EXEC_COMMAND) {
-        spawnSync(`${DOCKER_CMD}`, ['exec', '-it', CONTAINER_NAME, '/bin/bash', '-c', EXEC_COMMAND], { stdio: 'inherit' });
+    if (runtime.execCommand) {
+        spawnSync(`${DOCKER_CMD}`, ['exec', '-it', runtime.containerName, '/bin/bash', '-c', runtime.execCommand], { stdio: 'inherit' });
     } else {
-        spawnSync(`${DOCKER_CMD}`, ['exec', '-it', CONTAINER_NAME, '/bin/bash'], { stdio: 'inherit' });
+        spawnSync(`${DOCKER_CMD}`, ['exec', '-it', runtime.containerName, '/bin/bash'], { stdio: 'inherit' });
     }
 }
 
@@ -1910,73 +1201,75 @@ function executeInContainer(defaultCommand) {
  * 处理会话退出后的交互
  * @param {string} defaultCommand - 默认命令
  */
-async function handlePostExit(defaultCommand) {
+async function handlePostExit(runtime, defaultCommand) {
     // --rm-on-exit 模式：自动删除容器
-    if (RM_ON_EXIT) {
-        removeContainer(CONTAINER_NAME);
-        return;
+    if (runtime.rmOnExit) {
+        removeContainer(runtime.containerName);
+        return false;
     }
 
-    getHelloTip(CONTAINER_NAME, defaultCommand);
+    getHelloTip(runtime.containerName, defaultCommand, runtime.execCommand);
 
-    let tipAskKeep = `❔ 会话已结束。是否保留此后台容器 ${CONTAINER_NAME}? [ y=默认保留, n=删除, 1=首次命令进入, x=执行命令, i=交互式SHELL ]: `;
-    if ( QUIET.askkeep || QUIET.full ) tipAskKeep = `保留容器吗? [y n 1 x i] `;
+    let tipAskKeep = `❔ 会话已结束。是否保留此后台容器 ${runtime.containerName}? [ y=默认保留, n=删除, 1=首次命令进入, x=执行命令, i=交互式SHELL ]: `;
+    if (runtime.quiet.askkeep || runtime.quiet.full) tipAskKeep = `保留容器吗? [y n 1 x i] `;
     const reply = await askQuestion(tipAskKeep);
 
     const firstChar = reply.trim().toLowerCase()[0];
 
     if (firstChar === 'n') {
-        removeContainer(CONTAINER_NAME);
+        removeContainer(runtime.containerName);
+        return false;
     } else if (firstChar === '1') {
-        if ( !(QUIET.full) ) console.log(`${GREEN}✅ 离开当前连接，用首次命令进入。${NC}`);
-        // Reset command variables to use default command
-        EXEC_COMMAND = "";
-        EXEC_COMMAND_PREFIX = "";
-        EXEC_COMMAND_SUFFIX = "";
-        const newArgs = ['-n', CONTAINER_NAME];
-        process.argv = [process.argv[0], process.argv[1], ...newArgs];
-        await main();
+        if (!(runtime.quiet.full)) console.log(`${GREEN}✅ 离开当前连接，用首次命令进入。${NC}`);
+        runtime.execCommandPrefix = "";
+        runtime.execCommandSuffix = "";
+        runtime.execCommand = defaultCommand;
+        return true;
     } else if (firstChar === 'x') {
         const command = await askQuestion('❔ 输入要执行的命令: ');
-        if ( !(QUIET.cmd || QUIET.full) ) console.log(`${GREEN}✅ 离开当前连接，执行命令。${NC}`);
-        const newArgs = ['-n', CONTAINER_NAME, '-x', command];
-        process.argv = [process.argv[0], process.argv[1], ...newArgs];
-        await main();
+        if (!(runtime.quiet.cmd || runtime.quiet.full)) console.log(`${GREEN}✅ 离开当前连接，执行命令。${NC}`);
+        runtime.execCommandPrefix = "";
+        runtime.execCommandSuffix = "";
+        runtime.execCommand = command;
+        return true;
     } else if (firstChar === 'i') {
-        if ( !(QUIET.full) ) console.log(`${GREEN}✅ 离开当前连接，进入容器交互式SHELL。${NC}`);
-        const newArgs = ['-n', CONTAINER_NAME, '-x', '/bin/bash'];
-        process.argv = [process.argv[0], process.argv[1], ...newArgs];
-        await main();
+        if (!(runtime.quiet.full)) console.log(`${GREEN}✅ 离开当前连接，进入容器交互式SHELL。${NC}`);
+        runtime.execCommandPrefix = "";
+        runtime.execCommandSuffix = "";
+        runtime.execCommand = '/bin/bash';
+        return true;
     } else {
-        console.log(`${GREEN}✅ 已退出连接。容器 ${CONTAINER_NAME} 仍在后台运行。${NC}`);
+        console.log(`${GREEN}✅ 已退出连接。容器 ${runtime.containerName} 仍在后台运行。${NC}`);
+        return false;
     }
 }
 
-// ==============================================================================
-// SECTION: Web Server
-// ==============================================================================
-
-async function runWebServerMode() {
-    ensureWebServerAuthCredentials();
+async function runWebServerMode(runtime) {
+    if (!runtime.serverAuthUser || !runtime.serverAuthPass) {
+        ensureWebServerAuthCredentials();
+        runtime.serverAuthUser = SERVER_AUTH_USER;
+        runtime.serverAuthPass = SERVER_AUTH_PASS;
+        runtime.serverAuthPassAuto = SERVER_AUTH_PASS_AUTO;
+    }
 
     await startWebServer({
-        serverHost: SERVER_HOST,
-        serverPort: SERVER_PORT,
-        authUser: SERVER_AUTH_USER,
-        authPass: SERVER_AUTH_PASS,
-        authPassAuto: SERVER_AUTH_PASS_AUTO,
+        serverHost: runtime.serverHost,
+        serverPort: runtime.serverPort,
+        authUser: runtime.serverAuthUser,
+        authPass: runtime.serverAuthPass,
+        authPassAuto: runtime.serverAuthPassAuto,
         dockerCmd: DOCKER_CMD,
-        hostPath: HOST_PATH,
-        containerPath: CONTAINER_PATH,
-        imageName: IMAGE_NAME,
-        imageVersion: IMAGE_VERSION,
-        execCommandPrefix: EXEC_COMMAND_PREFIX,
-        execCommand: EXEC_COMMAND,
-        execCommandSuffix: EXEC_COMMAND_SUFFIX,
-        contModeArgs: CONT_MODE_ARGS,
-        containerEnvs: CONTAINER_ENVS,
-        containerVolumes: CONTAINER_VOLUMES,
-        validateHostPath,
+        hostPath: runtime.hostPath,
+        containerPath: runtime.containerPath,
+        imageName: runtime.imageName,
+        imageVersion: runtime.imageVersion,
+        execCommandPrefix: runtime.execCommandPrefix,
+        execCommand: runtime.execCommand,
+        execCommandSuffix: runtime.execCommandSuffix,
+        contModeArgs: runtime.contModeArgs,
+        containerEnvs: runtime.containerEnvs,
+        containerVolumes: runtime.containerVolumes,
+        validateHostPath: () => validateHostPath(runtime),
         formatDate,
         isValidContainerName,
         containerExists,
@@ -1997,41 +1290,57 @@ async function runWebServerMode() {
     });
 }
 
-// ==============================================================================
-// Main Function
-// ==============================================================================
-
 async function main() {
     try {
         // 1. Setup commander and parse arguments
         await setupCommander();
+        const runtime = createRuntimeContext();
 
         // 2. Start web server mode
-        if (SERVER_MODE) {
-            await runWebServerMode();
+        if (runtime.serverMode) {
+            await runWebServerMode(runtime);
             return;
         }
 
         // 3. Handle image build operation
         if (IMAGE_BUILD_NEED) {
-            await buildImage(IMAGE_BUILD_ARGS, IMAGE_NAME, IMAGE_VERSION);
+            await buildImage({
+                imageBuildArgs: IMAGE_BUILD_ARGS,
+                imageName: runtime.imageName,
+                imageVersionTag: runtime.imageVersion,
+                imageVersionDefault: IMAGE_VERSION_DEFAULT,
+                imageVersionBase: IMAGE_VERSION_BASE,
+                parseImageVersionTag,
+                manyoyoName: MANYOYO_NAME,
+                yesMode: YES_MODE,
+                dockerCmd: DOCKER_CMD,
+                rootDir: path.join(__dirname, '..'),
+                loadConfig,
+                runCmd,
+                askQuestion,
+                pruneDanglingImages,
+                colors: { RED, GREEN, YELLOW, BLUE, CYAN, NC }
+            });
             process.exit(0);
         }
 
         // 4. Handle remove container operation
-        handleRemoveContainer();
+        if (handleRemoveContainer(runtime)) {
+            return;
+        }
 
         // 5. Validate host path safety
-        validateHostPath();
+        validateHostPath(runtime);
 
         // 6. Setup container (create or connect)
-        const defaultCommand = await setupContainer();
+        const defaultCommand = await setupContainer(runtime);
 
-        // 7. Execute command in container
-        executeInContainer(defaultCommand);
-
-        // 8. Handle post-exit interactions
-        await handlePostExit(defaultCommand);
+        // 7-8. Execute command and handle post-exit interactions
+        let shouldContinue = true;
+        while (shouldContinue) {
+            executeInContainer(runtime, defaultCommand);
+            shouldContinue = await handlePostExit(runtime, defaultCommand);
+        }
 
     } catch (e) {
         console.error(`${RED}Error: ${e.message}${NC}`);