@xcanwin/manyoyo 6.0.5 → 6.1.3

package/bin/manyoyo.js

@@ -14,6 +14,9 @@ const { getManyoyoConfigPath, readManyoyoConfig, syncGlobalImageVersion } = requ
 const { initAgentConfigs } = require('../lib/init-config');
 const { buildImage } = require('../lib/image-build');
 const { resolveAgentResumeArg, buildAgentResumeCommand } = require('../lib/agent-resume');
+const { resolveYoloCommand } = require('../lib/agent-adapters');
+const { runDoctorChecks } = require('../lib/doctor');
+const { resolveContainerMode } = require('../lib/container-modes');
 const { runPluginCommand, createPlugin } = require('../lib/plugin');
 const { buildManyoyoLogPath } = require('../lib/log-path');
 const { resolveRuntimeConfig } = require('../lib/runtime-resolver');
@@ -635,27 +638,13 @@ 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) {
-    const key = String(cli || '').trim().toLowerCase();
-    const mappedCommand = YOLO_COMMAND_MAP[key];
-    if (!mappedCommand) {
+    try {
+        EXEC_COMMAND = resolveYoloCommand(cli);
+    } catch (error) {
         console.log(`${RED}⚠️  未知LLM CLI: ${cli}${NC}`);
         process.exit(0);
     }
-    EXEC_COMMAND = mappedCommand;
 }
 
 /**
@@ -663,41 +652,21 @@ function setYolo(cli) {
  * @param {string} mode - 模式名称 (common, dind, sock)
  */
 function setContMode(mode) {
-    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;
+    let resolved;
+    try {
+        resolved = resolveContainerMode(mode);
+    } catch (error) {
+        console.log(`${RED}⚠️  未知模式: ${mode}${NC}`);
+        process.exit(0);
     }
 
-    if (normalizedMode === 'dind') {
-        CONT_MODE_ARGS = ['--privileged'];
-        console.log(`${GREEN}✅ 开启安全的容器嵌套容器模式, 手动在容器内启动服务: nohup dockerd &${NC}`);
-        return;
-    }
+    CONT_MODE_ARGS = resolved.args;
 
-    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'
-        ];
+    if (resolved.mode === 'dind') {
+        console.log(`${GREEN}✅ 开启安全的容器嵌套容器模式, 手动在容器内启动服务: nohup dockerd &${NC}`);
+    } else if (resolved.mode === 'sock') {
         console.log(`${RED}⚠️  开启危险的容器嵌套容器模式, 危害: 容器可访问宿主机文件${NC}`);
-        return;
     }
-
-    console.log(`${RED}⚠️  未知模式: ${mode}${NC}`);
-    process.exit(0);
 }
 
 function showImagePullHint(err) {
@@ -757,6 +726,14 @@ function runCmd(cmd, args, options = {}) {
     return result.stdout || '';
 }
 
+function checkPortAvailability(port) {
+    return new Promise(resolve => {
+        const server = net.createServer();
+        server.once('error', () => resolve('occupied'));
+        server.listen(port, '127.0.0.1', () => server.close(() => resolve('available')));
+    });
+}
+
 function dockerExecArgs(args, options = {}) {
     try {
         return runCmd(DOCKER_CMD, args, options);
@@ -1288,6 +1265,13 @@ Notes:
         .option('--yes', '所有提示自动确认 (用于CI/脚本)')
         .action((agents, options) => selectAction('init', { ...options, initConfig: agents === undefined ? 'all' : agents }));
 
+    program.command('doctor')
+        .description('诊断容器运行时、镜像、配置、Agent、模式、插件和端口')
+        .option('-r, --run <name>', '加载运行配置 (从 ~/.manyoyo/manyoyo.json 的 runs.<name> 读取)')
+        .option('--port <port>', '检查指定监听端口')
+        .option('--json', '以 JSON 输出稳定诊断结果')
+        .action(options => selectAction('doctor', { ...options, doctor: true }));
+
     program.command('update')
         .description('更新 MANYOYO（若检测为本地 file 安装则跳过）')
         .action(() => selectAction('update', { update: true }));
@@ -1334,6 +1318,7 @@ Notes:
     const isPruneMode = selectedAction === 'prune';
     const isShowConfigMode = selectedAction === 'config-show';
     const isShowCommandMode = selectedAction === 'config-command';
+    const isDoctorMode = selectedAction === 'doctor';
     const isServerMode = options.server !== undefined;
     const isServerStopMode = Boolean(selectedAction === 'serve' && options.stop);
     const isServerRestartMode = Boolean(selectedAction === 'serve' && options.restart);
@@ -1342,7 +1327,7 @@ Notes:
         throw new Error('serve --stop 与 --restart 不能同时使用');
     }
 
-    const noDockerActions = new Set(['init', 'update', 'install', 'config-show', 'plugin']);
+    const noDockerActions = new Set(['init', 'update', 'install', 'config-show', 'plugin', 'doctor']);
     if (isServerStopMode) {
         noDockerActions.add('serve');
     }
@@ -1528,6 +1513,31 @@ Notes:
         process.exit(0);
     }
 
+    if (isDoctorMode) {
+        const parsedPort = options.port === undefined ? null : Number(options.port);
+        const portStatus = Number.isInteger(parsedPort) && parsedPort > 0 && parsedPort <= 65535
+            ? await checkPortAvailability(parsedPort)
+            : undefined;
+        const report = runDoctorChecks({
+            runCommand: runCmd,
+            configExists: fs.existsSync(getManyoyoConfigPath()),
+            imageName: IMAGE_NAME,
+            imageVersion: IMAGE_VERSION,
+            agentCommand: EXEC_COMMAND,
+            containerMode: contModeValue || 'common',
+            pluginConfig: config.plugins,
+            portStatus
+        });
+        if (options.json) {
+            console.log(JSON.stringify(report, null, 4));
+        } else {
+            report.checks.forEach(check => {
+                console.log(`[${check.status.toUpperCase()}] ${check.code}: ${check.summary}${check.action ? ` (${check.action})` : ''}`);
+            });
+        }
+        process.exit(report.ok ? 0 : 1);
+    }
+
     if (isPsMode) { getContList(); process.exit(0); }
     if (isImagesMode) { getImageList(); process.exit(0); }
     if (isPruneMode) { pruneDanglingImages(); process.exit(0); }

package/lib/agent-adapters/index.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const AGENT_ADAPTERS = {
+    claude: {
+        id: 'claude',
+        aliases: ['claude', 'cc', 'c'],
+        yoloCommand: 'IS_SANDBOX=1 claude --dangerously-skip-permissions'
+    },
+    gemini: {
+        id: 'gemini',
+        aliases: ['gemini', 'gm', 'g'],
+        yoloCommand: 'gemini --yolo'
+    },
+    codex: {
+        id: 'codex',
+        aliases: ['codex', 'cx'],
+        yoloCommand: 'codex --dangerously-bypass-approvals-and-sandbox'
+    },
+    opencode: {
+        id: 'opencode',
+        aliases: ['opencode', 'oc'],
+        yoloCommand: 'OPENCODE_PERMISSION=\'{"*":"allow"}\' opencode'
+    }
+};
+
+function findAdapterByAlias(value) {
+    const key = String(value || '').trim().toLowerCase();
+    if (!key) return null;
+    return Object.values(AGENT_ADAPTERS).find(adapter => adapter.aliases.includes(key)) || null;
+}
+
+function resolveYoloCommand(yolo) {
+    const key = String(yolo || '').trim();
+    if (!key) {
+        return '';
+    }
+    const adapter = findAdapterByAlias(key);
+    if (!adapter) {
+        throw new Error(`未知 yolo 值: ${yolo}`);
+    }
+    return adapter.yoloCommand;
+}
+
+module.exports = {
+    AGENT_ADAPTERS,
+    resolveYoloCommand
+};

package/lib/container-modes.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const CONTAINER_MODE_ALIASES = {
+    common: 'common',
+    'docker-in-docker': 'dind',
+    dind: 'dind',
+    d: 'dind',
+    'mount-docker-socket': 'sock',
+    sock: 'sock',
+    s: 'sock'
+};
+
+const CONTAINER_MODE_ARGS = {
+    common: [],
+    dind: ['--privileged'],
+    sock: [
+        '--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 resolveContainerMode(mode) {
+    const normalizedMode = CONTAINER_MODE_ALIASES[String(mode || '').trim().toLowerCase()];
+    if (!normalizedMode) {
+        throw new Error(`未知 containerMode: ${mode}`);
+    }
+    return {
+        mode: normalizedMode,
+        args: CONTAINER_MODE_ARGS[normalizedMode].slice()
+    };
+}
+
+module.exports = {
+    resolveContainerMode
+};

package/lib/core/app-error.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const crypto = require('crypto');
+
+class AppError extends Error {
+    constructor(options = {}) {
+        const summary = String(options.summary || '服务暂时不可用');
+        super(summary);
+        this.name = 'AppError';
+        this.code = String(options.code || 'INTERNAL_ERROR');
+        this.summary = summary;
+        this.detail = typeof options.detail === 'string' ? options.detail : '';
+        this.retryable = options.retryable === true;
+        this.action = typeof options.action === 'string' ? options.action : '';
+        this.correlationId = String(options.correlationId || crypto.randomUUID());
+        this.statusCode = Number.isInteger(options.statusCode) ? options.statusCode : 500;
+    }
+}
+
+function toAppError(error) {
+    if (error instanceof AppError) {
+        return error;
+    }
+    return new AppError({
+        code: 'INTERNAL_ERROR',
+        summary: '服务暂时不可用',
+        retryable: true,
+        action: '请稍后重试',
+        statusCode: 500
+    });
+}
+
+function toErrorPayload(error) {
+    const appError = toAppError(error);
+    return {
+        error: {
+            code: appError.code,
+            summary: appError.summary,
+            detail: appError.detail,
+            retryable: appError.retryable,
+            action: appError.action,
+            correlationId: appError.correlationId
+        }
+    };
+}
+
+function toHttpAppError(statusCode, payload = {}) {
+    if (payload.error instanceof AppError) {
+        return payload.error;
+    }
+
+    const message = typeof payload.error === 'string' ? payload.error : '';
+    const definitions = {
+        400: ['INVALID_REQUEST', message || '请求参数错误', false],
+        401: ['UNAUTHORIZED', message === 'UNAUTHORIZED' ? '未登录或登录已过期' : (message || '未登录或登录已过期'), false],
+        403: ['FORBIDDEN', message || '没有执行此操作的权限', false],
+        404: ['NOT_FOUND', message || '请求的资源不存在', false],
+        409: ['CONFLICT', message || '请求与当前状态冲突', false],
+        429: ['RATE_LIMITED', message || '请求过于频繁，请稍后重试', true]
+    };
+    const definition = definitions[statusCode];
+    if (definition) {
+        return new AppError({
+            code: definition[0],
+            summary: definition[1],
+            detail: typeof payload.detail === 'string' ? payload.detail : '',
+            retryable: definition[2],
+            action: definition[2] ? '请稍后重试' : '',
+            statusCode
+        });
+    }
+
+    return toAppError(payload.error instanceof Error ? payload.error : new Error(message));
+}
+
+module.exports = {
+    AppError,
+    toAppError,
+    toErrorPayload,
+    toHttpAppError
+};

package/lib/core/event-store.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const {
+    validateControlEvent,
+    selectEventsAfterCursor,
+    projectSessionEvents
+} = require('./events');
+
+function getAggregateFileName(aggregateId) {
+    return encodeURIComponent(String(aggregateId || '').trim());
+}
+
+class FileEventStore {
+    constructor(rootDir) {
+        this.rootDir = path.resolve(rootDir);
+        this.eventsDir = path.join(this.rootDir, 'events');
+        this.projectionsDir = path.join(this.rootDir, 'projections');
+    }
+
+    getEventFilePath(aggregateId) {
+        return path.join(this.eventsDir, `${getAggregateFileName(aggregateId)}.jsonl`);
+    }
+
+    getProjectionFilePath(aggregateId) {
+        return path.join(this.projectionsDir, `${getAggregateFileName(aggregateId)}.json`);
+    }
+
+    read(aggregateId) {
+        const normalizedAggregateId = String(aggregateId || '').trim();
+        const filePath = this.getEventFilePath(normalizedAggregateId);
+        if (!fs.existsSync(filePath)) {
+            return [];
+        }
+
+        const lines = fs.readFileSync(filePath, 'utf-8').split('\n');
+        const events = [];
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index].trim();
+            if (!line) continue;
+            try {
+                const event = JSON.parse(line);
+                validateControlEvent(event);
+                if (event.aggregateId !== normalizedAggregateId) {
+                    throw new Error('事件 aggregateId 与日志不一致');
+                }
+                events.push(event);
+            } catch (error) {
+                const isFinalLine = index === lines.length - 1;
+                if (isFinalLine) {
+                    break;
+                }
+                throw error;
+            }
+        }
+        selectEventsAfterCursor(events, 0);
+        return events;
+    }
+
+    append(event) {
+        validateControlEvent(event);
+        const events = this.read(event.aggregateId);
+        const expectedSeq = events.length ? events[events.length - 1].seq + 1 : event.seq;
+        if (event.seq !== expectedSeq) {
+            throw new Error(`seq 必须连续递增，期望 ${expectedSeq}，实际 ${event.seq}`);
+        }
+
+        fs.mkdirSync(this.eventsDir, { recursive: true });
+        fs.appendFileSync(this.getEventFilePath(event.aggregateId), `${JSON.stringify(event)}\n`);
+        const projection = projectSessionEvents([...events, event]);
+        this.saveProjection(event.aggregateId, projection);
+        return event;
+    }
+
+    loadProjection(aggregateId) {
+        const events = this.read(aggregateId);
+        const projection = projectSessionEvents(events);
+        const projectionPath = this.getProjectionFilePath(aggregateId);
+        if (!fs.existsSync(projectionPath)) {
+            return projection;
+        }
+        try {
+            const saved = JSON.parse(fs.readFileSync(projectionPath, 'utf-8'));
+            if (saved && saved.aggregateId === projection.aggregateId && saved.lastSeq === projection.lastSeq) {
+                return saved;
+            }
+        } catch (error) {
+            // 以事件日志为准重建损坏的投影快照。
+        }
+        this.saveProjection(aggregateId, projection);
+        return projection;
+    }
+
+    saveProjection(aggregateId, projection) {
+        fs.mkdirSync(this.projectionsDir, { recursive: true });
+        const targetPath = this.getProjectionFilePath(aggregateId);
+        const temporaryPath = `${targetPath}.${process.pid}.tmp`;
+        fs.writeFileSync(temporaryPath, `${JSON.stringify(projection)}\n`);
+        fs.renameSync(temporaryPath, targetPath);
+    }
+}
+
+module.exports = {
+    FileEventStore
+};

package/lib/core/events.js

@@ -0,0 +1,149 @@
+'use strict';
+
+const crypto = require('crypto');
+
+const EVENT_VERSION = 1;
+const EVENT_TYPES = new Set([
+    'session.created',
+    'session.ready',
+    'session.stopping',
+    'session.stopped',
+    'session.failed',
+    'process.started',
+    'process.stdout',
+    'process.stderr',
+    'process.exited',
+    'process.interrupted',
+    'agent.turn.started',
+    'agent.turn.delta',
+    'agent.message.completed',
+    'agent.turn.failed',
+    'agent.tool.observed',
+    'agent.child.observed',
+    'agent.child.completed',
+    'agent.child.failed',
+    'agent.child.interrupted',
+    'artifact.created',
+    'artifact.changed',
+    'artifact.deleted',
+    'terminal.opened',
+    'terminal.resized',
+    'terminal.closed'
+]);
+
+function createControlEvent(input = {}) {
+    const aggregateId = String(input.aggregateId || input.sessionId || '').trim();
+    const event = {
+        id: input.id || crypto.randomUUID(),
+        type: input.type,
+        version: input.version === undefined ? EVENT_VERSION : input.version,
+        aggregateId,
+        sessionId: input.sessionId || aggregateId,
+        seq: input.seq,
+        timestamp: input.timestamp || new Date().toISOString(),
+        data: input.data || {}
+    };
+    return validateControlEvent(event);
+}
+
+function validateControlEvent(event) {
+    if (!event || typeof event !== 'object') {
+        throw new Error('事件必须为对象');
+    }
+    if (!EVENT_TYPES.has(event.type)) {
+        throw new Error(`未知事件类型: ${event.type}`);
+    }
+    if (event.version !== EVENT_VERSION) {
+        throw new Error(`不支持的事件版本: ${event.version}`);
+    }
+    if (!String(event.id || '').trim()) {
+        throw new Error('事件 id 不能为空');
+    }
+    if (!String(event.aggregateId || '').trim()) {
+        throw new Error('aggregateId 不能为空');
+    }
+    if (!Number.isInteger(event.seq) || event.seq <= 0) {
+        throw new Error('seq 必须为正整数');
+    }
+    if (!String(event.timestamp || '').trim()) {
+        throw new Error('timestamp 不能为空');
+    }
+    if (!event.data || typeof event.data !== 'object' || Array.isArray(event.data)) {
+        throw new Error('data 必须为对象');
+    }
+    return event;
+}
+
+function selectEventsAfterCursor(events, cursor = 0) {
+    const normalizedCursor = Number(cursor || 0);
+    if (!Number.isInteger(normalizedCursor) || normalizedCursor < 0) {
+        throw new Error('cursor 必须为非负整数');
+    }
+
+    let previousSeq = 0;
+    let aggregateId = '';
+    const result = [];
+    for (const event of events || []) {
+        validateControlEvent(event);
+        if (!aggregateId) {
+            aggregateId = event.aggregateId;
+        } else if (aggregateId !== event.aggregateId) {
+            throw new Error('事件 aggregateId 必须一致');
+        }
+        if (event.seq <= previousSeq) {
+            throw new Error('seq 必须严格递增');
+        }
+        previousSeq = event.seq;
+        if (event.seq > normalizedCursor) {
+            result.push(event);
+        }
+    }
+    return result;
+}
+
+function projectSessionEvents(events) {
+    const orderedEvents = selectEventsAfterCursor(events, 0);
+    const projection = {
+        aggregateId: orderedEvents.length ? orderedEvents[0].aggregateId : '',
+        status: 'idle',
+        lastSeq: orderedEvents.length ? orderedEvents[orderedEvents.length - 1].seq : 0,
+        childSessions: []
+    };
+    const childSessions = new Map();
+
+    for (const event of orderedEvents) {
+        if (event.type === 'session.created') projection.status = 'starting';
+        if (event.type === 'session.ready' || event.type === 'process.started' || event.type === 'agent.turn.started') projection.status = 'running';
+        if (event.type === 'session.stopping') projection.status = 'stopping';
+        if (event.type === 'session.stopped' || event.type === 'process.interrupted') projection.status = 'interrupted';
+        if (event.type === 'session.failed' || event.type === 'agent.turn.failed') projection.status = 'failed';
+        if (event.type === 'process.exited') {
+            projection.status = Number(event.data.exitCode) === 0 ? 'completed' : 'failed';
+        }
+        if (event.type.startsWith('agent.child.')) {
+            const childSessionId = String(event.data.childSessionId || '').trim();
+            if (!childSessionId) {
+                continue;
+            }
+            const current = childSessions.get(childSessionId) || { id: childSessionId, agentProgram: '', status: 'observed' };
+            if (event.data.agentProgram) {
+                current.agentProgram = String(event.data.agentProgram);
+            }
+            if (event.type === 'agent.child.completed') current.status = 'completed';
+            if (event.type === 'agent.child.failed') current.status = 'failed';
+            if (event.type === 'agent.child.interrupted') current.status = 'interrupted';
+            childSessions.set(childSessionId, current);
+        }
+    }
+    projection.childSessions = Array.from(childSessions.values());
+    return projection;
+}
+
+module.exports = {
+    EVENT_VERSION,
+    EVENT_TYPES,
+    createControlEvent,
+    validateControlEvent,
+    selectEventsAfterCursor,
+    projectSessionEvents
+};

package/lib/doctor.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const { resolveContainerMode } = require('./container-modes');
+const { resolveAgentProgram } = require('./agent-resume');
+
+function createCheck(code, status, summary, action = '', detail = '') {
+    return { code, status, summary, action, detail };
+}
+
+function runDoctorChecks(options = {}) {
+    const checks = [];
+    const runCommand = typeof options.runCommand === 'function' ? options.runCommand : () => {
+        throw new Error('未配置命令执行器');
+    };
+    let runtimeCommand = '';
+
+    for (const candidate of (options.runtimeCandidates || ['docker', 'podman'])) {
+        try {
+            const detail = String(runCommand(candidate, ['--version']) || '').trim();
+            runtimeCommand = candidate;
+            checks.push(createCheck('RUNTIME_AVAILABLE', 'ok', `检测到 ${candidate}`, '', detail));
+            break;
+        } catch (error) {
+            // 尝试下一个受支持运行时。
+        }
+    }
+    if (!runtimeCommand) {
+        checks.push(createCheck('RUNTIME_UNAVAILABLE', 'error', '未找到 Docker 或 Podman', '安装并启动 Docker Desktop 或 Podman。'));
+    } else {
+        try {
+            const detail = String(runCommand(runtimeCommand, ['info']) || '').trim();
+            checks.push(createCheck('DAEMON_AVAILABLE', 'ok', `${runtimeCommand} daemon 可用`, '', detail));
+        } catch (error) {
+            checks.push(createCheck('DAEMON_UNAVAILABLE', 'error', `${runtimeCommand} daemon 不可用`, `启动 ${runtimeCommand} daemon 后重试。`, error.message || ''));
+        }
+        try {
+            const image = `${options.imageName || ''}:${options.imageVersion || ''}`;
+            const detail = String(runCommand(runtimeCommand, ['image', 'inspect', image]) || '').trim();
+            checks.push(createCheck('IMAGE_AVAILABLE', 'ok', `镜像可用: ${image}`, '', detail));
+        } catch (error) {
+            checks.push(createCheck('IMAGE_MISSING', 'warning', '目标镜像尚不可用', '执行 manyoyo build，或拉取匹配镜像。', error.message || ''));
+        }
+    }
+
+    checks.push(options.configExists === true
+        ? createCheck('CONFIG_AVAILABLE', 'ok', '配置文件可用')
+        : createCheck('CONFIG_MISSING', 'warning', '未找到配置文件', '执行 manyoyo init 或通过 run 参数指定配置。'));
+
+    const agentProgram = resolveAgentProgram(options.agentCommand || '');
+    checks.push(agentProgram
+        ? createCheck('AGENT_CONFIGURED', 'ok', `已配置 Agent: ${agentProgram}`)
+        : createCheck('AGENT_NOT_CONFIGURED', 'warning', '未配置 Agent 命令', '设置 shell、yolo 或 agentPromptCommand。'));
+
+    try {
+        const mode = resolveContainerMode(options.containerMode || 'common');
+        checks.push(createCheck('MODE_VALID', 'ok', `容器模式有效: ${mode.mode}`));
+    } catch (error) {
+        checks.push(createCheck('MODE_INVALID', 'error', '容器模式无效', '使用 common、dind 或 sock。', error.message || ''));
+    }
+
+    const pluginConfig = options.pluginConfig;
+    checks.push(pluginConfig && typeof pluginConfig === 'object' && !Array.isArray(pluginConfig)
+        ? createCheck('PLUGIN_CONFIG_VALID', 'ok', '插件配置有效')
+        : createCheck('PLUGIN_CONFIG_INVALID', 'warning', '插件配置不存在或格式无效', '将 plugins 配置为对象(map)。'));
+
+    if (options.portStatus === 'available') {
+        checks.push(createCheck('PORT_AVAILABLE', 'ok', '监听端口可用'));
+    } else if (options.portStatus === 'occupied') {
+        checks.push(createCheck('PORT_OCCUPIED', 'warning', '监听端口已占用', '选择其他 serve 端口或停止占用进程。'));
+    } else {
+        checks.push(createCheck('PORT_NOT_CHECKED', 'warning', '未检查监听端口', '使用 doctor --port <port> 检查端口。'));
+    }
+
+    return {
+        version: 1,
+        runtimeCommand: runtimeCommand || null,
+        ok: !checks.some(check => check.status === 'error'),
+        checks
+    };
+}
+
+module.exports = {
+    runDoctorChecks
+};