@xcanwin/manyoyo 2.2.1 → 3.0.1

package/README.md

@@ -1,19 +1,23 @@
+[English](docs/README_EN.md) | [ [中文](README.md) ]
+
+---
+
 # MANYOYO（慢悠悠）
 
 **MANYOYO** 是一款 AI 智能体提效安全沙箱，安全、高效、省 token，专为 Agent YOLO 模式设计，保障宿主机安全。
 
-预装常见 Agent 与工具，进一步节省 token。循环自由切换 Agent 和 /bin/bash，进一步提效。
+预装常见 Agent 与工具，进一步节省 token。循环自由切换 Agent 和 `/bin/bash`，进一步提效。
 
-MANYOYO provides an isolated Docker/Podman container environment for running AI agent CLIs safely.
+**MANYOYO** 提供隔离的 Docker/Podman 容器环境，用于安全运行 AI 智能体命令行工具。
 
 ## 功能亮点
 
-- **多Agent**：支持 claude code, gemini, codex, opencode
+- **多智能体支持**：支持 claude code, gemini, codex, opencode
 - **安全隔离**：保护宿主机，支持安全容器嵌套（Docker-in-Docker）
-- **高效启动**：快捷开启常见 Agent YOLO / SOLO 模式（例如 claude --dangerously-skip-permissions）
+- **快速启动**：快捷开启常见 Agent YOLO / SOLO 模式（例如 claude --dangerously-skip-permissions）
 - **便捷操作**：快速进入 `/bin/bash`
 - **会话恢复**：安装 Skills Marketplace 可快速恢复会话
-- **自定义灵活**：支持自定义 `BASEURL`、`AUTH_TOKEN` 等变量
+- **灵活自定义**：支持自定义 `BASEURL`、`AUTH_TOKEN` 等变量
 - **配置管理**：快捷导入配置文件
 - **高级模式**：支持危险容器嵌套（mount-docker-socket）、自定义沙箱镜像
 
@@ -25,7 +29,7 @@ MANYOYO provides an isolated Docker/Podman container environment for running AI
 
 ## 2. 编译镜像
 
-```
+```bash
 podman pull ubuntu:24.04
 iv=1.4.0-all && podman build -t localhost/xcanwin/manyoyo:$iv -f docker/manyoyo.Dockerfile . --build-arg EXT=all --no-cache
 podman image prune -f
@@ -33,13 +37,13 @@ podman image prune -f
 
 ## 3. 安装 manyoyo（选一种）
 
-### Global Installation (Recommended)
+### 全局安装（推荐）
 
 ```bash
 npm install -g @xcanwin/manyoyo
 ```
 
-### Local Development
+### 本地开发
 
 ```bash
 npm install -g .
@@ -47,57 +51,57 @@ npm install -g .
 
 ## 4. 使用方法
 
-### Basic Commands
+### 基础命令
 
 ```bash
-# Show help
+# 显示帮助
 manyoyo -h
 
-# Show version
+# 显示版本
 manyoyo -V
 
-# List all containers
+# 列出所有容器
 manyoyo -l
 
-# Create new container with environment file
+# 创建新容器并使用环境文件
 manyoyo -n test --ef .env -y c
 
-# Resume existing session
+# 恢复现有会话
 manyoyo -n test -- -c
 
-# Execute command in interactive shell
+# 在交互式 shell 中执行命令
 manyoyo -n test -x /bin/bash
 
-# Execute custom command
+# 执行自定义命令
 manyoyo -n test -x echo "hello world"
 
-# Remove container
+# 删除容器
 manyoyo -n test --rm
 ```
 
-### Environment Variables
+### 环境变量
 
-#### String Format
+#### 字符串格式
 
 ```bash
-# Direct
+# 直接传递
 manyoyo -e "VAR=value" -x env
 
-# Multiple
+# 多个变量
 manyoyo -e "A=1" -e "B=2" -x env
 ```
 
-#### File Format
+#### 文件格式
 
 ```bash
-# From file
+# 从文件加载
 manyoyo --ef .env -x env
 ```
 
-Environment files (`.env`) support the following formats:
+环境文件（`.env`）支持以下格式：
 
 ```bash
-# With export statement
+# 使用 export 语句
 export ANTHROPIC_BASE_URL="https://api.anthropic.com"
 # export CLAUDE_CODE_OAUTH_TOKEN="sk-xxxxxxxx"
 export ANTHROPIC_AUTH_TOKEN="sk-xxxxxxxx"
@@ -108,107 +112,107 @@ export ANTHROPIC_DEFAULT_SONNET_MODEL="claude-sonnet-4-5"
 export ANTHROPIC_DEFAULT_HAIKU_MODEL="claude-haiku-4-5"
 export CLAUDE_CODE_SUBAGENT_MODEL="claude-sonnet-4-5"
 
-# Simple key=value
+# 简单的键值对
 API_KEY=your-api-key-here
 
-# Quoted values (quotes will be stripped)
+# 带引号的值（引号会被移除）
 MESSAGE="Hello World"
 PATH='/usr/local/bin'
 ```
 
-### AI CLI Shortcuts (skip permissions)
+### AI CLI 快捷方式（跳过权限确认）
 
 ```bash
 # Claude Code
-manyoyo -y c          # or: claude, cc
+manyoyo -y c          # 或: claude, cc
 
 # Gemini
-manyoyo -y gm         # or: gemini, g
+manyoyo -y gm         # 或: gemini, g
 
 # Codex
-manyoyo -y cx         # or: codex
+manyoyo -y cx         # 或: codex
 
 # OpenCode
-manyoyo -y oc         # or: opencode
+manyoyo -y oc         # 或: opencode
 ```
 
-### Interactive Session Management
+### 交互式会话管理
 
-After exiting a container session, you'll be prompted with options:
+退出容器会话后，系统将提示您选择操作：
 
-- `y` - Keep container running in background (default)
-- `n` - Delete the container
-- `1` - Re-enter with the original command
-- `s` - Execute a new command
-- `i` - Enter interactive shell
+- `y` - 保持容器在后台运行（默认）
+- `n` - 删除容器
+- `1` - 使用首次命令重新进入
+- `x` - 执行新命令
+- `i` - 进入交互式 shell
 
-### Container Modes
+### 容器模式
 
-#### Docker-in-Docker Development
+#### Docker-in-Docker 开发
 
 ```bash
-# Docker-in-Docker (safe nested containers)
-# Create a container with Docker-in-Docker support
+# Docker-in-Docker（安全的嵌套容器）
+# 创建支持 Docker-in-Docker 的容器
 manyoyo -n docker-dev -m dind -x /bin/bash
 
-# Inside the container, start dockerd
+# 在容器内启动 dockerd
 nohup dockerd &
 
-# Now you can use docker commands inside the container
+# 现在可以在容器内使用 docker 命令
 docker run hello-world
 ```
 
-#### Mount Docker socket Development
+#### 挂载 Docker Socket 开发
 
 ```bash
-# Mount Docker socket (dangerous - container can access host)
+# 挂载 Docker Socket（危险 - 容器可以访问宿主机）
 manyoyo -n socket-dev -m mdsock -x docker ps
 ```
 
-### Command-Line Options
-
-| Option | Aliases | Description |
-|--------|---------|-------------|
-| `-l` | `--ls`, `--list` | List all manyoyo containers |
-| `--hp PATH` | `--host-path` | Set host working directory (default: current path) |
-| `-n NAME` | `--cn`, `--cont-name` | Set container name |
-| `--cp PATH` | `--cont-path` | Set container working directory |
-| `--in NAME` | `--image-name` | Specify image name |
-| `--iv VERSION` | `--image-ver` | Specify image version |
-| `-e STRING` | `--env` | Set environment variable |
-| `--ef FILE` | `--env-file` | Load environment variables from file |
-| `-v STRING` | `--volume` | Bind mount volume |
-| `--rm` | `--rmc`, `--remove-cont` | Remove container |
-| `--sp CMD` | `--shell-prefix` | Temporary environment variable (prefix for -s) |
-| `-s CMD` | `--shell` | Specify command to execute |
-| `--` | `--ss`, `--shell-suffix` | Command arguments (suffix for -s) |
-| `-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) |
-| `--install NAME` | | Install manyoyo command |
-| `-V` | `--version` | Show version |
-| `-h` | `--help` | Show help |
+### 命令行选项
+
+| 选项 | 别名 | 描述 |
+|------|------|------|
+| `-l` | `--ls`, `--list` | 列出所有 manyoyo 容器 |
+| `--hp PATH` | `--host-path` | 设置宿主机工作目录（默认：当前路径） |
+| `-n NAME` | `--cn`, `--cont-name` | 设置容器名称 |
+| `--cp PATH` | `--cont-path` | 设置容器工作目录 |
+| `--in NAME` | `--image-name` | 指定镜像名称 |
+| `--iv VERSION` | `--image-ver` | 指定镜像版本 |
+| `-e STRING` | `--env` | 设置环境变量 |
+| `--ef FILE` | `--env-file` | 从文件加载环境变量 |
+| `-v STRING` | `--volume` | 绑定挂载卷 |
+| `--rm` | `--rmc`, `--remove-cont` | 删除容器 |
+| `--sp CMD` | `--shell-prefix` | 临时环境变量（作为 -s 的前缀） |
+| `-s CMD` | `--shell` | 指定要执行的命令 |
+| `--` | `--ss`, `--shell-suffix` | 命令参数（作为 -s 的后缀） |
+| `-x CMD` | `--sf`, `--shell-full` | 完整命令（替代 --sp, -s 和 --） |
+| `-y CLI` | `--yolo` | 无需确认运行 AI 智能体 |
+| `-m MODE` | `--cm`, `--cont-mode` | 设置容器模式（common, dind, mdsock） |
+| `--install NAME` | | 安装 manyoyo 命令 |
+| `-V` | `--version` | 显示版本 |
+| `-h` | `--help` | 显示帮助 |
 
 ## 其他说明
 
-### Default Configuration
+### 默认配置
 
-- **Container Name**: `myy-{MMDD-HHMM}` (auto-generated based on current time)
-- **Host Path**: Current working directory
-- **Container Path**: Same as host path
-- **Image**: `localhost/xcanwin/manyoyo:xxx`
+- **容器名称**：`myy-{月日-时分}`（基于当前时间自动生成）
+- **宿主机路径**：当前工作目录
+- **容器路径**：与宿主机路径相同
+- **镜像**：`localhost/xcanwin/manyoyo:xxx`
 
-### Requirements
+### 系统要求
 
-- Node.js >= 14.0.0
-- Docker or Podman
+- Node.js >= 24.0.0
+- Docker 或 Podman
 
-### Remove
+### 卸载
 
 ```bash
 npm uninstall -g @xcanwin/manyoyo
 ```
 
-## License
+## 许可证
 
 MIT

package/bin/manyoyo.js

@@ -47,7 +47,19 @@ const NC = '\x1b[0m'; // No Color
 // Docker command (will be set by ensure_docker)
 let DOCKER_CMD = 'docker';
 
-function show_help() {
+// ==============================================================================
+// Utility Functions
+// ==============================================================================
+
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// ==============================================================================
+// UI Functions
+// ==============================================================================
+
+function showHelp() {
     console.log(`${BLUE}Usage:${NC}`);
     console.log(`  ${MANYOYO_NAME} [OPTIONS]`);
     console.log(`  ${MANYOYO_NAME} [--hp HOST_PATH] [-n CONTAINER_NAME] [--cp CONTAINER_PATH] [--ef ENV_FILE] [--sp COMMAND] [-s COMMAND] [-- COMMAND]`);
@@ -84,41 +96,80 @@ function show_help() {
     console.log(`  ${MANYOYO_NAME} -n test -x claude -c                恢复之前会话`);
 }
 
-function ensure_docker() {
-    try {
-        execSync('docker --version', { stdio: 'pipe' });
-        DOCKER_CMD = 'docker';
-        return true;
-    } catch (e) {
-        try {
-            execSync('podman --version', { stdio: 'pipe' });
-            DOCKER_CMD = 'podman';
-            return true;
-        } catch (e2) {
-            console.error("docker/podman not found");
-            process.exit(1);
-        }
-    }
+function showVersion() {
+    console.log(`manyoyo by xcanwin, ${BIN_VERSION}`);
 }
 
-function install_manyoyo(name) {
-    const MANYOYO_FILE = fs.realpathSync(__filename);
-    switch (name) {
-        case 'docker-cli-plugin':
-            execSync(`mkdir -p "$HOME/.docker/cli-plugins/"`, { stdio: 'inherit' });
-            execSync(`ln -f -s "${MANYOYO_FILE}" "$HOME/.docker/cli-plugins/docker-manyoyo"`, { stdio: 'inherit' });
-            break;
-        default:
-            console.log("");
+function getHelloTip(containerName, defaultCommand) {
+    console.log(`${BLUE}----------------------------------------${NC}`);
+    console.log(`📦 首次命令        : ${defaultCommand}`);
+    console.log(`⚫ 恢复首次命令会话: ${CYAN}${MANYOYO_NAME} -n ${containerName} -- -c${NC}`);
+    console.log(`⚫ 执行首次命令    : ${GREEN}${MANYOYO_NAME} -n ${containerName}${NC}`);
+    console.log(`⚫ 执行指定命令    : ${GREEN}${MANYOYO_NAME} -n ${containerName} -x /bin/bash${NC}`);
+    console.log(`⚫ 执行指定命令    : ${GREEN}docker exec -it ${containerName} /bin/bash${NC}`);
+    console.log(`⚫ 删除容器        : ${MANYOYO_NAME} -n ${containerName} --rm`);
+    console.log("");
+}
+
+async function askQuestion(prompt) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    return new Promise((resolve) => {
+        rl.question(prompt, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+
+// ==============================================================================
+// Configuration Functions
+// ==============================================================================
+
+function addEnv(env) {
+    CONTAINER_ENVS.push("--env", env);
+}
+
+function addEnvFile(envFile) {
+    ENV_FILE = envFile;
+    if (ENV_FILE && fs.existsSync(ENV_FILE)) {
+        const content = fs.readFileSync(ENV_FILE, 'utf-8');
+        const lines = content.split('\n');
+
+        for (let line of lines) {
+            // Match pattern: (export )?(KEY)=(VALUE)
+            const match = line.match(/^(?:export\s+)?([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.*)$/);
+            if (match) {
+                let key = match[1];
+                let value = match[2].trim();
+
+                // Filter malicious characters
+                if (/[\$\(\)\`\|\&\*\{\}]/.test(value)) continue;
+                if (/^\(/.test(value)) continue;
+
+                // Remove quotes
+                if (/^"(.*)"$/.test(value)) {
+                    value = value.slice(1, -1);
+                } else if (/^'(.*)'$/.test(value)) {
+                    value = value.slice(1, -1);
+                }
+
+                if (key) {
+                    CONTAINER_ENVS.push("--env", `${key}=${value}`);
+                }
+            }
+        }
     }
-    process.exit(0);
 }
 
-function show_version() {
-    console.log(`manyoyo by xcanwin, ${BIN_VERSION}`);
+function addVolume(volume) {
+    CONTAINER_VOLUMES.push("--volume", volume);
 }
 
-function set_yolo(cli) {
+function setYolo(cli) {
     switch (cli) {
         case 'claude':
         case 'cc':
@@ -144,7 +195,7 @@ function set_yolo(cli) {
     }
 }
 
-function set_cont_mode(mode) {
+function setContMode(mode) {
     switch (mode) {
         case 'common':
             CONT_MODE = "";
@@ -167,105 +218,96 @@ function set_cont_mode(mode) {
     }
 }
 
-function get_cont_list() {
+// ==============================================================================
+// Docker Helper Functions
+// ==============================================================================
+
+function dockerExec(cmd, options = {}) {
     try {
-        const result = execSync(`${DOCKER_CMD} ps -a --size --filter "ancestor=manyoyo" --filter "ancestor=$(${DOCKER_CMD} images -a --format '{{.Repository}}:{{.Tag}}' | grep manyoyo)" --format "table {{.Names}}\\t{{.Status}}\\t{{.Size}}\\t{{.ID}}\\t{{.Image}}\\t{{.Ports}}\\t{{.Networks}}\\t{{.Mounts}}"`,
-            { encoding: 'utf-8' });
-        console.log(result);
+        return execSync(cmd, { encoding: 'utf-8', ...options });
     } catch (e) {
-        console.log(e.stdout || '');
+        if (options.ignoreError) {
+            return e.stdout || '';
+        }
+        throw e;
     }
 }
 
-function add_volume(volume) {
-    CONTAINER_VOLUMES.push("--volume", volume);
+function containerExists(name) {
+    const containers = dockerExec(`${DOCKER_CMD} ps -a --format '{{.Names}}'`);
+    return containers.split('\n').some(n => n.trim() === name);
 }
 
-function add_env(env) {
-    CONTAINER_ENVS.push("--env", env);
+function getContainerStatus(name) {
+    return dockerExec(`${DOCKER_CMD} inspect -f '{{.State.Status}}' "${name}"`).trim();
 }
 
-function add_env_file(envFile) {
-    ENV_FILE = envFile;
-    if (ENV_FILE && fs.existsSync(ENV_FILE)) {
-        const content = fs.readFileSync(ENV_FILE, 'utf-8');
-        const lines = content.split('\n');
-
-        for (let line of lines) {
-            // Match pattern: (export )?(KEY)=(VALUE)
-            const match = line.match(/^(?:export\s+)?([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.*)$/);
-            if (match) {
-                let key = match[1];
-                let value = match[2].trim();
-
-                // Filter malicious characters
-                if (/[\$\(\)\`\|\&\*\{\}]/.test(value)) continue;
-                if (/^\(/.test(value)) continue;
+function removeContainer(name) {
+    console.log(`${YELLOW}🗑️ 正在删除容器: ${name}...${NC}`);
+    dockerExec(`${DOCKER_CMD} rm -f "${name}"`, { stdio: 'pipe' });
+    console.log(`${GREEN}✅ 已彻底删除。${NC}`);
+}
 
-                // Remove quotes
-                if (/^"(.*)"$/.test(value)) {
-                    value = value.slice(1, -1);
-                } else if (/^'(.*)'$/.test(value)) {
-                    value = value.slice(1, -1);
-                }
+// ==============================================================================
+// Docker Operations
+// ==============================================================================
 
-                if (key) {
-                    CONTAINER_ENVS.push("--env", `${key}=${value}`);
-                }
-            }
+function ensureDocker() {
+    const commands = ['docker', 'podman'];
+    for (const cmd of commands) {
+        try {
+            execSync(`${cmd} --version`, { stdio: 'pipe' });
+            DOCKER_CMD = cmd;
+            return true;
+        } catch (e) {
+            // Try next command
         }
     }
+    console.error("docker/podman not found");
+    process.exit(1);
 }
 
-function get_hello_tip(containerName, defaultCommand) {
-    console.log(`${BLUE}----------------------------------------${NC}`);
-    console.log(`📦 首次命令        : ${defaultCommand}`);
-    console.log(`⚫ 恢复首次命令会话: ${CYAN}${MANYOYO_NAME} -n ${containerName} -- -c${NC}`);
-    console.log(`⚫ 执行首次命令    : ${GREEN}${MANYOYO_NAME} -n ${containerName}${NC}`);
-    console.log(`⚫ 执行指定命令    : ${GREEN}${MANYOYO_NAME} -n ${containerName} -x /bin/bash${NC}`);
-    console.log(`⚫ 执行指定命令    : ${GREEN}docker exec -it ${containerName} /bin/bash${NC}`);
-    console.log(`⚫ 删除容器        : ${MANYOYO_NAME} -n ${containerName} --rm`);
-    console.log("");
+function installManyoyo(name) {
+    const MANYOYO_FILE = fs.realpathSync(__filename);
+    switch (name) {
+        case 'docker-cli-plugin':
+            const pluginDir = path.join(process.env.HOME, '.docker/cli-plugins');
+            fs.mkdirSync(pluginDir, { recursive: true });
+            const targetPath = path.join(pluginDir, 'docker-manyoyo');
+            if (fs.existsSync(targetPath)) {
+                fs.unlinkSync(targetPath);
+            }
+            fs.symlinkSync(MANYOYO_FILE, targetPath);
+            break;
+        default:
+            console.log("");
+    }
+    process.exit(0);
 }
 
-function docker_exec(cmd, options = {}) {
+function getContList() {
     try {
-        return execSync(cmd, { encoding: 'utf-8', ...options });
+        const result = execSync(`${DOCKER_CMD} ps -a --size --filter "ancestor=manyoyo" --filter "ancestor=$(${DOCKER_CMD} images -a --format '{{.Repository}}:{{.Tag}}' | grep manyoyo)" --format "table {{.Names}}\\t{{.Status}}\\t{{.Size}}\\t{{.ID}}\\t{{.Image}}\\t{{.Ports}}\\t{{.Networks}}\\t{{.Mounts}}"`,
+            { encoding: 'utf-8' });
+        console.log(result);
     } catch (e) {
-        if (options.ignoreError) {
-            return e.stdout || '';
-        }
-        throw e;
+        console.log(e.stdout || '');
     }
 }
 
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-async function askQuestion(prompt) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
-    });
-
-    return new Promise((resolve) => {
-        rl.question(prompt, (answer) => {
-            rl.close();
-            resolve(answer);
-        });
-    });
-}
+// ==============================================================================
+// Main Function Helpers
+// ==============================================================================
 
-async function main() {
+function validateAndInitialize() {
     // Check if no arguments provided
     if (process.argv.length <= 2) {
-        show_help();
+        showHelp();
         process.exit(1);
     }
 
     // Ensure docker/podman is available
-    ensure_docker();
+    ensureDocker();
 
     // Docker CLI plugin metadata
     if (process.argv[2] === 'docker-cli-plugin-metadata') {
@@ -278,13 +320,15 @@ async function main() {
         console.log(JSON.stringify(metadata, null, 2));
         process.exit(0);
     }
+}
 
+function parseArguments(argv) {
     // Parse arguments
-    let args = process.argv.slice(2);
+    let args = argv.slice(2);
 
     // Docker CLI plugin mode - remove first arg if running as plugin
     const dockerPluginPath = path.join(process.env.HOME || '', '.docker/cli-plugins/docker-manyoyo');
-    if (process.argv[1] === dockerPluginPath && args[0] === 'manyoyo') {
+    if (argv[1] === dockerPluginPath && args[0] === 'manyoyo') {
         args.shift();
     }
 
@@ -297,7 +341,7 @@ async function main() {
             case '-l':
             case '--ls':
             case '--list':
-                get_cont_list();
+                getContList();
                 process.exit(0);
 
             case '--hp':
@@ -333,19 +377,19 @@ async function main() {
 
             case '-e':
             case '--env':
-                add_env(args[i + 1]);
+                addEnv(args[i + 1]);
                 i += 2;
                 break;
 
             case '--ef':
             case '--env-file':
-                add_env_file(args[i + 1]);
+                addEnvFile(args[i + 1]);
                 i += 2;
                 break;
 
             case '-v':
             case '--volume':
-                add_volume(args[i + 1]);
+                addVolume(args[i + 1]);
                 i += 2;
                 break;
 
@@ -384,46 +428,44 @@ async function main() {
 
             case '-y':
             case '--yolo':
-                set_yolo(args[i + 1]);
+                setYolo(args[i + 1]);
                 i += 2;
                 break;
 
             case '-m':
             case '--cm':
             case '--cont-mode':
-                set_cont_mode(args[i + 1]);
+                setContMode(args[i + 1]);
                 i += 2;
                 break;
 
             case '--install':
-                install_manyoyo(args[i + 1]);
+                installManyoyo(args[i + 1]);
                 process.exit(0);
 
             case '-V':
             case '--version':
-                show_version();
+                showVersion();
                 process.exit(0);
 
             case '-h':
             case '--help':
-                show_help();
+                showHelp();
                 process.exit(0);
 
             default:
                 console.log(`${RED}⚠️ 未知参数: ${arg}${NC}`);
-                show_help();
+                showHelp();
                 process.exit(1);
         }
     }
+}
 
-    // Handle remove logic
+function handleRemoveContainer() {
     if (SHOULD_REMOVE) {
         try {
-            const containers = docker_exec(`${DOCKER_CMD} ps -a --format '{{.Names}}'`);
-            if (containers.split('\n').some(name => name.trim() === CONTAINER_NAME)) {
-                console.log(`${YELLOW}🗑️ 正在删除容器: ${CONTAINER_NAME}...${NC}`);
-                docker_exec(`${DOCKER_CMD} rm -f "${CONTAINER_NAME}"`, { stdio: 'pipe' });
-                console.log(`${GREEN}✅ 已彻底删除。${NC}`);
+            if (containerExists(CONTAINER_NAME)) {
+                removeContainer(CONTAINER_NAME);
             } else {
                 console.log(`${RED}⚠️ 错误: 未找到名为 ${CONTAINER_NAME} 的容器。${NC}`);
             }
@@ -432,136 +474,179 @@ async function main() {
         }
         process.exit(0);
     }
+}
 
-    // Safety check
+function validateHostPath() {
     const realHostPath = fs.realpathSync(HOST_PATH);
     const homeDir = process.env.HOME || '/home';
     if (realHostPath === '/' || realHostPath === '/home' || realHostPath === homeDir) {
         console.log(`${RED}⚠️ 错误: 不允许挂载根目录或home目录。${NC}`);
         process.exit(1);
     }
+}
 
-    const FULL_IMAGE = `${IMAGE_NAME}:${IMAGE_VERSION}`;
-    let DEFAULT_COMMAND = "";
+async function waitForContainerReady(containerName) {
+    const MAX_RETRIES = 50;
+    let count = 0;
+    while (true) {
+        try {
+            const status = getContainerStatus(containerName);
 
-    // Check if container exists
-    try {
-        const containers = docker_exec(`${DOCKER_CMD} ps -a --format '{{.Names}}'`);
-        const containerExists = containers.split('\n').some(name => name.trim() === CONTAINER_NAME);
-
-        if (!containerExists) {
-            // Create new container
-            console.log(`${CYAN}📦 manyoyo by xcanwin 正在创建新容器: ${YELLOW}${CONTAINER_NAME}${NC}\n`);
-            EXEC_COMMAND = `${EXEC_COMMAND_PREFIX}${EXEC_COMMAND}${EXEC_COMMAND_SUFFIX}`;
-            DEFAULT_COMMAND = EXEC_COMMAND;
-
-            // Build docker run command
-            const envArgs = CONTAINER_ENVS.join(' ');
-            const volumeArgs = CONTAINER_VOLUMES.join(' ');
-            const contModeArg = CONT_MODE ? CONT_MODE : '';
-
-            const dockerRunCmd = `${DOCKER_CMD} run -d --name "${CONTAINER_NAME}" --entrypoint "" ${contModeArg} ${envArgs} ${volumeArgs} --volume "${HOST_PATH}:${CONTAINER_PATH}" --workdir "${CONTAINER_PATH}" --label "manyoyo.default_cmd=${EXEC_COMMAND}" "${FULL_IMAGE}" tail -f /dev/null`;
-
-            docker_exec(dockerRunCmd, { stdio: 'pipe' });
-
-            // Wait for container to be ready
-            const MAX_RETRIES = 50;
-            let count = 0;
-            while (true) {
-                try {
-                    const status = docker_exec(`${DOCKER_CMD} inspect -f '{{.State.Status}}' "${CONTAINER_NAME}"`).trim();
-
-                    if (status === 'running') {
-                        break;
-                    }
-
-                    if (status === 'exited') {
-                        console.log(`${RED}⚠️ 错误: 容器启动后立即退出。${NC}`);
-                        docker_exec(`${DOCKER_CMD} logs "${CONTAINER_NAME}"`, { stdio: 'inherit' });
-                        process.exit(1);
-                    }
-
-                    await sleep(100);
-                    count++;
-
-                    if (count >= MAX_RETRIES) {
-                        console.log(`${RED}⚠️ 错误: 容器启动超时（当前状态: ${status}）。${NC}`);
-                        docker_exec(`${DOCKER_CMD} logs "${CONTAINER_NAME}"`, { stdio: 'inherit' });
-                        process.exit(1);
-                    }
-                } catch (e) {
-                    await sleep(100);
-                    count++;
-                    if (count >= MAX_RETRIES) {
-                        console.log(`${RED}⚠️ 错误: 容器启动超时。${NC}`);
-                        process.exit(1);
-                    }
-                }
+            if (status === 'running') {
+                break;
             }
-        } else {
-            // Container exists
-            console.log(`${CYAN}🔄 manyoyo by xcanwin 正在连接到现有容器: ${YELLOW}${CONTAINER_NAME}${NC}`);
-
-            // Start container if stopped
-            const status = docker_exec(`${DOCKER_CMD} inspect -f '{{.State.Status}}' "${CONTAINER_NAME}"`).trim();
-            if (status !== 'running') {
-                docker_exec(`${DOCKER_CMD} start "${CONTAINER_NAME}"`, { stdio: 'pipe' });
+
+            if (status === 'exited') {
+                console.log(`${RED}⚠️ 错误: 容器启动后立即退出。${NC}`);
+                dockerExec(`${DOCKER_CMD} logs "${containerName}"`, { stdio: 'inherit' });
+                process.exit(1);
             }
 
-            // Get default command from label
-            DEFAULT_COMMAND = docker_exec(`${DOCKER_CMD} inspect -f '{{index .Config.Labels "manyoyo.default_cmd"}}' "${CONTAINER_NAME}"`).trim();
+            await sleep(100);
+            count++;
 
-            if (!EXEC_COMMAND) {
-                EXEC_COMMAND = `${EXEC_COMMAND_PREFIX}${DEFAULT_COMMAND}${EXEC_COMMAND_SUFFIX}`;
-            } else {
-                EXEC_COMMAND = `${EXEC_COMMAND_PREFIX}${EXEC_COMMAND}${EXEC_COMMAND_SUFFIX}`;
+            if (count >= MAX_RETRIES) {
+                console.log(`${RED}⚠️ 错误: 容器启动超时（当前状态: ${status}）。${NC}`);
+                dockerExec(`${DOCKER_CMD} logs "${containerName}"`, { stdio: 'inherit' });
+                process.exit(1);
+            }
+        } catch (e) {
+            await sleep(100);
+            count++;
+            if (count >= MAX_RETRIES) {
+                console.log(`${RED}⚠️ 错误: 容器启动超时。${NC}`);
+                process.exit(1);
             }
         }
+    }
+}
 
-        get_hello_tip(CONTAINER_NAME, DEFAULT_COMMAND);
-        console.log(`${BLUE}----------------------------------------${NC}`);
-        console.log(`💻 执行命令: ${YELLOW}${EXEC_COMMAND || '交互式 Shell'}${NC}`);
+async function createNewContainer() {
+    console.log(`${CYAN}📦 manyoyo by xcanwin 正在创建新容器: ${YELLOW}${CONTAINER_NAME}${NC}\n`);
 
-        // Execute command in container
-        if (EXEC_COMMAND) {
-            spawnSync(`${DOCKER_CMD}`, ['exec', '-it', CONTAINER_NAME, '/bin/bash', '-c', EXEC_COMMAND], { stdio: 'inherit' });
-        } else {
-            spawnSync(`${DOCKER_CMD}`, ['exec', '-it', CONTAINER_NAME, '/bin/bash'], { stdio: 'inherit' });
-        }
+    EXEC_COMMAND = `${EXEC_COMMAND_PREFIX}${EXEC_COMMAND}${EXEC_COMMAND_SUFFIX}`;
+    const defaultCommand = EXEC_COMMAND;
 
-        // Post-exit prompt
-        console.log("");
-        get_hello_tip(CONTAINER_NAME, DEFAULT_COMMAND);
-
-        const reply = await askQuestion(`❔ 会话已结束。是否保留此后台容器 ${CONTAINER_NAME}? [ y=默认保留, n=删除, 1=首次命令进入, s=执行命令, i=交互式SHELL ]: `);
-        console.log("");
-
-        const firstChar = reply.trim().toLowerCase()[0];
-
-        if (firstChar === 'n') {
-            console.log(`${YELLOW}🗑️ 正在删除容器...${NC}`);
-            docker_exec(`${DOCKER_CMD} rm -f "${CONTAINER_NAME}"`, { stdio: 'pipe' });
-            console.log(`${GREEN}✅ 已彻底删除。${NC}`);
-        } else if (firstChar === '1') {
-            console.log(`${GREEN}✅ 离开当前连接，用首次命令进入。${NC}`);
-            // Reconstruct the command and execute recursively
-            const newArgs = ['-n', CONTAINER_NAME];
-            process.argv = [process.argv[0], process.argv[1], ...newArgs];
-            await main();
-        } else if (firstChar === 's') {
-            const command = await askQuestion('❔ 输入要执行的命令: ');
-            console.log(`${GREEN}✅ 离开当前连接，执行命令。${NC}`);
-            const newArgs = ['-n', CONTAINER_NAME, '-x', command];
-            process.argv = [process.argv[0], process.argv[1], ...newArgs];
-            await main();
-        } else if (firstChar === 'i') {
-            console.log(`${GREEN}✅ 离开当前连接，进入容器交互式SHELL。${NC}`);
-            const newArgs = ['-n', CONTAINER_NAME, '-x', '/bin/bash'];
-            process.argv = [process.argv[0], process.argv[1], ...newArgs];
-            await main();
-        } else {
-            console.log(`${GREEN}✅ 已退出连接。容器 ${CONTAINER_NAME} 仍在后台运行。${NC}`);
-        }
+    // Build docker run command
+    const fullImage = `${IMAGE_NAME}:${IMAGE_VERSION}`;
+    const envArgs = CONTAINER_ENVS.join(' ');
+    const volumeArgs = CONTAINER_VOLUMES.join(' ');
+    const contModeArg = CONT_MODE || '';
+
+    const dockerRunCmd = `${DOCKER_CMD} run -d --name "${CONTAINER_NAME}" --entrypoint "" ${contModeArg} ${envArgs} ${volumeArgs} --volume "${HOST_PATH}:${CONTAINER_PATH}" --workdir "${CONTAINER_PATH}" --label "manyoyo.default_cmd=${EXEC_COMMAND}" "${fullImage}" tail -f /dev/null`;
+
+    dockerExec(dockerRunCmd, { stdio: 'pipe' });
+
+    // Wait for container to be ready
+    await waitForContainerReady(CONTAINER_NAME);
+
+    return defaultCommand;
+}
+
+async function connectExistingContainer() {
+    console.log(`${CYAN}🔄 manyoyo by xcanwin 正在连接到现有容器: ${YELLOW}${CONTAINER_NAME}${NC}`);
+
+    // Start container if stopped
+    const status = getContainerStatus(CONTAINER_NAME);
+    if (status !== 'running') {
+        dockerExec(`${DOCKER_CMD} start "${CONTAINER_NAME}"`, { stdio: 'pipe' });
+    }
+
+    // Get default command from label
+    const defaultCommand = dockerExec(`${DOCKER_CMD} inspect -f '{{index .Config.Labels "manyoyo.default_cmd"}}' "${CONTAINER_NAME}"`).trim();
+
+    if (!EXEC_COMMAND) {
+        EXEC_COMMAND = `${EXEC_COMMAND_PREFIX}${defaultCommand}${EXEC_COMMAND_SUFFIX}`;
+    } else {
+        EXEC_COMMAND = `${EXEC_COMMAND_PREFIX}${EXEC_COMMAND}${EXEC_COMMAND_SUFFIX}`;
+    }
+
+    return defaultCommand;
+}
+
+async function setupContainer() {
+    if (!containerExists(CONTAINER_NAME)) {
+        return await createNewContainer();
+    } else {
+        return await connectExistingContainer();
+    }
+}
+
+function executeInContainer(defaultCommand) {
+    getHelloTip(CONTAINER_NAME, defaultCommand);
+    console.log(`${BLUE}----------------------------------------${NC}`);
+    console.log(`💻 执行命令: ${YELLOW}${EXEC_COMMAND || '交互式 Shell'}${NC}`);
+
+    // Execute command in container
+    if (EXEC_COMMAND) {
+        spawnSync(`${DOCKER_CMD}`, ['exec', '-it', CONTAINER_NAME, '/bin/bash', '-c', EXEC_COMMAND], { stdio: 'inherit' });
+    } else {
+        spawnSync(`${DOCKER_CMD}`, ['exec', '-it', CONTAINER_NAME, '/bin/bash'], { stdio: 'inherit' });
+    }
+}
+
+async function handlePostExit(defaultCommand) {
+    console.log("");
+    getHelloTip(CONTAINER_NAME, defaultCommand);
+
+    const reply = await askQuestion(`❔ 会话已结束。是否保留此后台容器 ${CONTAINER_NAME}? [ y=默认保留, n=删除, 1=首次命令进入, x=执行命令, i=交互式SHELL ]: `);
+    console.log("");
+
+    const firstChar = reply.trim().toLowerCase()[0];
+
+    if (firstChar === 'n') {
+        removeContainer(CONTAINER_NAME);
+    } else if (firstChar === '1') {
+        console.log(`${GREEN}✅ 离开当前连接，用首次命令进入。${NC}`);
+        // Reset command variables to use default command
+        EXEC_COMMAND = "";
+        EXEC_COMMAND_PREFIX = "";
+        EXEC_COMMAND_SUFFIX = "";
+        const newArgs = ['-n', CONTAINER_NAME];
+        process.argv = [process.argv[0], process.argv[1], ...newArgs];
+        await main();
+    } else if (firstChar === 'x') {
+        const command = await askQuestion('❔ 输入要执行的命令: ');
+        console.log(`${GREEN}✅ 离开当前连接，执行命令。${NC}`);
+        const newArgs = ['-n', CONTAINER_NAME, '-x', command];
+        process.argv = [process.argv[0], process.argv[1], ...newArgs];
+        await main();
+    } else if (firstChar === 'i') {
+        console.log(`${GREEN}✅ 离开当前连接，进入容器交互式SHELL。${NC}`);
+        const newArgs = ['-n', CONTAINER_NAME, '-x', '/bin/bash'];
+        process.argv = [process.argv[0], process.argv[1], ...newArgs];
+        await main();
+    } else {
+        console.log(`${GREEN}✅ 已退出连接。容器 ${CONTAINER_NAME} 仍在后台运行。${NC}`);
+    }
+}
+
+// ==============================================================================
+// Main Function
+// ==============================================================================
+
+async function main() {
+    try {
+        // 1. Validate and initialize
+        validateAndInitialize();
+
+        // 2. Parse command-line arguments
+        parseArguments(process.argv);
+
+        // 3. Handle remove container operation
+        handleRemoveContainer();
+
+        // 4. Validate host path safety
+        validateHostPath();
+
+        // 5. Setup container (create or connect)
+        const defaultCommand = await setupContainer();
+
+        // 6. Execute command in container
+        executeInContainer(defaultCommand);
+
+        // 7. Handle post-exit interactions
+        await handlePostExit(defaultCommand);
 
     } catch (e) {
         console.error(`${RED}Error: ${e.message}${NC}`);

package/docs/README_EN.md

@@ -0,0 +1,218 @@
+[ [English](README_EN.md) ] | [中文](../README.md)
+
+---
+
+# MANYOYO (Man-Yo-Yo)
+
+**MANYOYO** is an AI agent security sandbox that is safe, efficient, and token-saving. Designed specifically for Agent YOLO mode to protect the host machine.
+
+Pre-installed with common agents and tools to further save tokens. Freely switch between agents and `/bin/bash` in a loop for enhanced efficiency.
+
+**MANYOYO** provides an isolated Docker/Podman container environment for running AI agent CLIs safely.
+
+## Key Features
+
+- **Multi-Agent Support**: Supports claude code, gemini, codex, opencode
+- **Security Isolation**: Protects host machine, supports safe nested containers (Docker-in-Docker)
+- **Quick Launch**: Quickly enable common Agent YOLO / SOLO mode (e.g., claude --dangerously-skip-permissions)
+- **Convenient Operations**: Quick access to `/bin/bash`
+- **Session Recovery**: Install Skills Marketplace to quickly resume sessions
+- **Flexible Customization**: Support custom `BASEURL`, `AUTH_TOKEN`, and other variables
+- **Configuration Management**: Quick import of configuration files
+- **Advanced Mode**: Supports dangerous nested containers (mount-docker-socket), custom sandbox images
+
+# Usage
+
+## 1. Install podman
+
+- Install [podman](https://podman.io/docs/installation)
+
+## 2. Build Image
+
+```
+podman pull ubuntu:24.04
+iv=1.4.0-all && podman build -t localhost/xcanwin/manyoyo:$iv -f docker/manyoyo.Dockerfile . --build-arg EXT=all --no-cache
+podman image prune -f
+```
+
+## 3. Install manyoyo (Choose One)
+
+### Global Installation (Recommended)
+
+```bash
+npm install -g @xcanwin/manyoyo
+```
+
+### Local Development
+
+```bash
+npm install -g .
+```
+
+## 4. Usage
+
+### Basic Commands
+
+```bash
+# Show help
+manyoyo -h
+
+# Show version
+manyoyo -V
+
+# List all containers
+manyoyo -l
+
+# Create new container with environment file
+manyoyo -n test --ef .env -y c
+
+# Resume existing session
+manyoyo -n test -- -c
+
+# Execute command in interactive shell
+manyoyo -n test -x /bin/bash
+
+# Execute custom command
+manyoyo -n test -x echo "hello world"
+
+# Remove container
+manyoyo -n test --rm
+```
+
+### Environment Variables
+
+#### String Format
+
+```bash
+# Direct
+manyoyo -e "VAR=value" -x env
+
+# Multiple
+manyoyo -e "A=1" -e "B=2" -x env
+```
+
+#### File Format
+
+```bash
+# From file
+manyoyo --ef .env -x env
+```
+
+Environment files (`.env`) support the following formats:
+
+```bash
+# With export statement
+export ANTHROPIC_BASE_URL="https://api.anthropic.com"
+# export CLAUDE_CODE_OAUTH_TOKEN="sk-xxxxxxxx"
+export ANTHROPIC_AUTH_TOKEN="sk-xxxxxxxx"
+export API_TIMEOUT_MS=3000000
+export ANTHROPIC_MODEL="claude-sonnet-4-5"
+export ANTHROPIC_DEFAULT_OPUS_MODEL="claude-opus-4-5"
+export ANTHROPIC_DEFAULT_SONNET_MODEL="claude-sonnet-4-5"
+export ANTHROPIC_DEFAULT_HAIKU_MODEL="claude-haiku-4-5"
+export CLAUDE_CODE_SUBAGENT_MODEL="claude-sonnet-4-5"
+
+# Simple key=value
+API_KEY=your-api-key-here
+
+# Quoted values (quotes will be stripped)
+MESSAGE="Hello World"
+PATH='/usr/local/bin'
+```
+
+### AI CLI Shortcuts (skip permissions)
+
+```bash
+# Claude Code
+manyoyo -y c          # or: claude, cc
+
+# Gemini
+manyoyo -y gm         # or: gemini, g
+
+# Codex
+manyoyo -y cx         # or: codex
+
+# OpenCode
+manyoyo -y oc         # or: opencode
+```
+
+### Interactive Session Management
+
+After exiting a container session, you'll be prompted with options:
+
+- `y` - Keep container running in background (default)
+- `n` - Delete the container
+- `1` - Re-enter with the original command
+- `x` - Execute a new command
+- `i` - Enter interactive shell
+
+### Container Modes
+
+#### Docker-in-Docker Development
+
+```bash
+# Docker-in-Docker (safe nested containers)
+# Create a container with Docker-in-Docker support
+manyoyo -n docker-dev -m dind -x /bin/bash
+
+# Inside the container, start dockerd
+nohup dockerd &
+
+# Now you can use docker commands inside the container
+docker run hello-world
+```
+
+#### Mount Docker socket Development
+
+```bash
+# Mount Docker socket (dangerous - container can access host)
+manyoyo -n socket-dev -m mdsock -x docker ps
+```
+
+### Command-Line Options
+
+| Option | Aliases | Description |
+|--------|---------|-------------|
+| `-l` | `--ls`, `--list` | List all manyoyo containers |
+| `--hp PATH` | `--host-path` | Set host working directory (default: current path) |
+| `-n NAME` | `--cn`, `--cont-name` | Set container name |
+| `--cp PATH` | `--cont-path` | Set container working directory |
+| `--in NAME` | `--image-name` | Specify image name |
+| `--iv VERSION` | `--image-ver` | Specify image version |
+| `-e STRING` | `--env` | Set environment variable |
+| `--ef FILE` | `--env-file` | Load environment variables from file |
+| `-v STRING` | `--volume` | Bind mount volume |
+| `--rm` | `--rmc`, `--remove-cont` | Remove container |
+| `--sp CMD` | `--shell-prefix` | Temporary environment variable (prefix for -s) |
+| `-s CMD` | `--shell` | Specify command to execute |
+| `--` | `--ss`, `--shell-suffix` | Command arguments (suffix for -s) |
+| `-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) |
+| `--install NAME` | | Install manyoyo command |
+| `-V` | `--version` | Show version |
+| `-h` | `--help` | Show help |
+
+## Additional Information
+
+### Default Configuration
+
+- **Container Name**: `myy-{MMDD-HHMM}` (auto-generated based on current time)
+- **Host Path**: Current working directory
+- **Container Path**: Same as host path
+- **Image**: `localhost/xcanwin/manyoyo:xxx`
+
+### Requirements
+
+- Node.js >= 24.0.0
+- Docker or Podman
+
+### Uninstall
+
+```bash
+npm uninstall -g @xcanwin/manyoyo
+```
+
+## License
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xcanwin/manyoyo",
-  "version": "2.2.1",
+  "version": "3.0.1",
   "description": "AI Agent CLI Security Sandbox",
   "keywords": [
     "ai", "agent", "sandbox", "docker", "cli", "container", "development"
@@ -26,8 +26,9 @@
     "node": ">=14.0.0"
   },
   "files": [
-    "manyoyo.js",
+    "bin/manyoyo.js",
     "README.md",
+    "docs/README_EN.md",
     "LICENSE",
     "docker/manyoyo.Dockerfile"
   ]