@xcanwin/manyoyo 4.1.4 → 4.1.10

package/lib/web/server.js

@@ -1,12 +1,13 @@
 'use strict';
 
-const { spawnSync, spawn } = require('child_process');
+const { spawn } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
 const http = require('http');
 const WebSocket = require('ws');
+const JSON5 = require('json5');
 const { buildContainerRunArgs } = require('../container-run');
 
 const WEB_HISTORY_MAX_MESSAGES = 500;
@@ -20,6 +21,39 @@ const WEB_TERMINAL_MIN_ROWS = 12;
 const WEB_AUTH_COOKIE_NAME = 'manyoyo_web_auth';
 const WEB_AUTH_TTL_SECONDS = 12 * 60 * 60;
 const FRONTEND_DIR = path.join(__dirname, 'frontend');
+const SAFE_CONTAINER_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
+const IMAGE_VERSION_TAG_PATTERN = /^(\d+\.\d+\.\d+)-([A-Za-z0-9][A-Za-z0-9_.-]*)$/;
+
+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'
+};
+
+const DEFAULT_WEB_CONFIG_TEMPLATE = `{
+    // MANYOYO 全局配置文件（JSON5）
+    "containerName": "my-dev",
+    "hostPath": "/path/to/your/project",
+    "containerPath": "/path/to/your/project",
+    "imageName": "localhost/xcanwin/manyoyo",
+    "imageVersion": "1.7.4-common",
+    "containerMode": "common",
+    "shellPrefix": "",
+    "shell": "",
+    "shellSuffix": "",
+    "yolo": "",
+    "env": {},
+    "envFile": [],
+    "volumes": []
+}
+`;
 
 let XTERM_JS_FILE = null;
 let XTERM_CSS_FILE = null;
@@ -218,6 +252,464 @@ function getWebAuthClearCookie() {
     return `${WEB_AUTH_COOKIE_NAME}=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0`;
 }
 
+function getDefaultWebConfigPath() {
+    return path.join(os.homedir(), '.manyoyo', 'manyoyo.json');
+}
+
+function hasOwn(obj, key) {
+    return Boolean(obj) && Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function toPlainObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return {};
+    }
+    return value;
+}
+
+function pickFirstString() {
+    for (let i = 0; i < arguments.length; i += 1) {
+        const value = arguments[i];
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            if (trimmed) {
+                return trimmed;
+            }
+        }
+    }
+    return '';
+}
+
+function resolveNowTemplate(value, formatDate) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    const nowText = typeof formatDate === 'function' ? formatDate() : '';
+    return value.replace(/\{now\}|\$\{now\}/g, nowText);
+}
+
+function validateContainerNameStrict(containerName) {
+    if (!SAFE_CONTAINER_NAME_PATTERN.test(containerName)) {
+        throw new Error(`containerName 非法: ${containerName}`);
+    }
+}
+
+function validateImageVersionStrict(imageVersion) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(imageVersion)) {
+        throw new Error(`imageVersion 非法: ${imageVersion}`);
+    }
+    if (!IMAGE_VERSION_TAG_PATTERN.test(imageVersion)) {
+        throw new Error(`imageVersion 格式必须为 <x.y.z-后缀>，例如 1.7.4-common。当前值: ${imageVersion}`);
+    }
+}
+
+function validateWebHostPath(hostPath) {
+    if (typeof hostPath !== 'string' || !hostPath.trim()) {
+        throw new Error('hostPath 不能为空');
+    }
+    if (!fs.existsSync(hostPath)) {
+        throw new Error(`宿主机路径不存在: ${hostPath}`);
+    }
+    const realHostPath = fs.realpathSync(hostPath);
+    const homeDir = process.env.HOME || os.homedir() || '/home';
+    if (realHostPath === '/' || realHostPath === '/home' || realHostPath === homeDir) {
+        throw new Error('不允许挂载根目录或home目录。');
+    }
+}
+
+function parseEnvEntry(entryText) {
+    const text = String(entryText || '');
+    const idx = text.indexOf('=');
+    if (idx <= 0) {
+        throw new Error(`env 格式应为 KEY=VALUE: ${text}`);
+    }
+    const key = text.slice(0, idx);
+    const value = text.slice(idx + 1);
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+        throw new Error(`env key 非法: ${key}`);
+    }
+    if (/[\r\n\0]/.test(value) || /[;&|`$<>]/.test(value)) {
+        throw new Error(`env value 含非法字符: ${key}`);
+    }
+    return { key, value };
+}
+
+function normalizeEnvMap(envConfig, sourceLabel) {
+    if (envConfig === undefined || envConfig === null) {
+        return {};
+    }
+    if (typeof envConfig !== 'object' || Array.isArray(envConfig)) {
+        throw new Error(`${sourceLabel} 必须是对象(map)`);
+    }
+    const result = {};
+    for (const [key, rawValue] of Object.entries(envConfig)) {
+        if (rawValue !== null && !['string', 'number', 'boolean'].includes(typeof rawValue)) {
+            throw new Error(`${sourceLabel}.${key} 必须是 string/number/boolean/null`);
+        }
+        const parsed = parseEnvEntry(`${key}=${rawValue === null ? '' : String(rawValue)}`);
+        result[parsed.key] = parsed.value;
+    }
+    return result;
+}
+
+function normalizeStringArray(value, sourceLabel) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`${sourceLabel} 必须是数组`);
+    }
+    return value
+        .map(item => String(item || '').trim())
+        .filter(Boolean);
+}
+
+function parseEnvFileToArgs(filePath) {
+    if (!path.isAbsolute(filePath)) {
+        throw new Error(`envFile 仅支持绝对路径: ${filePath}`);
+    }
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`未找到环境文件: ${filePath}`);
+    }
+
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const args = [];
+    const lines = content.split('\n');
+
+    for (let line of lines) {
+        const match = line.match(/^(?:export\s+)?([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.*)$/);
+        if (!match) {
+            continue;
+        }
+
+        const key = match[1];
+        let value = match[2].trim();
+        if (/[\r\n\0]/.test(value)) continue;
+        if (/[\$\(\)\`\|\&\*\{\};<>]/.test(value)) continue;
+        if (/^\(/.test(value)) continue;
+
+        if (/^"(.*)"$/.test(value)) {
+            value = value.slice(1, -1);
+        } else if (/^'(.*)'$/.test(value)) {
+            value = value.slice(1, -1);
+        }
+        args.push('--env', `${key}=${value}`);
+    }
+
+    return args;
+}
+
+function resolveContainerModeArgs(mode) {
+    const modeAliasMap = {
+        common: 'common',
+        'docker-in-docker': 'dind',
+        dind: 'dind',
+        d: 'dind',
+        'mount-docker-socket': 'sock',
+        sock: 'sock',
+        s: 'sock'
+    };
+    const normalized = modeAliasMap[String(mode || '').trim().toLowerCase()];
+    if (!normalized) {
+        throw new Error(`未知 containerMode: ${mode}`);
+    }
+    if (normalized === 'common') {
+        return { mode: 'common', args: [] };
+    }
+    if (normalized === 'dind') {
+        return { mode: 'dind', args: ['--privileged'] };
+    }
+    return {
+        mode: 'sock',
+        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'
+        ]
+    };
+}
+
+function resolveYoloCommand(yolo) {
+    const key = String(yolo || '').trim().toLowerCase();
+    if (!key) {
+        return '';
+    }
+    const mapped = YOLO_COMMAND_MAP[key];
+    if (!mapped) {
+        throw new Error(`未知 yolo 值: ${yolo}`);
+    }
+    return mapped;
+}
+
+function buildDefaultCommand(shellPrefix, shell, shellSuffix) {
+    const parts = [];
+    if (shellPrefix && String(shellPrefix).trim()) {
+        parts.push(String(shellPrefix).trim());
+    }
+    if (shell && String(shell).trim()) {
+        parts.push(String(shell).trim());
+    }
+    if (shellSuffix && String(shellSuffix).trim()) {
+        parts.push(String(shellSuffix).trim());
+    }
+    return parts.join(' ').trim();
+}
+
+function validateWebConfigShape(configObject) {
+    const config = toPlainObject(configObject);
+
+    if (hasOwn(config, 'containerName') && String(config.containerName || '').trim()) {
+        validateContainerNameStrict(resolveNowTemplate(String(config.containerName), () => '0101-0000'));
+    }
+    if (hasOwn(config, 'imageVersion') && String(config.imageVersion || '').trim()) {
+        validateImageVersionStrict(String(config.imageVersion).trim());
+    }
+    if (hasOwn(config, 'env')) {
+        normalizeEnvMap(config.env, 'env');
+    }
+    if (hasOwn(config, 'envFile')) {
+        normalizeStringArray(config.envFile, 'envFile');
+    }
+    if (hasOwn(config, 'volumes')) {
+        normalizeStringArray(config.volumes, 'volumes');
+    }
+    if (hasOwn(config, 'runs')) {
+        const runs = config.runs;
+        if (runs !== undefined && (typeof runs !== 'object' || runs === null || Array.isArray(runs))) {
+            throw new Error('runs 必须是对象(map)');
+        }
+    }
+}
+
+function readWebConfigSnapshot(configPath) {
+    const resolvedPath = path.resolve(configPath || getDefaultWebConfigPath());
+    if (!fs.existsSync(resolvedPath)) {
+        return {
+            path: resolvedPath,
+            raw: DEFAULT_WEB_CONFIG_TEMPLATE,
+            parsed: {},
+            parseError: null,
+            exists: false
+        };
+    }
+
+    const raw = fs.readFileSync(resolvedPath, 'utf-8');
+    if (!String(raw || '').trim()) {
+        return {
+            path: resolvedPath,
+            raw,
+            parsed: {},
+            parseError: null,
+            exists: true
+        };
+    }
+
+    try {
+        const parsed = JSON5.parse(raw);
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+            throw new Error('配置根节点必须是对象(map)');
+        }
+        const config = toPlainObject(parsed);
+        validateWebConfigShape(config);
+        return {
+            path: resolvedPath,
+            raw,
+            parsed: config,
+            parseError: null,
+            exists: true
+        };
+    } catch (e) {
+        return {
+            path: resolvedPath,
+            raw,
+            parsed: {},
+            parseError: e && e.message ? e.message : '配置解析失败',
+            exists: true
+        };
+    }
+}
+
+function parseAndValidateConfigRaw(raw) {
+    const parsed = JSON5.parse(String(raw || ''));
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error('配置根节点必须是对象(map)');
+    }
+    const config = toPlainObject(parsed);
+    validateWebConfigShape(config);
+    return config;
+}
+
+function buildConfigDefaults(ctx, config) {
+    const parsed = toPlainObject(config);
+    const defaults = {
+        containerName: hasOwn(parsed, 'containerName') ? String(parsed.containerName || '') : '',
+        hostPath: pickFirstString(parsed.hostPath, ctx.hostPath),
+        containerPath: pickFirstString(parsed.containerPath, ctx.containerPath),
+        imageName: pickFirstString(parsed.imageName, ctx.imageName),
+        imageVersion: pickFirstString(parsed.imageVersion, ctx.imageVersion),
+        containerMode: hasOwn(parsed, 'containerMode') ? String(parsed.containerMode || '') : '',
+        shellPrefix: hasOwn(parsed, 'shellPrefix') ? String(parsed.shellPrefix || '') : '',
+        shell: hasOwn(parsed, 'shell') ? String(parsed.shell || '') : '',
+        shellSuffix: hasOwn(parsed, 'shellSuffix') ? String(parsed.shellSuffix || '') : '',
+        yolo: hasOwn(parsed, 'yolo') ? String(parsed.yolo || '') : '',
+        env: {},
+        envFile: [],
+        volumes: []
+    };
+
+    try {
+        defaults.env = normalizeEnvMap(parsed.env, 'env');
+    } catch (e) {
+        defaults.env = {};
+    }
+    try {
+        defaults.envFile = normalizeStringArray(parsed.envFile, 'envFile');
+    } catch (e) {
+        defaults.envFile = [];
+    }
+    try {
+        defaults.volumes = normalizeStringArray(parsed.volumes, 'volumes');
+    } catch (e) {
+        defaults.volumes = [];
+    }
+
+    return defaults;
+}
+
+function buildStaticContainerRuntime(ctx, containerName) {
+    return {
+        containerName,
+        hostPath: ctx.hostPath,
+        containerPath: ctx.containerPath,
+        imageName: ctx.imageName,
+        imageVersion: ctx.imageVersion,
+        contModeArgs: Array.isArray(ctx.contModeArgs) ? ctx.contModeArgs.slice() : [],
+        containerEnvs: Array.isArray(ctx.containerEnvs) ? ctx.containerEnvs.slice() : [],
+        containerVolumes: Array.isArray(ctx.containerVolumes) ? ctx.containerVolumes.slice() : [],
+        defaultCommand: buildDefaultCommand(ctx.execCommandPrefix, ctx.execCommand, ctx.execCommandSuffix) || '/bin/bash'
+    };
+}
+
+function buildCreateRuntime(ctx, state, payload) {
+    const body = toPlainObject(payload);
+    const requestOptions = toPlainObject(body.createOptions);
+    const snapshot = readWebConfigSnapshot(state.webConfigPath);
+    const config = snapshot.parseError ? {} : snapshot.parsed;
+
+    const hasRequestEnv = hasOwn(requestOptions, 'env');
+    const hasRequestEnvFile = hasOwn(requestOptions, 'envFile');
+    const hasRequestVolumes = hasOwn(requestOptions, 'volumes');
+    const hasConfigEnv = hasOwn(config, 'env');
+    const hasConfigEnvFile = hasOwn(config, 'envFile');
+    const hasConfigVolumes = hasOwn(config, 'volumes');
+
+    const requestName = pickFirstString(requestOptions.containerName, body.name);
+    let containerName = pickFirstString(requestName, config.containerName);
+    if (!containerName) {
+        containerName = `my-${ctx.formatDate()}`;
+    }
+    containerName = resolveNowTemplate(containerName, ctx.formatDate);
+    validateContainerNameStrict(containerName);
+
+    const hostPath = pickFirstString(requestOptions.hostPath, config.hostPath, ctx.hostPath);
+    validateWebHostPath(hostPath);
+
+    const containerPath = pickFirstString(requestOptions.containerPath, config.containerPath, ctx.containerPath, hostPath) || hostPath;
+    const imageName = pickFirstString(requestOptions.imageName, config.imageName, ctx.imageName);
+    const imageVersion = pickFirstString(requestOptions.imageVersion, config.imageVersion, ctx.imageVersion);
+
+    if (!/^[A-Za-z0-9][A-Za-z0-9._/:-]*$/.test(imageName)) {
+        throw new Error(`imageName 非法: ${imageName}`);
+    }
+    validateImageVersionStrict(imageVersion);
+
+    let contModeArgs = Array.isArray(ctx.contModeArgs) ? ctx.contModeArgs.slice() : [];
+    let containerMode = '';
+    const modeValue = pickFirstString(requestOptions.containerMode, config.containerMode);
+    if (modeValue) {
+        const mode = resolveContainerModeArgs(modeValue);
+        containerMode = mode.mode;
+        contModeArgs = mode.args;
+    }
+
+    const shellPrefix = hasOwn(requestOptions, 'shellPrefix')
+        ? String(requestOptions.shellPrefix || '')
+        : (hasOwn(config, 'shellPrefix') ? String(config.shellPrefix || '') : String(ctx.execCommandPrefix || ''));
+    let shell = hasOwn(requestOptions, 'shell')
+        ? String(requestOptions.shell || '')
+        : (hasOwn(config, 'shell') ? String(config.shell || '') : String(ctx.execCommand || ''));
+    const shellSuffix = hasOwn(requestOptions, 'shellSuffix')
+        ? String(requestOptions.shellSuffix || '')
+        : (hasOwn(config, 'shellSuffix') ? String(config.shellSuffix || '') : String(ctx.execCommandSuffix || ''));
+    const yolo = hasOwn(requestOptions, 'yolo')
+        ? String(requestOptions.yolo || '')
+        : (hasOwn(config, 'yolo') ? String(config.yolo || '') : '');
+    const yoloCommand = resolveYoloCommand(yolo);
+    if (yoloCommand) {
+        shell = yoloCommand;
+    }
+
+    let containerEnvs = Array.isArray(ctx.containerEnvs) ? ctx.containerEnvs.slice() : [];
+    if (hasRequestEnv || hasRequestEnvFile || hasConfigEnv || hasConfigEnvFile) {
+        const configEnv = normalizeEnvMap(config.env, 'config.env');
+        const requestEnv = hasRequestEnv ? normalizeEnvMap(requestOptions.env, 'createOptions.env') : {};
+        const mergedEnv = { ...configEnv, ...requestEnv };
+        const envArgs = [];
+        Object.entries(mergedEnv).forEach(([key, value]) => {
+            const parsed = parseEnvEntry(`${key}=${value}`);
+            envArgs.push('--env', `${parsed.key}=${parsed.value}`);
+        });
+
+        const envFileList = hasRequestEnvFile
+            ? normalizeStringArray(requestOptions.envFile, 'createOptions.envFile')
+            : normalizeStringArray(config.envFile, 'config.envFile');
+        const envFileArgs = [];
+        envFileList.forEach(filePath => {
+            envFileArgs.push(...parseEnvFileToArgs(filePath));
+        });
+
+        containerEnvs = [...envArgs, ...envFileArgs];
+    }
+
+    let containerVolumes = Array.isArray(ctx.containerVolumes) ? ctx.containerVolumes.slice() : [];
+    if (hasRequestVolumes || hasConfigVolumes) {
+        const volumeList = hasRequestVolumes
+            ? normalizeStringArray(requestOptions.volumes, 'createOptions.volumes')
+            : normalizeStringArray(config.volumes, 'config.volumes');
+        containerVolumes = [];
+        volumeList.forEach(volume => {
+            containerVolumes.push('--volume', volume);
+        });
+    }
+
+    return {
+        containerName,
+        hostPath,
+        containerPath,
+        imageName,
+        imageVersion,
+        contModeArgs,
+        containerEnvs,
+        containerVolumes,
+        defaultCommand: buildDefaultCommand(shellPrefix, shell, shellSuffix) || '/bin/bash',
+        applied: {
+            containerName,
+            hostPath,
+            containerPath,
+            imageName,
+            imageVersion,
+            containerMode,
+            shellPrefix: shellPrefix || '',
+            shell: shell || '',
+            shellSuffix: shellSuffix || '',
+            yolo: yolo || '',
+            envCount: Math.floor(containerEnvs.length / 2),
+            volumeCount: Math.floor(containerVolumes.length / 2)
+        }
+    };
+}
+
 function listWebManyoyoContainers(ctx) {
     const output = ctx.dockerExecArgs(
         ['ps', '-a', '--filter', 'label=manyoyo.default_cmd', '--format', '{{.Names}}\t{{.Status}}\t{{.Image}}'],
@@ -244,19 +736,26 @@ function listWebManyoyoContainers(ctx) {
     return map;
 }
 
-async function ensureWebContainer(ctx, state, containerName) {
-    if (!ctx.containerExists(containerName)) {
-        const webDefaultCommand = `${ctx.execCommandPrefix}${ctx.execCommand}${ctx.execCommandSuffix}`.trim() || '/bin/bash';
+async function ensureWebContainer(ctx, state, containerInput) {
+    const runtime = typeof containerInput === 'string'
+        ? buildStaticContainerRuntime(ctx, containerInput)
+        : containerInput;
+
+    if (!runtime || !runtime.containerName) {
+        throw new Error('containerName 不能为空');
+    }
+
+    if (!ctx.containerExists(runtime.containerName)) {
         const args = buildContainerRunArgs({
-            containerName,
-            hostPath: ctx.hostPath,
-            containerPath: ctx.containerPath,
-            imageName: ctx.imageName,
-            imageVersion: ctx.imageVersion,
-            contModeArgs: ctx.contModeArgs,
-            containerEnvs: ctx.containerEnvs,
-            containerVolumes: ctx.containerVolumes,
-            defaultCommand: webDefaultCommand
+            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.defaultCommand
         });
 
         try {
@@ -266,33 +765,58 @@ async function ensureWebContainer(ctx, state, containerName) {
             throw e;
         }
 
-        await ctx.waitForContainerReady(containerName);
-        appendWebSessionMessage(state.webHistoryDir, containerName, 'system', `容器 ${containerName} 已创建并启动。`);
+        await ctx.waitForContainerReady(runtime.containerName);
+        appendWebSessionMessage(state.webHistoryDir, runtime.containerName, 'system', `容器 ${runtime.containerName} 已创建并启动。`);
         return;
     }
 
-    const status = ctx.getContainerStatus(containerName);
+    const status = ctx.getContainerStatus(runtime.containerName);
     if (status !== 'running') {
-        ctx.dockerExecArgs(['start', containerName], { stdio: 'pipe' });
-        appendWebSessionMessage(state.webHistoryDir, containerName, 'system', `容器 ${containerName} 已启动。`);
+        ctx.dockerExecArgs(['start', runtime.containerName], { stdio: 'pipe' });
+        appendWebSessionMessage(state.webHistoryDir, runtime.containerName, 'system', `容器 ${runtime.containerName} 已启动。`);
     }
 }
 
-function execCommandInWebContainer(ctx, containerName, command) {
-    const result = spawnSync(ctx.dockerCmd, ['exec', containerName, '/bin/bash', '-lc', command], {
-        encoding: 'utf-8',
-        maxBuffer: 32 * 1024 * 1024
-    });
+async function execCommandInWebContainer(ctx, containerName, command) {
+    return await new Promise((resolve, reject) => {
+        const process = spawn(
+            ctx.dockerCmd,
+            ['exec', containerName, '/bin/bash', '-lc', command],
+            { stdio: ['ignore', 'pipe', 'pipe'] }
+        );
 
-    if (result.error) {
-        throw result.error;
-    }
+        const MAX_RAW_OUTPUT_CHARS = 32 * 1024 * 1024;
+        let rawOutput = '';
+        let outputTruncated = false;
+
+        function appendChunk(chunk) {
+            if (!chunk) return;
+            const text = chunk.toString('utf-8');
+            if (!text) return;
+            if (rawOutput.length >= MAX_RAW_OUTPUT_CHARS) {
+                outputTruncated = true;
+                return;
+            }
+            const remain = MAX_RAW_OUTPUT_CHARS - rawOutput.length;
+            if (text.length > remain) {
+                rawOutput += text.slice(0, remain);
+                outputTruncated = true;
+                return;
+            }
+            rawOutput += text;
+        }
 
-    const exitCode = typeof result.status === 'number' ? result.status : 1;
-    const rawOutput = `${result.stdout || ''}${result.stderr || ''}`;
-    const output = clipText(stripAnsi(rawOutput).trim() || '(无输出)');
+        process.stdout.on('data', appendChunk);
+        process.stderr.on('data', appendChunk);
 
-    return { exitCode, output };
+        process.on('error', reject);
+        process.on('close', code => {
+            const exitCode = typeof code === 'number' ? code : 1;
+            const clippedRaw = outputTruncated ? `${rawOutput}\n...[raw-truncated]` : rawOutput;
+            const output = clipText(stripAnsi(clippedRaw).trim() || '(无输出)');
+            resolve({ exitCode, output });
+        });
+    });
 }
 
 function readRequestBody(req) {
@@ -694,6 +1218,51 @@ function sendWebUnauthorized(res, pathname) {
 
 async function handleWebApi(req, res, pathname, ctx, state) {
     const routes = [
+        {
+            method: 'GET',
+            match: currentPath => currentPath === '/api/config' ? [] : null,
+            handler: async () => {
+                const snapshot = readWebConfigSnapshot(state.webConfigPath);
+                const defaults = buildConfigDefaults(ctx, snapshot.parseError ? {} : snapshot.parsed);
+                sendJson(res, 200, {
+                    path: snapshot.path,
+                    raw: snapshot.raw,
+                    parsed: snapshot.parseError ? null : snapshot.parsed,
+                    parseError: snapshot.parseError,
+                    defaults
+                });
+            }
+        },
+        {
+            method: 'PUT',
+            match: currentPath => currentPath === '/api/config' ? [] : null,
+            handler: async () => {
+                const payload = await readJsonBody(req);
+                const raw = typeof payload.raw === 'string' ? payload.raw : '';
+                if (!raw.trim()) {
+                    sendJson(res, 400, { error: '配置内容不能为空' });
+                    return;
+                }
+
+                let parsed = null;
+                try {
+                    parsed = parseAndValidateConfigRaw(raw);
+                } catch (e) {
+                    sendJson(res, 400, { error: '配置格式错误', detail: e.message || '解析失败' });
+                    return;
+                }
+
+                const savePath = path.resolve(state.webConfigPath);
+                fs.mkdirSync(path.dirname(savePath), { recursive: true });
+                fs.writeFileSync(savePath, raw, 'utf-8');
+
+                sendJson(res, 200, {
+                    saved: true,
+                    path: savePath,
+                    defaults: buildConfigDefaults(ctx, parsed)
+                });
+            }
+        },
         {
             method: 'GET',
             match: currentPath => currentPath === '/api/sessions' ? [] : null,
@@ -720,17 +1289,16 @@ async function handleWebApi(req, res, pathname, ctx, state) {
             match: currentPath => currentPath === '/api/sessions' ? [] : null,
             handler: async () => {
                 const payload = await readJsonBody(req);
-                let containerName = (payload.name || '').trim();
-                if (!containerName) {
-                    containerName = `my-${ctx.formatDate()}`;
-                }
-                if (!ctx.isValidContainerName(containerName)) {
-                    sendJson(res, 400, { error: `containerName 非法: ${containerName}` });
+                let runtime = null;
+                try {
+                    runtime = buildCreateRuntime(ctx, state, payload);
+                } catch (e) {
+                    sendJson(res, 400, { error: e.message || '创建参数错误' });
                     return;
                 }
 
-                await ensureWebContainer(ctx, state, containerName);
-                sendJson(res, 200, { name: containerName });
+                await ensureWebContainer(ctx, state, runtime);
+                sendJson(res, 200, { name: runtime.containerName, applied: runtime.applied });
             }
         },
         {
@@ -763,12 +1331,12 @@ async function handleWebApi(req, res, pathname, ctx, state) {
 
                 await ensureWebContainer(ctx, state, containerName);
                 appendWebSessionMessage(state.webHistoryDir, containerName, 'user', command);
-                const result = execCommandInWebContainer(ctx, containerName, command);
+                const result = await execCommandInWebContainer(ctx, containerName, command);
                 appendWebSessionMessage(
                     state.webHistoryDir,
                     containerName,
                     'assistant',
-                    `${result.output}\n\n[exit ${result.exitCode}]`,
+                    result.output,
                     { exitCode: result.exitCode }
                 );
                 sendJson(res, 200, { exitCode: result.exitCode, output: result.output });
@@ -862,6 +1430,7 @@ async function startWebServer(options) {
 
     const state = {
         webHistoryDir: options.webHistoryDir || path.join(os.homedir(), '.manyoyo', 'web-history'),
+        webConfigPath: options.webConfigPath || getDefaultWebConfigPath(),
         authSessions: new Map(),
         terminalSessions: new Map()
     };