@xcanwin/manyoyo 4.1.1 → 4.1.10

package/docker/manyoyo.Dockerfile

@@ -4,6 +4,7 @@
 FROM ubuntu:24.04 AS cache-stage
 
 ARG TARGETARCH
+ARG TOOL="common"
 
 # 复制缓存目录（可能为空）
 COPY ./docker/cache/ /cache/
@@ -29,27 +30,31 @@ RUN <<EOX
         curl -fsSL ${NVM_NODEJS_ORG_MIRROR}/latest-v24.x/${NODE_TAR} | tar -xz -C /opt/node --strip-components=1 --exclude='*.md' --exclude='LICENSE'
     fi
 
-    # JDT LSP: 检测缓存，不存在则下载
+    # JDT LSP: 仅在 full/java 时准备缓存
     mkdir -p /opt/jdtls
-    if [ -f /cache/jdtls/jdt-language-server-latest.tar.gz ]; then
-        echo "使用 JDT LSP 缓存"
-        tar -xzf /cache/jdtls/jdt-language-server-latest.tar.gz -C /opt/jdtls --no-same-owner
-    else
-        echo "下载 JDT LSP"
-        curl -fsSL https://download.eclipse.org/jdtls/snapshots/jdt-language-server-latest.tar.gz | tar -xz -C /opt/jdtls
-    fi
+    case ",$TOOL," in *,full,*|*,java,*)
+        if [ -f /cache/jdtls/jdt-language-server-latest.tar.gz ]; then
+            echo "使用 JDT LSP 缓存"
+            tar -xzf /cache/jdtls/jdt-language-server-latest.tar.gz -C /opt/jdtls --no-same-owner
+        else
+            echo "下载 JDT LSP"
+            curl -fsSL https://download.eclipse.org/jdtls/snapshots/jdt-language-server-latest.tar.gz | tar -xz -C /opt/jdtls
+        fi
+    ;; esac
 
-    # gopls: 检测缓存，不存在则下载
+    # gopls: 仅在 full/go 时准备缓存
     mkdir -p /opt/gopls
-    if [ -f /cache/gopls/gopls-linux-${ARCH_GO} ]; then
-        echo "使用 gopls 缓存"
-        cp /cache/gopls/gopls-linux-${ARCH_GO} /opt/gopls/gopls
-        chmod +x /opt/gopls/gopls
-    else
-        echo "下载 gopls (需要 go 环境)"
-        # gopls 需要编译，这里跳过，在最终阶段处理
-        touch /opt/gopls/.no-cache
-    fi
+    case ",$TOOL," in *,full,*|*,go,*)
+        if [ -f /cache/gopls/gopls-linux-${ARCH_GO} ]; then
+            echo "使用 gopls 缓存"
+            cp /cache/gopls/gopls-linux-${ARCH_GO} /opt/gopls/gopls
+            chmod +x /opt/gopls/gopls
+        else
+            echo "下载 gopls (需要 go 环境)"
+            # gopls 需要编译，这里跳过，在最终阶段处理
+            touch /opt/gopls/.no-cache
+        fi
+    ;; esac
 EOX
 
 # ==============================================================================
@@ -68,6 +73,8 @@ ARG PIP_INDEX_URL=https://mirrors.tencent.com/pypi/simple
 # 轻量级文本解析依赖（可通过 --build-arg 覆盖）
 ARG PY_TEXT_PIP_PACKAGES="PyYAML python-dotenv tomlkit pyjson5 jsonschema"
 ARG PY_TEXT_EXTRA_PIP_PACKAGES=""
+ENV LANG=C.UTF-8 \
+    LC_ALL=C.UTF-8
 
 # 合并系统依赖安装为单层，减少镜像体积
 RUN <<EOX
@@ -128,7 +135,6 @@ ARG GIT_SSL_NO_VERIFY=false
 RUN <<EOX
     # 配置 node.js
     npm config set registry=${NPM_REGISTRY}
-    npm install -g npm
 
     # 安装 LSP服务（python、typescript）
     npm install -g pyright typescript-language-server typescript
@@ -151,8 +157,12 @@ EOF
     claude plugin install ralph-loop@claude-plugins-official
     claude plugin install typescript-lsp@claude-plugins-official
     claude plugin install pyright-lsp@claude-plugins-official
-    claude plugin install gopls-lsp@claude-plugins-official
-    claude plugin install jdtls-lsp@claude-plugins-official
+    case ",$TOOL," in *,full,*|*,go,*)
+        claude plugin install gopls-lsp@claude-plugins-official
+    ;; esac
+    case ",$TOOL," in *,full,*|*,java,*)
+        claude plugin install jdtls-lsp@claude-plugins-official
+    ;; esac
 
     GIT_SSL_NO_VERIFY=$GIT_SSL_NO_VERIFY claude plugin marketplace add https://github.com/anthropics/skills
     claude plugin install example-skills@anthropic-agent-skills
@@ -200,21 +210,6 @@ enabled = false
 EOF
     ;; esac
 
-    # 安装 Copilot CLI
-    case ",$TOOL," in *,full,*|*,copilot,*)
-        npm install -g @github/copilot
-        mkdir -p ~/.copilot/
-        cat > ~/.copilot/config.json <<EOF
-{
-    "banner": "never",
-    "model": "gemini-3-pro-preview",
-    "render_markdown": true,
-    "screen_reader": false,
-    "theme": "auto"
-}
-EOF
-    ;; esac
-
     # 安装 OpenCode CLI
     case ",$TOOL," in *,full,*|*,opencode,*)
         npm install -g opencode-ai
@@ -251,7 +246,7 @@ EOF
 EOX
 
 # 从 cache-stage 复制 JDT LSP（缓存或下载）
-COPY --from=cache-stage /opt/jdtls /root/.local/share/jdtls
+COPY --from=cache-stage /opt/jdtls /tmp/jdtls-cache
 
 RUN <<EOX
     # 安装 java
@@ -260,12 +255,15 @@ RUN <<EOX
         apt-get install -y --no-install-recommends openjdk-21-jdk maven
 
         # 配置 LSP服务（java）
+        mkdir -p ~/.local/share/
+        cp -a /tmp/jdtls-cache ~/.local/share/jdtls
         ln -sf ~/.local/share/jdtls/bin/jdtls /usr/local/bin/jdtls
 
         # 清理
         apt-get clean
         rm -rf /tmp/* /var/tmp/* /var/log/apt /var/log/*.log /var/lib/apt/lists/* ~/.cache ~/.npm ~/go/pkg/mod/cache
     ;; esac
+    rm -rf /tmp/jdtls-cache
 EOX
 
 # 从 cache-stage 复制 gopls（缓存或下载）
@@ -288,13 +286,12 @@ RUN <<EOX
             go install golang.org/x/tools/gopls@latest
             ln -sf ~/go/bin/gopls /usr/local/bin/gopls
         fi
-        rm -rf /tmp/gopls-cache
-
         # 清理
         apt-get clean
         go clean -modcache -cache
         rm -rf /tmp/* /var/tmp/* /var/log/apt /var/log/*.log /var/lib/apt/lists/* ~/.cache ~/.npm ~/go/pkg/mod/cache
     ;; esac
+    rm -rf /tmp/gopls-cache
 EOX
 
 RUN <<EOX

package/lib/agent-resume.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const path = require('path');
+
+const AGENT_RESUME_ARG_MAP = {
+    claude: '-r',
+    gemini: '-r',
+    codex: 'resume',
+    opencode: '-c'
+};
+
+function stripLeadingAssignments(commandText) {
+    let rest = String(commandText || '').trim();
+    const assignmentPattern = /^(?:[A-Za-z_][A-Za-z0-9_]*=)(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s]+)(?:\s+|$)/;
+
+    while (rest) {
+        const matched = rest.match(assignmentPattern);
+        if (!matched) {
+            break;
+        }
+        rest = rest.slice(matched[0].length).trim();
+    }
+
+    return rest;
+}
+
+function readLeadingToken(commandText) {
+    const text = String(commandText || '').trim();
+    if (!text) {
+        return { token: '', rest: '' };
+    }
+
+    const tokenMatch = text.match(/^(?:"((?:\\.|[^"])*)"|'((?:\\.|[^'])*)'|([^\s]+))(?:\s+|$)/);
+    if (!tokenMatch) {
+        return { token: '', rest: '' };
+    }
+
+    const token = tokenMatch[1] || tokenMatch[2] || tokenMatch[3] || '';
+    const rest = text.slice(tokenMatch[0].length).trim();
+    return { token, rest };
+}
+
+function normalizeProgramName(token) {
+    if (!token) {
+        return '';
+    }
+    return path.basename(token).toLowerCase();
+}
+
+function resolveAgentProgram(commandText) {
+    let rest = stripLeadingAssignments(commandText);
+    let leading = readLeadingToken(rest);
+    let program = normalizeProgramName(leading.token);
+
+    // Support common wrapper: env KEY=VALUE cmd ...
+    if (program === 'env') {
+        rest = stripLeadingAssignments(leading.rest);
+        leading = readLeadingToken(rest);
+        program = normalizeProgramName(leading.token);
+    }
+
+    return program;
+}
+
+function resolveAgentResumeArg(commandText) {
+    const program = resolveAgentProgram(commandText);
+    return AGENT_RESUME_ARG_MAP[program] || '';
+}
+
+module.exports = {
+    resolveAgentResumeArg
+};

package/lib/container-run.js

@@ -0,0 +1,39 @@
+'use strict';
+
+function sanitizeDefaultCommand(defaultCommand) {
+    return String(defaultCommand || '').replace(/[\r\n]/g, ' ');
+}
+
+function buildContainerRunArgs(options) {
+    const args = [
+        'run', '-d',
+        '--name', options.containerName,
+        '--entrypoint', '',
+        ...(options.contModeArgs || []),
+        ...(options.containerEnvs || []),
+        ...(options.containerVolumes || []),
+        '--volume', `${options.hostPath}:${options.containerPath}`,
+        '--workdir', options.containerPath,
+        '--label', `manyoyo.default_cmd=${sanitizeDefaultCommand(options.defaultCommand)}`,
+        `${options.imageName}:${options.imageVersion}`,
+        'tail', '-f', '/dev/null'
+    ];
+    return args;
+}
+
+function quoteShellArg(value) {
+    const text = String(value);
+    if (text.includes(' ') || text.includes('"') || text.includes('=')) {
+        return `"${text.replace(/"/g, '\\"')}"`;
+    }
+    return text;
+}
+
+function buildContainerRunCommand(dockerCmd, args) {
+    return `${dockerCmd} ${args.map(quoteShellArg).join(' ')}`;
+}
+
+module.exports = {
+    buildContainerRunArgs,
+    buildContainerRunCommand
+};

package/lib/image-build.js

@@ -0,0 +1,323 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+function getFileSha256(filePath) {
+    return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
+}
+
+function quoteShellArg(value) {
+    const text = String(value);
+    if (text.includes(' ') || text.includes('"') || text.includes('=')) {
+        return `"${text.replace(/"/g, '\\"')}"`;
+    }
+    return text;
+}
+
+function ensureDirectoryIfMissing(dirPath) {
+    if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function loadBuildCacheTimestamps(timestampFile) {
+    if (!fs.existsSync(timestampFile)) return {};
+    try {
+        return JSON.parse(fs.readFileSync(timestampFile, 'utf-8'));
+    } catch (e) {
+        return {};
+    }
+}
+
+function saveBuildCacheTimestamps(timestampFile, timestamps) {
+    fs.writeFileSync(timestampFile, JSON.stringify(timestamps, null, 4));
+}
+
+function createBuildCacheContext(ctx) {
+    const cacheDir = path.join(ctx.rootDir, 'docker', 'cache');
+    ensureDirectoryIfMissing(cacheDir);
+
+    const config = ctx.loadConfig();
+    const timestampFile = path.join(cacheDir, '.timestamps.json');
+    return {
+        cacheDir,
+        timestampFile,
+        cacheTTLDays: config.cacheTTL || ctx.cacheTtlDays,
+        nodeMirrors: [config.nodeMirror, 'https://mirrors.tencent.com/nodejs-release', 'https://nodejs.org/dist'].filter(Boolean),
+        timestamps: loadBuildCacheTimestamps(timestampFile),
+        now: new Date()
+    };
+}
+
+function isBuildCacheExpired(cache, key) {
+    if (!cache.timestamps[key]) return true;
+    const cachedTime = new Date(cache.timestamps[key]);
+    const diffDays = (cache.now - cachedTime) / (1000 * 60 * 60 * 24);
+    return diffDays > cache.cacheTTLDays;
+}
+
+function touchBuildCache(cache, key) {
+    cache.timestamps[key] = cache.now.toISOString();
+    saveBuildCacheTimestamps(cache.timestampFile, cache.timestamps);
+}
+
+function resolveBuildCacheArch() {
+    const arch = process.arch === 'x64' ? 'amd64' : process.arch === 'arm64' ? 'arm64' : process.arch;
+    return { arch, archNode: arch === 'amd64' ? 'x64' : 'arm64' };
+}
+
+function prepareNodeBuildCache(ctx, cache, archNode) {
+    const { RED, GREEN, YELLOW, BLUE, NC } = ctx.colors;
+    const nodeCacheDir = path.join(cache.cacheDir, 'node');
+    const nodeVersion = 24;
+    const nodeKey = 'node/';
+
+    ensureDirectoryIfMissing(nodeCacheDir);
+    const hasNodeCache = fs.readdirSync(nodeCacheDir).some(fileName => (
+        fileName.startsWith('node-') && fileName.includes(`linux-${archNode}`)
+    ));
+    if (hasNodeCache && !isBuildCacheExpired(cache, nodeKey)) {
+        ctx.log(`${GREEN}✓ Node.js 缓存已存在${NC}`);
+        return;
+    }
+
+    ctx.log(`${YELLOW}下载 Node.js ${nodeVersion} (${archNode})...${NC}`);
+
+    for (const mirror of cache.nodeMirrors) {
+        try {
+            ctx.log(`${BLUE}尝试镜像源: ${mirror}${NC}`);
+            const shasumUrl = `${mirror}/latest-v${nodeVersion}.x/SHASUMS256.txt`;
+            const shasumContent = ctx.runCmd('curl', ['-fsSL', shasumUrl], { stdio: 'pipe' });
+            const shasumLine = shasumContent.split('\n').find(line => line.includes(`linux-${archNode}.tar.gz`));
+            if (!shasumLine) continue;
+
+            const [expectedHash, fileName] = shasumLine.trim().split(/\s+/);
+            const nodeTargetPath = path.join(nodeCacheDir, fileName);
+            ctx.runCmd('curl', ['-fsSL', `${mirror}/latest-v${nodeVersion}.x/${fileName}`, '-o', nodeTargetPath], { stdio: 'inherit' });
+
+            if (getFileSha256(nodeTargetPath) !== expectedHash) {
+                ctx.log(`${RED}SHA256 校验失败，删除文件${NC}`);
+                fs.unlinkSync(nodeTargetPath);
+                continue;
+            }
+
+            ctx.log(`${GREEN}✓ SHA256 校验通过${NC}`);
+            touchBuildCache(cache, nodeKey);
+            ctx.log(`${GREEN}✓ Node.js 下载完成${NC}`);
+            return;
+        } catch (e) {
+            ctx.log(`${YELLOW}镜像源 ${mirror} 失败，尝试下一个...${NC}`);
+        }
+    }
+
+    ctx.error(`${RED}错误: Node.js 下载失败（所有镜像源均不可用）${NC}`);
+    throw new Error('Node.js download failed');
+}
+
+function prepareJdtlsBuildCache(ctx, cache, imageTool) {
+    const { RED, GREEN, YELLOW, NC } = ctx.colors;
+    if (!(imageTool === 'full' || imageTool.includes('java'))) return;
+
+    const jdtlsCacheDir = path.join(cache.cacheDir, 'jdtls');
+    const jdtlsKey = 'jdtls/jdt-language-server-latest.tar.gz';
+    const jdtlsPath = path.join(cache.cacheDir, jdtlsKey);
+
+    ensureDirectoryIfMissing(jdtlsCacheDir);
+    if (fs.existsSync(jdtlsPath) && !isBuildCacheExpired(cache, jdtlsKey)) {
+        ctx.log(`${GREEN}✓ JDT LSP 缓存已存在${NC}`);
+        return;
+    }
+
+    const tmpDir = path.join(jdtlsCacheDir, '.tmp-apk');
+    const apkPath = path.join(tmpDir, 'jdtls.apk');
+    ctx.log(`${YELLOW}下载 JDT Language Server...${NC}`);
+
+    try {
+        ensureDirectoryIfMissing(tmpDir);
+        ctx.runCmd('curl', ['-fsSL', 'https://mirrors.tencent.com/alpine/latest-stable/community/x86_64/jdtls-1.53.0-r0.apk', '-o', apkPath], { stdio: 'inherit' });
+        ctx.runCmd('tar', ['-xzf', apkPath, '-C', tmpDir], { stdio: 'inherit' });
+        ctx.runCmd('tar', ['-czf', jdtlsPath, '-C', path.join(tmpDir, 'usr', 'share', 'jdtls'), '.'], { stdio: 'inherit' });
+        touchBuildCache(cache, jdtlsKey);
+        ctx.log(`${GREEN}✓ JDT LSP 下载完成${NC}`);
+    } catch (e) {
+        ctx.error(`${RED}错误: JDT LSP 下载失败${NC}`);
+        throw e;
+    } finally {
+        try { ctx.runCmd('rm', ['-rf', tmpDir], { stdio: 'inherit', ignoreError: true }); } catch (e) {}
+    }
+}
+
+function cleanupGoTmpPath(ctx, tmpGoPath, warnOnError) {
+    const { YELLOW, NC } = ctx.colors;
+    if (!fs.existsSync(tmpGoPath)) return;
+
+    try {
+        ctx.runCmd('go', ['clean', '-modcache'], {
+            stdio: 'inherit',
+            ignoreError: true,
+            env: { ...process.env, GOPATH: tmpGoPath }
+        });
+        ctx.runCmd('chmod', ['-R', 'u+w', tmpGoPath], { stdio: 'inherit', ignoreError: true });
+        ctx.runCmd('rm', ['-rf', tmpGoPath], { stdio: 'inherit', ignoreError: true });
+    } catch (e) {
+        if (warnOnError) {
+            ctx.log(`${YELLOW}提示: 临时目录清理失败，可手动删除 ${tmpGoPath}${NC}`);
+        }
+    }
+}
+
+function resolveGoplsSource(tmpGoPath, arch) {
+    const primary = path.join(tmpGoPath, 'bin', `linux_${arch}`, 'gopls');
+    if (fs.existsSync(primary)) return primary;
+    const fallback = path.join(tmpGoPath, 'bin', 'gopls');
+    return fs.existsSync(fallback) ? fallback : '';
+}
+
+function prepareGoplsBuildCache(ctx, cache, imageTool, arch) {
+    const { RED, GREEN, YELLOW, NC } = ctx.colors;
+    if (!(imageTool === 'full' || imageTool.includes('go'))) return;
+
+    const goplsCacheDir = path.join(cache.cacheDir, 'gopls');
+    const goplsKey = `gopls/gopls-linux-${arch}`;
+    const goplsPath = path.join(cache.cacheDir, goplsKey);
+
+    ensureDirectoryIfMissing(goplsCacheDir);
+    if (fs.existsSync(goplsPath) && !isBuildCacheExpired(cache, goplsKey)) {
+        ctx.log(`${GREEN}✓ gopls 缓存已存在${NC}`);
+        return;
+    }
+
+    const tmpGoPath = path.join(cache.cacheDir, '.tmp-go');
+    ctx.log(`${YELLOW}下载 gopls (${arch})...${NC}`);
+
+    try {
+        cleanupGoTmpPath(ctx, tmpGoPath, false);
+        ensureDirectoryIfMissing(tmpGoPath);
+
+        ctx.runCmd('go', ['install', 'golang.org/x/tools/gopls@latest'], {
+            stdio: 'inherit',
+            env: { ...process.env, GOPATH: tmpGoPath, GOOS: 'linux', GOARCH: arch }
+        });
+
+        const sourcePath = resolveGoplsSource(tmpGoPath, arch);
+        if (!sourcePath) throw new Error(`gopls binary not found in ${tmpGoPath}`);
+        fs.copyFileSync(sourcePath, goplsPath);
+        ctx.runCmd('chmod', ['+x', goplsPath], { stdio: 'inherit' });
+
+        touchBuildCache(cache, goplsKey);
+        ctx.log(`${GREEN}✓ gopls 下载完成${NC}`);
+        cleanupGoTmpPath(ctx, tmpGoPath, true);
+    } catch (e) {
+        ctx.error(`${RED}错误: gopls 下载失败${NC}`);
+        throw e;
+    }
+}
+
+async function prepareBuildCache(ctx, imageTool) {
+    const { CYAN, GREEN, NC } = ctx.colors;
+    const cache = createBuildCacheContext(ctx);
+    const { arch, archNode } = resolveBuildCacheArch();
+
+    ctx.log(`\n${CYAN}准备构建缓存...${NC}`);
+    prepareNodeBuildCache(ctx, cache, archNode);
+    prepareJdtlsBuildCache(ctx, cache, imageTool);
+    prepareGoplsBuildCache(ctx, cache, imageTool, arch);
+    saveBuildCacheTimestamps(cache.timestampFile, cache.timestamps);
+    ctx.log(`${GREEN}✅ 构建缓存准备完成${NC}\n`);
+}
+
+function resolveToolFromBuildArgs(args) {
+    for (const value of args) {
+        if (typeof value === 'string' && value.startsWith('TOOL=')) return value.slice(5);
+    }
+    return '';
+}
+
+async function buildImage(options = {}) {
+    const ctx = {
+        imageBuildArgs: Array.isArray(options.imageBuildArgs) ? [...options.imageBuildArgs] : [],
+        imageName: options.imageName,
+        imageVersionTag: options.imageVersionTag,
+        imageVersionDefault: options.imageVersionDefault || '',
+        imageVersionBase: options.imageVersionBase || '1.0.0',
+        parseImageVersionTag: options.parseImageVersionTag,
+        manyoyoName: options.manyoyoName || 'manyoyo',
+        yesMode: Boolean(options.yesMode),
+        dockerCmd: options.dockerCmd || 'docker',
+        rootDir: options.rootDir || process.cwd(),
+        loadConfig: options.loadConfig || (() => ({})),
+        runCmd: options.runCmd,
+        askQuestion: options.askQuestion || (async () => ''),
+        pruneDanglingImages: options.pruneDanglingImages || (() => {}),
+        cacheTtlDays: options.cacheTtlDays || 2,
+        log: options.log || console.log,
+        error: options.error || console.error,
+        exit: options.exit || (code => process.exit(code)),
+        colors: options.colors || { RED: '', GREEN: '', YELLOW: '', BLUE: '', CYAN: '', NC: '' }
+    };
+    const { RED, GREEN, YELLOW, BLUE, CYAN, NC } = ctx.colors;
+
+    const versionTag = ctx.imageVersionTag || ctx.imageVersionDefault || `${ctx.imageVersionBase}-common`;
+    const parsedVersion = ctx.parseImageVersionTag(versionTag);
+    if (!parsedVersion) {
+        ctx.error(`${RED}错误: 镜像版本格式错误，必须为 <x.y.z-后缀>，例如 1.7.4-common: ${versionTag}${NC}`);
+        ctx.exit(1);
+        return;
+    }
+
+    const version = parsedVersion.baseVersion;
+    let imageTool = parsedVersion.tool;
+    const imageBuildArgs = [...ctx.imageBuildArgs];
+    const toolFromArgs = resolveToolFromBuildArgs(imageBuildArgs);
+    if (!toolFromArgs) {
+        imageBuildArgs.push('--build-arg', `TOOL=${imageTool}`);
+    } else {
+        imageTool = toolFromArgs;
+    }
+
+    const fullImageTag = `${ctx.imageName}:${version}-${imageTool}`;
+    ctx.log(`${CYAN}🔨 正在构建镜像: ${YELLOW}${fullImageTag}${NC}`);
+    ctx.log(`${BLUE}构建组件类型: ${imageTool}${NC}\n`);
+
+    await prepareBuildCache(ctx, imageTool);
+
+    const dockerfilePath = path.join(ctx.rootDir, 'docker', 'manyoyo.Dockerfile');
+    if (!fs.existsSync(dockerfilePath)) {
+        ctx.error(`${RED}错误: 找不到 Dockerfile: ${dockerfilePath}${NC}`);
+        ctx.exit(1);
+        return;
+    }
+
+    const buildArgs = [
+        'build', '-t', fullImageTag,
+        '-f', dockerfilePath,
+        ctx.rootDir,
+        ...imageBuildArgs,
+        '--load',
+        '--progress=plain',
+        '--no-cache'
+    ];
+
+    ctx.log(`${BLUE}准备执行命令:${NC}`);
+    ctx.log(`${ctx.dockerCmd} ${buildArgs.map(quoteShellArg).join(' ')}\n`);
+
+    if (!ctx.yesMode) {
+        await ctx.askQuestion('❔ 是否继续构建? [ 直接回车=继续, ctrl+c=取消 ]: ');
+        ctx.log('');
+    }
+
+    try {
+        ctx.runCmd(ctx.dockerCmd, buildArgs, { stdio: 'inherit' });
+        ctx.log(`\n${GREEN}✅ 镜像构建成功: ${fullImageTag}${NC}`);
+        ctx.log(`${BLUE}使用镜像:${NC}`);
+        ctx.log(`  ${ctx.manyoyoName} -n test --in ${ctx.imageName} --iv ${version}-${imageTool} -y c`);
+        ctx.pruneDanglingImages();
+    } catch (e) {
+        ctx.error(`${RED}错误: 镜像构建失败${NC}`);
+        ctx.exit(1);
+    }
+}
+
+module.exports = {
+    buildImage
+};