@xcanwin/manyoyo 3.1.0 → 3.4.0

package/README.md

@@ -1,4 +1,4 @@
-[English](docs/README_EN.md) | [ [中文](README.md) ]
+[English](docs/README_EN.md) | << [中文](README.md) >>
 
 ---
 
@@ -49,15 +49,23 @@ npm install -g .
 # 拉取基础镜像
 podman pull ubuntu:24.04
 
-# 使用 manyoyo 构建镜像（推荐）
-manyoyo --ib all                     # 构建 all 版本（包含所有工具）
-manyoyo --ib common                  # 构建 common 版本（基础版本）
-manyoyo --ib go,codex,java,gemini    # 构建 go 版本（包含 go,codex,java,gemini 工具）
+# 使用 manyoyo 构建镜像（推荐，自动使用缓存加速）
+manyoyo --ib all                     # 构建 all 版本（自动使用缓存，首次下载后 2 天内极速构建）
+manyoyo --ib common                  # 构建 common 版本
+manyoyo --ib go,codex,java,gemini    # 构建自定义组合版本
+
+# 工作原理：
+# - 首次构建：自动下载 Node.js、JDT LSP、gopls 等到 docker/cache/
+# - 2天内再次构建：直接使用本地缓存，速度提升约 5 倍
+# - 缓存过期后：自动重新下载最新版本
 
 # 自定义镜像名称和版本
 manyoyo --ib all --in myimage --iv 2.0.0
 # 构建：myimage:2.0.0-all
 
+# 清理镜像
+manyoyo --ip                         # 清理悬空镜像和 <none> 镜像
+
 # 或手动构建（不推荐）
 iv=1.4.0 && podman build -t localhost/xcanwin/manyoyo:$iv-all -f docker/manyoyo.Dockerfile . --build-arg EXT=all --no-cache
 podman image prune -f
@@ -173,14 +181,18 @@ manyoyo -n docker-dev -m dind -x /bin/bash
 nohup dockerd &
 
 # 现在可以在容器内使用 docker 命令
-docker run hello-world
+docker ps -a
 ```
 
 #### 挂载 Docker Socket 开发
 
 ```bash
-# 挂载 Docker Socket（危险 - 容器可以访问宿主机）
-manyoyo -n socket-dev -m mdsock -x docker ps
+# 挂载 Docker Socket（危险的！！！容器可以访问和执行宿主机的一切）
+# 创建挂载 /var/run/docker.sock 的容器
+manyoyo -n socket-dev -m mdsock -x /bin/bash
+
+# 现在可以在容器内使用 docker 命令
+docker ps -a
 ```
 
 ### 命令行选项
@@ -203,7 +215,8 @@ manyoyo -n socket-dev -m mdsock -x docker ps
 | `-x CMD` | `--sf`, `--shell-full` | 完整命令（替代 --sp, -s 和 --） |
 | `-y CLI` | `--yolo` | 无需确认运行 AI 智能体 |
 | `-m MODE` | `--cm`, `--cont-mode` | 设置容器模式（common, dind, mdsock） |
-| `--ib EXT` | `--image-build` | 构建镜像，EXT 为镜像变体（all, go, common） |
+| `--ib EXT` | `--image-build` | 构建镜像，EXT 为镜像变体，自动使用缓存加速 |
+| `--ip` | `--image-prune` | 清理悬空镜像和 `<none>` 镜像 |
 | `--install NAME` | | 安装 manyoyo 命令 |
 | `-V` | `--version` | 显示版本 |
 | `-h` | `--help` | 显示帮助 |

package/bin/manyoyo.js

@@ -87,6 +87,8 @@ function showHelp() {
     console.log("                                 例如 common, dind, mdsock");
     console.log("  --ib|--image-build EXT         构建镜像，EXT 为镜像变体，逗号分割");
     console.log("                                 例如 \"common\" (默认值), \"all\", \"go,codex,java,gemini\" ...");
+    console.log("                                 (自动使用缓存加速，缓存过期后自动重新下载)");
+    console.log("  --ip|--image-prune             清理悬空镜像和 <none> 镜像");
     console.log("  --install NAME                 安装manyoyo命令");
     console.log("                                 例如 docker-cli-plugin");
     console.log("  -V|--version                   显示版本");
@@ -214,7 +216,7 @@ function setContMode(mode) {
         case 'mount-docker-socket':
         case 'mdsock':
         case 's':
-            CONT_MODE = "--volume /var/run/docker.sock:/var/run/docker.sock";
+            CONT_MODE = "--privileged --volume /var/run/docker.sock:/var/run/docker.sock";
             console.log(`${RED}⚠️ 开启危险的容器嵌套容器模式, 危害: 容器可访问宿主机文件${NC}`);
             break;
         default:
@@ -300,6 +302,179 @@ function getContList() {
     }
 }
 
+function pruneDanglingImages() {
+    console.log(`\n${YELLOW}清理悬空镜像...${NC}`);
+    execSync(`${DOCKER_CMD} image prune -f`, { stdio: 'inherit' });
+
+    // Remove remaining <none> images
+    try {
+        const imagesOutput = execSync(`${DOCKER_CMD} images -a --format "{{.ID}} {{.Repository}}"`, { encoding: 'utf-8' });
+        const noneImages = imagesOutput
+            .split('\n')
+            .filter(line => line.includes('<none>'))
+            .map(line => line.split(' ')[0])
+            .filter(id => id);
+
+        if (noneImages.length > 0) {
+            console.log(`${YELLOW}清理剩余的 <none> 镜像 (${noneImages.length} 个)...${NC}`);
+            execSync(`${DOCKER_CMD} rmi -f ${noneImages.join(' ')}`, { stdio: 'inherit' });
+        }
+    } catch (e) {
+        // Ignore errors if no <none> images found
+    }
+
+    console.log(`${GREEN}✅ 清理完成${NC}`);
+}
+
+async function prepareBuildCache(ext) {
+    const cacheDir = path.join(__dirname, '../docker/cache');
+    const timestampFile = path.join(cacheDir, '.timestamps.json');
+    const cacheTTLDays = 2;
+
+    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}`);
+        const mirror = 'https://mirrors.tencent.com/nodejs-release';
+        try {
+            const shasum = execSync(`curl -sL ${mirror}/latest-v${nodeVersion}.x/SHASUMS256.txt | grep linux-${archNode}.tar.gz | awk '{print $2}'`, { encoding: 'utf-8' }).trim();
+            const nodeUrl = `${mirror}/latest-v${nodeVersion}.x/${shasum}`;
+            const nodeTargetPath = path.join(nodeCacheDir, shasum);
+            execSync(`curl -fsSL "${nodeUrl}" -o "${nodeTargetPath}"`, { stdio: 'inherit' });
+            timestamps[nodeKey] = now.toISOString();
+            fs.writeFileSync(timestampFile, JSON.stringify(timestamps, null, 2));
+            console.log(`${GREEN}✓ Node.js 下载完成${NC}`);
+        } catch (e) {
+            console.error(`${RED}错误: Node.js 下载失败${NC}`);
+            throw e;
+        }
+    } else {
+        console.log(`${GREEN}✓ Node.js 缓存已存在${NC}`);
+    }
+
+    // Prepare JDT LSP cache (for java variant)
+    if (ext === 'all' || ext.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 jdtUrl = 'https://download.eclipse.org/jdtls/snapshots/jdt-language-server-latest.tar.gz';
+            try {
+                execSync(`curl -fsSL "${jdtUrl}" -o "${jdtlsPath}"`, { stdio: 'inherit' });
+                timestamps[jdtlsKey] = now.toISOString();
+                fs.writeFileSync(timestampFile, JSON.stringify(timestamps, null, 2));
+                console.log(`${GREEN}✓ JDT LSP 下载完成${NC}`);
+            } catch (e) {
+                console.error(`${RED}错误: JDT LSP 下载失败${NC}`);
+                throw e;
+            }
+        } else {
+            console.log(`${GREEN}✓ JDT LSP 缓存已存在${NC}`);
+        }
+    }
+
+    // Prepare gopls cache (for go variant)
+    if (ext === 'all' || ext.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 });
+
+                execSync(`GOPATH="${tmpGoPath}" GOOS=linux GOARCH=${arch} go install golang.org/x/tools/gopls@latest`, { stdio: 'inherit' });
+                execSync(`cp "${tmpGoPath}/bin/linux_${arch}/gopls" "${goplsPath}" || cp "${tmpGoPath}/bin/gopls" "${goplsPath}"`, { stdio: 'inherit' });
+                execSync(`chmod +x "${goplsPath}"`, { stdio: 'inherit' });
+
+                // Save timestamp immediately after successful download
+                timestamps[goplsKey] = now.toISOString();
+                fs.writeFileSync(timestampFile, JSON.stringify(timestamps, null, 2));
+                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}`);
+        }
+    }
+
+    // Save timestamps
+    fs.writeFileSync(timestampFile, JSON.stringify(timestamps, null, 2));
+    console.log(`${GREEN}✅ 构建缓存准备完成${NC}\n`);
+}
+
 async function buildImage(ext, imageName, imageVersion) {
     // Use package.json imageVersion if not specified
     const version = imageVersion || IMAGE_VERSION_BASE;
@@ -308,6 +483,9 @@ async function buildImage(ext, imageName, imageVersion) {
     console.log(`${CYAN}🔨 正在构建镜像: ${YELLOW}${fullImageTag}${NC}`);
     console.log(`${BLUE}构建参数: EXT=${ext}${NC}\n`);
 
+    // Prepare cache (自动检测并下载缺失的文件)
+    await prepareBuildCache(ext);
+
     // Find Dockerfile path
     const dockerfilePath = path.join(__dirname, '../docker/manyoyo.Dockerfile');
     if (!fs.existsSync(dockerfilePath)) {
@@ -331,9 +509,7 @@ async function buildImage(ext, imageName, imageVersion) {
         console.log(`  manyoyo -n test --in ${imageName} --iv ${version}-${ext} -y c`);
 
         // Prune dangling images
-        console.log(`\n${YELLOW}清理悬空镜像...${NC}`);
-        execSync(`${DOCKER_CMD} image prune -f`, { stdio: 'inherit' });
-        console.log(`${GREEN}✅ 清理完成${NC}`);
+        pruneDanglingImages();
     } catch (e) {
         console.error(`${RED}错误: 镜像构建失败${NC}`);
         process.exit(1);
@@ -491,6 +667,11 @@ function parseArguments(argv) {
                 i += 2;
                 break;
 
+            case '--ip':
+            case '--image-prune':
+                pruneDanglingImages();
+                process.exit(0);
+
             case '--install':
                 installManyoyo(args[i + 1]);
                 process.exit(0);

package/docker/manyoyo.Dockerfile

@@ -1,3 +1,60 @@
+# ==============================================================================
+# Stage 1: 缓存准备阶段 - 智能检测缓存或下载
+# ==============================================================================
+FROM ubuntu:24.04 AS cache-stage
+
+ARG TARGETARCH
+
+# 复制缓存目录（可能为空）
+COPY ./docker/cache/ /cache/
+
+RUN <<EOX
+    # 确定架构
+    case "$TARGETARCH" in
+      amd64) ARCH_NODE="x64"; ARCH_GO="amd64" ;;
+      arm64) ARCH_NODE="arm64"; ARCH_GO="arm64" ;;
+      *)     ARCH_NODE="$TARGETARCH"; ARCH_GO="$TARGETARCH" ;;
+    esac
+
+    # Node.js: 检测缓存，不存在则下载
+    mkdir -p /opt/node
+    if ls /cache/node/node-*-linux-${ARCH_NODE}.tar.gz 1> /dev/null 2>&1; then
+        echo "使用 Node.js 缓存"
+        NODE_TAR=$(ls /cache/node/node-*-linux-${ARCH_NODE}.tar.gz | head -1)
+        tar -xzf ${NODE_TAR} -C /opt/node --strip-components=1 --exclude='*.md' --exclude='LICENSE'
+    else
+        echo "下载 Node.js"
+        NVM_NODEJS_ORG_MIRROR=https://mirrors.tencent.com/nodejs-release/
+        NODE_TAR=$(curl -sL ${NVM_NODEJS_ORG_MIRROR}/latest-v24.x/SHASUMS256.txt | grep linux-${ARCH_NODE}.tar.gz | awk '{print $2}')
+        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: 检测缓存，不存在则下载
+    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
+    else
+        echo "下载 JDT LSP"
+        curl -fsSL https://download.eclipse.org/jdtls/snapshots/jdt-language-server-latest.tar.gz | tar -xz -C /opt/jdtls
+    fi
+
+    # gopls: 检测缓存，不存在则下载
+    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
+EOX
+
+# ==============================================================================
+# Stage 2: 最终镜像
+# ==============================================================================
 FROM ubuntu:24.04
 
 ARG TARGETARCH
@@ -45,16 +102,11 @@ RUN <<EOX
     rm -rf /tmp/* /var/tmp/* /var/log/apt /var/log/*.log /var/lib/apt/lists/* ~/.cache ~/.npm ~/go/pkg/mod/cache
 EOX
 
+# 从 cache-stage 复制 Node.js（缓存或下载）
+COPY --from=cache-stage /opt/node /usr/local
+
 RUN <<EOX
-    # 安装 node.js
-    case "$TARGETARCH" in
-      amd64) ARCH_NODE="x64" ;;
-      arm64) ARCH_NODE="arm64" ;;
-      *)     ARCH_NODE="$TARGETARCH" ;;
-    esac
-    NVM_NODEJS_ORG_MIRROR=https://mirrors.tencent.com/nodejs-release/
-    NODE_TAR=$(curl -sL ${NVM_NODEJS_ORG_MIRROR}/latest-v${NODE_VERSION}.x/SHASUMS256.txt | grep linux-${ARCH_NODE}.tar.gz | awk '{print $2}')
-    curl -fsSL ${NVM_NODEJS_ORG_MIRROR}/latest-v${NODE_VERSION}.x/${NODE_TAR} | tar -xz -C /usr/local --strip-components=1 --exclude='*.md' --exclude='LICENSE'
+    # 配置 node.js
     npm config set registry=https://mirrors.tencent.com/npm/
     npm install -g npm
 
@@ -164,18 +216,16 @@ EOF
     rm -rf /tmp/* /var/tmp/* /var/log/apt /var/log/*.log /var/lib/apt/lists/* ~/.cache ~/.npm ~/go/pkg/mod/cache
 EOX
 
-COPY ./docker/lib/jdt-language-server-latest.tar.gz /tmp/
+# 从 cache-stage 复制 JDT LSP（缓存或下载）
+COPY --from=cache-stage /opt/jdtls /root/.local/share/jdtls
+
 RUN <<EOX
     # 安装 java
     case ",$EXT," in *,all,*|*,java,*)
         apt-get update -y
         apt-get install -y --no-install-recommends openjdk-21-jdk maven
 
-        # 安装 LSP服务（java）
-        mkdir -p ~/.local/share/jdtls
-        # wget -O /tmp/jdt-language-server-latest.tar.gz https://download.eclipse.org/jdtls/snapshots/jdt-language-server-latest.tar.gz
-        tar -xzf /tmp/jdt-language-server-latest.tar.gz -C ~/.local/share/jdtls
-        rm -f /tmp/jdt-language-server-latest.tar.gz
+        # 配置 LSP服务（java）
         ln -sf ~/.local/share/jdtls/bin/jdtls /usr/local/bin/jdtls
 
         # 清理
@@ -184,6 +234,9 @@ RUN <<EOX
     ;; esac
 EOX
 
+# 从 cache-stage 复制 gopls（缓存或下载）
+COPY --from=cache-stage /opt/gopls /tmp/gopls-cache
+
 RUN <<EOX
     # 安装 go
     case ",$EXT," in *,all,*|*,go,*)
@@ -192,8 +245,16 @@ RUN <<EOX
         go env -w GOPROXY=https://mirrors.tencent.com/go
 
         # 安装 LSP服务（go）
-        go install golang.org/x/tools/gopls@latest
-        ln -sf ~/go/bin/gopls /usr/local/bin/gopls
+        if [ -f /tmp/gopls-cache/gopls ] && [ ! -f /tmp/gopls-cache/.no-cache ]; then
+            # 使用缓存
+            cp /tmp/gopls-cache/gopls /usr/local/bin/gopls
+            chmod +x /usr/local/bin/gopls
+        else
+            # 下载编译
+            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

package/docs/README_EN.md

@@ -1,4 +1,4 @@
-[ [English](README_EN.md) ] | [中文](../README.md)
+<< [English](README_EN.md) >> | [中文](../README.md)
 
 ---
 
@@ -49,15 +49,23 @@ After installing manyoyo, use the built-in command to build images:
 # Pull base image
 podman pull ubuntu:24.04
 
-# Build using manyoyo (Recommended)
-manyoyo --ib all                     # Build all version (includes all tools)
-manyoyo --ib common                  # Build common version (basic version)
-manyoyo --ib go,codex,java,gemini    # Build go version (includes go,codex,java,gemini tools)
+# Build using manyoyo (Recommended, auto-cache enabled)
+manyoyo --ib all                     # Build all version (auto-cache, blazing fast after first build within 2 days)
+manyoyo --ib common                  # Build common version
+manyoyo --ib go,codex,java,gemini    # Build custom combination
+
+# How it works:
+# - First build: Auto-downloads Node.js, JDT LSP, gopls etc. to docker/cache/
+# - Rebuild within 2 days: Uses local cache, ~5x faster
+# - After cache expires: Auto-downloads latest versions
 
 # Custom image name and version
 manyoyo --ib all --in myimage --iv 2.0.0
 # Builds: myimage:2.0.0-all
 
+# Clean images
+manyoyo --ip                         # Clean dangling images and <none> images
+
 # Or build manually (Not recommended)
 iv=1.4.0 && podman build -t localhost/xcanwin/manyoyo:$iv-all -f docker/manyoyo.Dockerfile . --build-arg EXT=all --no-cache
 podman image prune -f
@@ -173,14 +181,18 @@ manyoyo -n docker-dev -m dind -x /bin/bash
 nohup dockerd &
 
 # Now you can use docker commands inside the container
-docker run hello-world
+docker ps -a
 ```
 
 #### Mount Docker socket Development
 
 ```bash
-# Mount Docker socket (dangerous - container can access host)
-manyoyo -n socket-dev -m mdsock -x docker ps
+# Mount Docker socket (dangerous!!! containers can access and execute everything on the host)
+# Create a container mounting /var/run/docker.sock
+manyoyo -n socket-dev -m mdsock -x /bin/bash
+
+# Now you can use docker commands inside the container
+docker ps -a
 ```
 
 ### Command-Line Options
@@ -203,7 +215,8 @@ manyoyo -n socket-dev -m mdsock -x docker ps
 | `-x CMD` | `--sf`, `--shell-full` | Full command (replaces --sp, -s, and --) |
 | `-y CLI` | `--yolo` | Run AI agent without confirmation |
 | `-m MODE` | `--cm`, `--cont-mode` | Set container mode (common, dind, mdsock) |
-| `--ib EXT` | `--image-build` | Build image, EXT is image variant (all, go, common) |
+| `--ib EXT` | `--image-build` | Build image with auto-cache, EXT is image variant |
+| `--ip` | `--image-prune` | Clean dangling images and `<none>` images |
 | `--install NAME` | | Install manyoyo command |
 | `-V` | `--version` | Show version |
 | `-h` | `--help` | Show help |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@xcanwin/manyoyo",
-  "version": "3.1.0",
-  "imageVersion": "1.5.0",
+  "version": "3.4.0",
+  "imageVersion": "1.6.0",
   "description": "AI Agent CLI Security Sandbox",
   "keywords": [
     "ai", "agent", "sandbox", "docker", "cli", "container", "development"