openclawsetup 2.0.3 → 2.1.1

package/README.md

@@ -7,6 +7,7 @@ OpenClaw 智能安装向导 - 调用官方 `openclaw onboard` 交互界面，自
 - **真实体验**：调用官方 `openclaw onboard` 命令，用户看到完整的原版安装界面
 - **智能自动化**：自动选择推荐配置，无需手动操作
 - **可观看过程**：用户可以看到每一步的选择过程，了解发生了什么
+- **随时接管**：按任意键立刻切换为手动操作
 - **手动模式**：`--manual` 参数可切换到完全手动模式
 - **三系统支持**：macOS、Linux、Windows
 
@@ -32,13 +33,13 @@ npx openclawsetup@latest
 
 ## 安装模式
 
-### 智能模式（默认）
+### 智能模式（默认，自动应答）
 
 ```bash
 npx openclawsetup@latest
 ```
 
-自动完成以下选择：
+自动完成以下选择（按任意键可接管）：
 - ✓ 选择 QuickStart 模式
 - ✓ 跳过模型配置（后续用 `npx openclawapi` 配置）
 - ✓ 跳过渠道配置（后续用 `npx openclawdc` 或 `npx openclaw-chat-cn@latest feishu` 配置）
@@ -53,12 +54,22 @@ npx openclawsetup@latest --manual
 
 完全交互，自己选择所有配置项。
 
+### 强制自动模式
+
+```bash
+npx openclawsetup@latest --auto
+```
+
+自动应答不可用时将直接退出（适合脚本化场景）。
+
 ## 命令行参数
 
 | 参数 | 说明 |
 |------|------|
 | `--manual` | 手动模式，不自动选择 |
-| `--with-model` | 安装时配置模型（默认跳过） |
+| `--auto` | 强制自动模式（不可用则退出） |
+| `--with-model` | 检测到模型配置时暂停自动选择 |
+| `--with-channel` | 检测到渠道配置时暂停自动选择 |
 | `--update` | 检查并更新已安装的 OpenClaw |
 | `--reinstall` | 卸载后重新安装（清除配置） |
 | `--help, -h` | 显示帮助信息 |
@@ -132,7 +143,7 @@ openclaw doctor
 ## 工作原理
 
 1. 安装 `openclaw` npm 包
-2. 使用 `script` 命令（Unix）创建伪终端，运行 `openclaw onboard --install-daemon`
+2. 使用 `node-pty` 创建跨平台伪终端（Windows 使用 ConPTY）
 3. 监听输出，识别交互提示后自动发送预设答案
 4. 用户看到完整的原版界面 + 自动选择过程
 
@@ -149,6 +160,8 @@ openclaw doctor
 | Daemon/Service | 安装 (y) |
 | UI 选择 | Web Dashboard |
 
+> 使用 `--with-model` / `--with-channel` 时，自动模式会在对应步骤暂停并交给用户操作。
+
 ## 卸载
 
 ```bash

package/bin/cli.mjs

@@ -1,58 +1,21 @@
 #!/usr/bin/env node
 /**
- * OpenClaw 智能安装向导
+ * OpenClaw 安装向导
  *
- * 调用官方 openclaw onboard 交互界面，自动完成推荐配置
- * 用户可以看到完整的原版安装过程，但无需手动选择
+ * 调用官方 openclaw onboard，自动选择推荐配置
+ * 用户可随时按任意键接管，切换为手动操作
  *
  * 用法:
- *   npx openclawsetup           # 智能安装（自动选择推荐配置）
- *   npx openclawsetup --manual  # 手动模式（完全交互）
+ *   npx openclawsetup           # 带中文指引的安装
  *   npx openclawsetup --update  # 更新已安装的 OpenClaw
  */
 
-import { execSync, spawn } from 'child_process';
-import { existsSync, mkdirSync, writeFileSync, readFileSync, rmSync, accessSync, constants as fsConstants } from 'fs';
+import { execSync, spawnSync } from 'child_process';
+import { existsSync, accessSync, constants as fsConstants, rmSync } from 'fs';
 import { homedir, platform } from 'os';
 import { join } from 'path';
 import { createInterface } from 'readline';
 
-// ============ 配置 ============
-
-// 自动应答规则：识别关键词 -> 自动输入
-// 顺序很重要：先匹配的先执行
-const AUTO_RESPONSES = [
-  // 安全确认
-  { match: /continue\?|accept|agree|proceed|\(y\/n\)|\[y\/N\]|\[Y\/n\]/i, response: 'y', delay: 300, desc: '安全确认' },
-
-  // Setup 模式选择 - QuickStart
-  { match: /quick\s*start|setup\s*mode|choose.*mode/i, response: '1', delay: 500, desc: '选择 QuickStart' },
-
-  // Model Provider - 跳过（用户后续用 openclawapi 配置）
-  { match: /provider|anthropic|openai|select.*model|choose.*model/i, response: 's', delay: 500, desc: '跳过模型配置' },
-
-  // API Key - 跳过
-  { match: /api\s*key|enter.*key|paste.*key|setup.*token/i, response: '', delay: 300, desc: '跳过 API Key', skip: true },
-
-  // Channel 配置 - 跳过
-  { match: /channel|telegram|discord|whatsapp|slack|skip.*channel/i, response: 's', delay: 500, desc: '跳过渠道配置' },
-
-  // Skills - 跳过
-  { match: /skill|install.*skill|skip.*skill/i, response: 's', delay: 500, desc: '跳过 Skills' },
-
-  // Daemon/Service - 安装
-  { match: /daemon|service|background|auto.*start|launchd|systemd/i, response: 'y', delay: 300, desc: '安装后台服务' },
-
-  // UI 选择 - Web Dashboard
-  { match: /interface|dashboard|tui|web.*ui|control.*ui/i, response: '1', delay: 500, desc: '选择 Web Dashboard' },
-
-  // 名称/称呼 - 使用默认
-  { match: /name|call\s*you|address/i, response: '', delay: 300, desc: '使用默认名称' },
-
-  // 通用确认
-  { match: /press\s*enter|continue|next|\[enter\]/i, response: '', delay: 200, desc: '继续' },
-];
-
 // ============ 工具函数 ============
 
 const colors = {
@@ -62,7 +25,7 @@ const colors = {
   cyan: (s) => `\x1b[36m${s}\x1b[0m`,
   bold: (s) => `\x1b[1m${s}\x1b[0m`,
   gray: (s) => `\x1b[90m${s}\x1b[0m`,
-  dim: (s) => `\x1b[2m${s}\x1b[0m`,
+  bgYellow: (s) => `\x1b[43m\x1b[30m${s}\x1b[0m`,
 };
 
 const log = {
@@ -71,30 +34,9 @@ const log = {
   warn: (msg) => console.log(colors.yellow(`⚠ ${msg}`)),
   error: (msg) => console.log(colors.red(`✗ ${msg}`)),
   hint: (msg) => console.log(colors.gray(`  提示: ${msg}`)),
-  auto: (msg) => console.log(colors.dim(`  [自动] ${msg}`)),
-};
-
-const ERROR_CODES = {
-  NODE_VERSION: { code: 1, message: 'Node.js 版本过低' },
-  NPM_INSTALL_FAILED: { code: 3, message: 'npm 安装失败' },
-  ONBOARD_FAILED: { code: 4, message: 'onboard 执行失败' },
-  NOT_TTY: { code: 5, message: '需要交互式终端' },
+  guide: (msg) => console.log(colors.bgYellow(` 📖 ${msg} `)),
 };
 
-function exitWithError(errorType, details = '', solutions = []) {
-  const err = ERROR_CODES[errorType] || { code: 99, message: '未知错误' };
-  console.log(colors.bold(colors.red('\n========================================')));
-  console.log(colors.bold(colors.red(`❌ 错误: ${err.message}`)));
-  console.log(colors.bold(colors.red('========================================')));
-  if (details) console.log(colors.gray(`  ${details}`));
-  if (solutions.length > 0) {
-    console.log(colors.cyan('\n解决方案:'));
-    solutions.forEach((s, i) => console.log(`  ${i + 1}. ${s}`));
-  }
-  console.log(colors.gray(`\n错误码: ${err.code}`));
-  process.exit(err.code);
-}
-
 function safeExec(cmd, options = {}) {
   try {
     const output = execSync(cmd, { encoding: 'utf8', stdio: 'pipe', ...options });
@@ -104,96 +46,62 @@ function safeExec(cmd, options = {}) {
   }
 }
 
-function checkNodeVersion() {
-  const version = process.version;
-  const major = parseInt(version.slice(1).split('.')[0], 10);
-  if (major < 18) {
-    exitWithError('NODE_VERSION', `当前版本: ${version}，需要 Node.js 18+`, [
-      '升级 Node.js: https://nodejs.org/',
-      '使用 nvm: nvm install 22',
-    ]);
-  }
-  return true;
-}
-
 function parseArgs() {
   const args = process.argv.slice(2);
   return {
-    manual: args.includes('--manual'),
     update: args.includes('--update'),
     reinstall: args.includes('--reinstall'),
+    manual: args.includes('--manual'),
+    auto: args.includes('--auto'),
+    withModel: args.includes('--with-model'),
+    withChannel: args.includes('--with-channel'),
     help: args.includes('--help') || args.includes('-h'),
-    skipModel: !args.includes('--with-model'),  // 默认跳过模型配置
   };
 }
 
 function showHelp() {
   console.log(`
-${colors.bold('OpenClaw 智能安装向导')}
+${colors.bold('OpenClaw 安装向导')}
 
 ${colors.cyan('用法:')}
-  npx openclawsetup              智能安装（自动选择推荐配置）
-  npx openclawsetup --manual     手动模式（完全交互，自己选择）
+  npx openclawsetup              带中文指引的安装
   npx openclawsetup --update     更新已安装的 OpenClaw
   npx openclawsetup --reinstall  卸载后重新安装
+  npx openclawsetup --manual     完全手动模式
+  npx openclawsetup --auto       强制自动模式
 
-${colors.cyan('选项:')}
-  --manual       完全手动模式，不自动选择
-  --with-model   安装时配置模型（默认跳过，后续用 openclawapi 配置）
-  --update       检查并更新
-  --reinstall    重新安装（清除配置）
-  --help, -h     显示帮助
+${colors.cyan('说明:')}
+  本工具会调用官方 openclaw onboard 命令
+  自动选择推荐配置，按任意键可随时接管
 
-${colors.cyan('智能安装会自动:')}
-  ✓ 选择 QuickStart 模式
-  ✓ 跳过模型配置（后续用 npx openclawapi 配置）
-  ✓ 跳过渠道配置（后续用 npx openclawdc 或 npx openclaw-chat-cn@latest feishu 配置）
-  ✓ 安装后台服务（开机自启）
-  ✓ 选择 Web Dashboard
+${colors.cyan('高级选项:')}
+  --with-model    检测到模型配置时暂停自动选择
+  --with-channel  检测到渠道配置时暂停自动选择
 
 ${colors.cyan('安装后配置模型:')}
   npx openclawapi@latest preset-claude
 `);
 }
 
-// ============ 检测已安装 ============
-
-function detectExistingInstall() {
-  const home = homedir();
-  const openclawDir = join(home, '.openclaw');
-  const clawdbotDir = join(home, '.clawdbot');
-
-  let result = { installed: false };
+// ============ 环境检测 ============
 
-  if (existsSync(openclawDir) || existsSync(clawdbotDir)) {
-    result = {
-      installed: true,
-      configDir: existsSync(openclawDir) ? openclawDir : clawdbotDir,
-      name: existsSync(openclawDir) ? 'openclaw' : 'clawdbot',
-    };
-  } else {
-    const openclawResult = safeExec('openclaw --version');
-    if (openclawResult.ok) {
-      result = { installed: true, name: 'openclaw', version: openclawResult.output };
-    } else {
-      const clawdbotResult = safeExec('clawdbot --version');
-      if (clawdbotResult.ok) {
-        result = { installed: true, name: 'clawdbot', version: clawdbotResult.output };
-      }
-    }
+function checkNodeVersion() {
+  const version = process.version;
+  const major = parseInt(version.slice(1).split('.')[0], 10);
+  if (major < 18) {
+    log.error(`Node.js 版本过低: ${version}，需要 18+`);
+    console.log(colors.cyan('\n解决方案:'));
+    console.log('  1. 访问 https://nodejs.org/ 下载最新版本');
+    console.log('  2. 或使用 nvm: nvm install 22');
+    process.exit(1);
   }
-
-  return result;
+  return true;
 }
 
-// ============ 安装 OpenClaw ============
-
-// 检测是否需要 sudo
 function needsSudo() {
   const os = platform();
   if (os === 'win32' || os === 'darwin') return false;
 
-  // Linux: 检查 /usr/lib/node_modules 是否可写
   try {
     const testDir = '/usr/lib/node_modules';
     if (existsSync(testDir)) {
@@ -206,178 +114,408 @@ function needsSudo() {
   return true;
 }
 
-// 获取 npm 安装命令
-function getNpmInstallCmd(pkg) {
-  const useSudo = needsSudo();
-  if (useSudo) {
-    return { cmd: 'sudo', args: ['npm', 'install', '-g', pkg] };
+function detectExistingInstall() {
+  const home = homedir();
+  const openclawDir = join(home, '.openclaw');
+  const clawdbotDir = join(home, '.clawdbot');
+
+  if (existsSync(openclawDir)) {
+    return { installed: true, configDir: openclawDir, name: 'openclaw' };
+  }
+  if (existsSync(clawdbotDir)) {
+    return { installed: true, configDir: clawdbotDir, name: 'clawdbot' };
+  }
+
+  const openclawResult = safeExec('openclaw --version');
+  if (openclawResult.ok) {
+    return { installed: true, name: 'openclaw', version: openclawResult.output };
   }
-  return { cmd: 'npm', args: ['install', '-g', pkg] };
+
+  const clawdbotResult = safeExec('clawdbot --version');
+  if (clawdbotResult.ok) {
+    return { installed: true, name: 'clawdbot', version: clawdbotResult.output };
+  }
+
+  return { installed: false };
 }
 
-async function installOpenClaw() {
-  log.info('\n[1/2] 安装 OpenClaw CLI...\n');
+// ============ 安装指引 ============
+
+function showInstallGuide() {
+  console.log(colors.bold(colors.cyan('\n' + '='.repeat(60))));
+  console.log(colors.bold(colors.cyan('  📖 OpenClaw 安装指引')));
+  console.log(colors.bold(colors.cyan('='.repeat(60))));
+
+  console.log(colors.yellow('\n接下来会运行官方 openclaw onboard 命令'));
+  console.log(colors.yellow('自动模式会按以下推荐选择（可随时接管）：\n'));
+
+  console.log(colors.cyan('┌─────────────────────────────────────────────────────────┐'));
+  console.log(colors.cyan('│') + colors.bold(' 步骤 1: 安全确认') + colors.cyan('                                       │'));
+  console.log(colors.cyan('│') + '  看到 "Do you want to continue?" 时                    ' + colors.cyan('│'));
+  console.log(colors.cyan('│') + colors.green('  → 输入 y 然后回车') + '                                      ' + colors.cyan('│'));
+  console.log(colors.cyan('├─────────────────────────────────────────────────────────┤'));
+  console.log(colors.cyan('│') + colors.bold(' 步骤 2: Setup 模式') + colors.cyan('                                      │'));
+  console.log(colors.cyan('│') + '  看到 "Quick Start" 和 "Advanced" 选项时               ' + colors.cyan('│'));
+  console.log(colors.cyan('│') + colors.green('  → 选择 Quick Start（通常是第 1 个）') + '                    ' + colors.cyan('│'));
+  console.log(colors.cyan('├─────────────────────────────────────────────────────────┤'));
+  console.log(colors.cyan('│') + colors.bold(' 步骤 3: Model Provider') + colors.cyan('                                  │'));
+  console.log(colors.cyan('│') + '  看到选择 AI 模型提供商时                              ' + colors.cyan('│'));
+  console.log(colors.cyan('│') + colors.green('  → 选择 Skip 或按 s 跳过') + '                                ' + colors.cyan('│'));
+  console.log(colors.cyan('│') + colors.gray('  （后续用 npx openclawapi 单独配置更方便）') + '              ' + colors.cyan('│'));
+  console.log(colors.cyan('├─────────────────────────────────────────────────────────┤'));
+  console.log(colors.cyan('│') + colors.bold(' 步骤 4: Channel 配置') + colors.cyan('                                    │'));
+  console.log(colors.cyan('│') + '  看到选择聊天渠道（Telegram/Discord 等）时             ' + colors.cyan('│'));
+  console.log(colors.cyan('│') + colors.green('  → 选择 Skip 或按 s 跳过') + '                                ' + colors.cyan('│'));
+  console.log(colors.cyan('│') + colors.gray('  （后续用 npx openclawdc 等单独配置）') + '                   ' + colors.cyan('│'));
+  console.log(colors.cyan('├─────────────────────────────────────────────────────────┤'));
+  console.log(colors.cyan('│') + colors.bold(' 步骤 5: Daemon/Service') + colors.cyan('                                  │'));
+  console.log(colors.cyan('│') + '  看到是否安装后台服务时                                ' + colors.cyan('│'));
+  console.log(colors.cyan('│') + colors.green('  → 输入 y 确认安装（开机自启）') + '                          ' + colors.cyan('│'));
+  console.log(colors.cyan('└─────────────────────────────────────────────────────────┘'));
+
+  console.log(colors.gray('\n其他选项可以直接回车使用默认值'));
+  console.log(colors.gray('如果不确定，选择 Skip 或直接回车通常是安全的\n'));
+}
+
+function stripAnsi(input) {
+  return input
+    .replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '')
+    .replace(/\x1b\][^\x07]*\x07/g, '')
+    .replace(/\r/g, '\n');
+}
+
+function getOnboardCommand(cliName) {
+  if (platform() === 'win32') {
+    return { file: 'cmd.exe', args: ['/c', cliName, 'onboard', '--install-daemon'] };
+  }
+  return { file: cliName, args: ['onboard', '--install-daemon'] };
+}
+
+function waitForEnter(message) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(colors.yellow(message), () => {
+      rl.close();
+      resolve();
+    });
+  });
+}
+
+// ============ 安装 OpenClaw ============
 
+async function installOpenClaw() {
   const useSudo = needsSudo();
+
+  console.log(colors.bold(colors.cyan('\n[1/2] 安装 OpenClaw CLI\n')));
+
   if (useSudo) {
-    log.hint('检测到需要 sudo 权限，可能需要输入密码\n');
+    log.hint('Linux 系统需要 sudo 权限安装全局包');
+    console.log(colors.yellow('\n请运行以下命令：'));
+    console.log(colors.green('  sudo npm install -g openclaw@latest\n'));
+
+    await waitForEnter('安装完成后按回车继续...');
+
+    // 验证安装
+    const check = safeExec('openclaw --version');
+    if (!check.ok) {
+      log.error('未检测到 openclaw 命令，请确认安装成功');
+      process.exit(1);
+    }
+    log.success(`OpenClaw 已安装: ${check.output}`);
+    return 'openclaw';
   }
 
-  return new Promise((resolve, reject) => {
-    const { cmd, args } = getNpmInstallCmd('openclaw@latest');
-    const child = spawn(cmd, args, {
-      stdio: 'inherit',
-      shell: true,
-    });
+  // macOS 或有权限的 Linux：直接安装
+  console.log(colors.gray('正在安装 openclaw...\n'));
 
-    child.on('close', (code) => {
-      if (code === 0) {
-        log.success('OpenClaw CLI 安装完成');
-        resolve('openclaw');
-      } else {
-        // 尝试 clawdbot
-        log.warn('openclaw 安装失败，尝试 clawdbot...');
-        const { cmd: cmd2, args: args2 } = getNpmInstallCmd('clawdbot@latest');
-        const fallback = spawn(cmd2, args2, {
-          stdio: 'inherit',
-          shell: true,
-        });
-        fallback.on('close', (code2) => {
-          if (code2 === 0) {
-            log.success('clawdbot 安装完成');
-            resolve('clawdbot');
-          } else {
-            reject(new Error('npm 安装失败'));
-          }
-        });
-      }
-    });
+  const result = spawnSync('npm', ['install', '-g', 'openclaw@latest'], {
+    stdio: 'inherit',
+    shell: true,
   });
-}
 
-// ============ 自动化 Onboard ============
+  if (result.status === 0) {
+    log.success('OpenClaw CLI 安装完成');
+    return 'openclaw';
+  }
 
-async function runOnboardWithAutoResponse(cliName, options) {
-  log.info('\n[2/2] 运行配置向导...\n');
+  // 尝试 clawdbot
+  log.warn('openclaw 安装失败，尝试 clawdbot...');
+  const fallback = spawnSync('npm', ['install', '-g', 'clawdbot@latest'], {
+    stdio: 'inherit',
+    shell: true,
+  });
 
-  if (options.manual) {
-    log.hint('手动模式：请自行完成所有选择\n');
-  } else {
-    console.log(colors.dim('  智能模式：自动选择推荐配置，您可以观看安装过程\n'));
+  if (fallback.status === 0) {
+    log.success('clawdbot 安装完成');
+    return 'clawdbot';
   }
 
-  return new Promise((resolve, reject) => {
-    // 使用 script 命令来伪造 TTY（Unix）或直接 spawn（可能不完美）
-    const os = platform();
-    let child;
-
-    // 设置终端尺寸环境变量
-    const termEnv = {
-      ...process.env,
-      FORCE_COLOR: '1',
-      TERM: 'xterm-256color',
-      COLUMNS: process.stdout.columns?.toString() || '120',
-      LINES: process.stdout.rows?.toString() || '40',
-    };
-
-    if (os === 'win32') {
-      // Windows: 直接 spawn，可能没有完整的交互体验
-      child = spawn(cliName, ['onboard', '--install-daemon'], {
-        stdio: options.manual ? 'inherit' : ['pipe', 'pipe', 'pipe'],
-        shell: true,
-        env: termEnv,
-      });
-    } else if (os === 'darwin') {
-      // macOS: script -q /dev/null command args...
-      child = spawn('script', ['-q', '/dev/null', cliName, 'onboard', '--install-daemon'], {
-        stdio: options.manual ? 'inherit' : ['pipe', 'pipe', 'pipe'],
-        env: termEnv,
-      });
+  log.error('安装失败');
+  console.log(colors.cyan('\n解决方案:'));
+  console.log('  1. 检查网络连接');
+  console.log('  2. 手动安装: npm install -g openclaw@latest');
+  process.exit(1);
+}
+
+// ============ 运行 Onboard ============
+
+async function runOnboard(cliName) {
+  console.log(colors.bold(colors.cyan('\n[2/2] 运行配置向导\n')));
+
+  // 显示指引
+  showInstallGuide();
+
+  await waitForEnter('准备好了吗？按回车开始配置...');
+
+  console.log(colors.gray('\n' + '-'.repeat(60)));
+  console.log(colors.gray('以下是官方 openclaw onboard 界面：'));
+  console.log(colors.gray('-'.repeat(60) + '\n'));
+
+  const options = parseArgs();
+  const preferAuto = !options.manual;
+  let usedAuto = false;
+
+  if (preferAuto) {
+    const autoResult = await runOnboardAuto(cliName, options);
+    if (autoResult.ok) {
+      usedAuto = true;
+      console.log(colors.gray('\n' + '-'.repeat(60)));
+      if (autoResult.exitCode !== 0) {
+        log.warn(`onboard 退出码: ${autoResult.exitCode}`);
+        log.hint('如果配置未完成，可以手动运行: ' + cliName + ' onboard');
+      }
+    } else if (options.auto) {
+      log.error('自动模式不可用，已退出');
+      log.hint(autoResult.reason || '请尝试 --manual');
+      process.exit(1);
     } else {
-      // Linux: script -q -c "command args..." /dev/null
-      // 使用 stty 设置终端尺寸
-      const cols = process.stdout.columns || 120;
-      const rows = process.stdout.rows || 40;
-      const cmd = `stty cols ${cols} rows ${rows} 2>/dev/null; ${cliName} onboard --install-daemon`;
-      child = spawn('script', ['-q', '-c', cmd, '/dev/null'], {
-        stdio: options.manual ? 'inherit' : ['pipe', 'pipe', 'pipe'],
-        env: termEnv,
-      });
+      log.warn('自动模式不可用，已切换为手动模式');
+      log.hint(autoResult.reason || '未能启用自动应答');
     }
+  }
 
-    if (options.manual) {
-      // 手动模式：完全交互
-      child.on('close', (code) => {
-        if (code === 0) {
-          resolve();
-        } else {
-          reject(new Error(`onboard 退出码: ${code}`));
-        }
-      });
+  if (!usedAuto) {
+    const manualResult = runOnboardManual(cliName);
+    console.log(colors.gray('\n' + '-'.repeat(60)));
+    if (manualResult.status !== 0) {
+      log.warn(`onboard 退出码: ${manualResult.status}`);
+      log.hint('如果配置未完成，可以手动运行: ' + cliName + ' onboard');
+    }
+  }
+}
+
+function runOnboardManual(cliName) {
+  const { file, args } = getOnboardCommand(cliName);
+  return spawnSync(file, args, {
+    stdio: 'inherit',
+  });
+}
+
+function createAutoResponder(term, options) {
+  const lastSent = new Map();
+  let autoStopped = false;
+  let pausedNoticeShown = false;
+
+  const cooldownMs = 1200;
+  const shouldRespond = (id) => {
+    const now = Date.now();
+    const last = lastSent.get(id) || 0;
+    if (now - last < cooldownMs) return false;
+    lastSent.set(id, now);
+    return true;
+  };
+
+  const stopAuto = (reason) => {
+    if (autoStopped) return;
+    autoStopped = true;
+    log.warn(reason);
+    log.hint('已进入手动模式');
+  };
+
+  const send = (id, payload) => {
+    if (!shouldRespond(id)) return false;
+    term.write(payload);
+    return true;
+  };
+
+  return (rawText) => {
+    if (autoStopped) return;
+    const text = rawText.toLowerCase();
+    const tail = text.slice(-800);
+
+    if (tail.includes('do you want to continue') || tail.includes('continue?') || tail.includes('是否继续')) {
+      send('confirm', 'y\r');
       return;
     }
 
-    // 智能模式：监听输出并自动应答
-    let buffer = '';
-    let lastResponseTime = 0;
-    const RESPONSE_COOLDOWN = 1000; // 防止重复响应
-
-    const processOutput = (data) => {
-      const text = data.toString();
-      process.stdout.write(text); // 显示原版输出
-      buffer += text;
-
-      // 检查是否需要自动应答
-      const now = Date.now();
-      if (now - lastResponseTime < RESPONSE_COOLDOWN) return;
-
-      for (const rule of AUTO_RESPONSES) {
-        if (rule.match.test(buffer)) {
-          if (rule.skip) {
-            // 跳过这个提示，不发送任何内容
-            buffer = '';
-            return;
-          }
-
-          lastResponseTime = now;
-          setTimeout(() => {
-            if (child.stdin && !child.stdin.destroyed) {
-              log.auto(rule.desc);
-              child.stdin.write(rule.response + '\n');
-            }
-          }, rule.delay);
-
-          buffer = ''; // 清空缓冲区，避免重复匹配
-          break;
-        }
+    if ((tail.includes('quick start') || tail.includes('quickstart')) && (tail.includes('advanced') || tail.includes('custom'))) {
+      send('setup', '\r');
+      return;
+    }
+
+    const modelPrompt =
+      tail.includes('model provider') ||
+      tail.includes('model providers') ||
+      tail.includes('select a model') ||
+      tail.includes('模型') && tail.includes('提供商');
+
+    if (modelPrompt) {
+      if (options.withModel) {
+        stopAuto('检测到模型配置提示，已暂停自动选择（--with-model）');
+        return;
       }
+      send('model-skip', tail.includes('skip') || tail.includes('跳过') ? 's\r' : '\r');
+      return;
+    }
+
+    const apiKeyPrompt =
+      tail.includes('api key') ||
+      tail.includes('apikey') ||
+      (tail.includes('key') && tail.includes('请输入'));
 
-      // 防止缓冲区过大
-      if (buffer.length > 2000) {
-        buffer = buffer.slice(-1000);
+    if (apiKeyPrompt) {
+      if (options.withModel) {
+        stopAuto('检测到 API Key 配置，已暂停自动选择（--with-model）');
+        return;
       }
-    };
+      send('api-skip', tail.includes('skip') || tail.includes('跳过') ? 's\r' : '\r');
+      return;
+    }
 
-    if (child.stdout) {
-      child.stdout.on('data', processOutput);
+    const channelPrompt =
+      tail.includes('channel') ||
+      tail.includes('discord') ||
+      tail.includes('telegram') ||
+      tail.includes('feishu') ||
+      (tail.includes('渠道') && (tail.includes('选择') || tail.includes('配置')));
+
+    if (channelPrompt) {
+      if (options.withChannel) {
+        stopAuto('检测到渠道配置提示，已暂停自动选择（--with-channel）');
+        return;
+      }
+      send('channel-skip', 's\r');
+      return;
     }
-    if (child.stderr) {
-      child.stderr.on('data', processOutput);
+
+    if (tail.includes('skills') || tail.includes('skill')) {
+      send('skills-skip', 's\r');
+      return;
     }
 
-    child.on('close', (code) => {
-      console.log(''); // 换行
-      if (code === 0) {
-        resolve();
-      } else {
-        // 非零退出码不一定是错误，可能是用户中断
-        log.warn(`onboard 退出码: ${code}`);
-        resolve();
-      }
+    const daemonPrompt =
+      tail.includes('daemon') ||
+      tail.includes('service') && (tail.includes('install') || tail.includes('enable')) ||
+      (tail.includes('后台') && tail.includes('服务')) ||
+      tail.includes('开机') && tail.includes('自启');
+
+    if (daemonPrompt) {
+      send('daemon-yes', 'y\r');
+      return;
+    }
+
+    const uiPrompt =
+      tail.includes('dashboard') ||
+      tail.includes('web ui') ||
+      tail.includes('web dashboard') ||
+      (tail.includes('ui') && tail.includes('选择')) ||
+      (tail.includes('界面') && tail.includes('选择'));
+
+    if (uiPrompt) {
+      send('ui-web', tail.includes('web') || tail.includes('dashboard') ? '\r' : 'w\r');
+      return;
+    }
+
+    if (tail.includes('port') && (tail.includes('gateway') || tail.includes('端口'))) {
+      send('port-default', '\r');
+      return;
+    }
+
+    if (!pausedNoticeShown && (options.withModel || options.withChannel)) {
+      pausedNoticeShown = true;
+      log.hint('检测到 --with-model / --with-channel，将在相关步骤暂停自动选择');
+    }
+  };
+}
+
+async function runOnboardAuto(cliName, options) {
+  let ptyModule;
+  try {
+    ptyModule = await import('node-pty');
+  } catch (e) {
+    return { ok: false, reason: 'node-pty 依赖不可用，请尝试 --manual' };
+  }
+
+  const pty = ptyModule.default ?? ptyModule;
+  const spawn = pty?.spawn;
+  if (typeof spawn !== 'function') {
+    return { ok: false, reason: 'node-pty 未正确加载，请尝试 --manual' };
+  }
+
+  const { file, args } = getOnboardCommand(cliName);
+  const cols = process.stdout.columns || 80;
+  const rows = process.stdout.rows || 24;
+  const env = { ...process.env, FORCE_COLOR: '1' };
+
+  let term;
+  try {
+    term = spawn(file, args, {
+      name: 'xterm-256color',
+      cols,
+      rows,
+      cwd: process.cwd(),
+      env,
     });
+  } catch (e) {
+    return { ok: false, reason: `启动 PTY 失败: ${e.message}` };
+  }
+
+  const autoResponder = createAutoResponder(term, options);
+  let buffer = '';
+  let manualOverride = false;
+
+  log.info('自动模式已开启，按任意键可接管');
+
+  const stdin = process.stdin;
+  const canReadInput = Boolean(stdin.isTTY);
+  const restoreRaw = canReadInput ? stdin.isRaw : false;
+
+  const onUserData = (data) => {
+    if (!manualOverride) {
+      manualOverride = true;
+      log.warn('已接管，自动模式停止');
+    }
+    term.write(data.toString('utf8'));
+  };
+
+  if (canReadInput && typeof stdin.setRawMode === 'function') {
+    stdin.setRawMode(true);
+  }
+  if (canReadInput) {
+    stdin.on('data', onUserData);
+    stdin.resume();
+  }
+
+  term.onData((data) => {
+    process.stdout.write(data);
+    if (manualOverride) return;
+    buffer += stripAnsi(data);
+    if (buffer.length > 4000) {
+      buffer = buffer.slice(-4000);
+    }
+    autoResponder(buffer);
+  });
 
-    child.on('error', (err) => {
-      reject(err);
+  return await new Promise((resolve) => {
+    term.onExit(({ exitCode }) => {
+      if (canReadInput) {
+        stdin.off('data', onUserData);
+        if (typeof stdin.setRawMode === 'function') {
+          stdin.setRawMode(Boolean(restoreRaw));
+        }
+        stdin.pause();
+      }
+      resolve({ ok: true, exitCode });
     });
   });
 }
@@ -385,53 +523,48 @@ async function runOnboardWithAutoResponse(cliName, options) {
 // ============ 更新 ============
 
 async function updateOpenClaw(cliName) {
-  log.info('\n检查更新...\n');
+  console.log(colors.bold(colors.cyan('\n检查更新...\n')));
 
   const currentResult = safeExec(`${cliName} --version`);
   const currentVersion = currentResult.ok ? currentResult.output : '未知';
-  console.log(`  当前版本: ${colors.yellow(currentVersion)}`);
+  console.log(`当前版本: ${colors.yellow(currentVersion)}`);
 
-  return new Promise((resolve) => {
-    const child = spawn('npm', ['install', '-g', `${cliName}@latest`], {
+  const useSudo = needsSudo();
+
+  if (useSudo) {
+    console.log(colors.yellow('\n请运行以下命令更新：'));
+    console.log(colors.green(`  sudo npm install -g ${cliName}@latest`));
+    console.log(colors.green(`  ${cliName} gateway restart\n`));
+  } else {
+    console.log(colors.gray('\n正在更新...\n'));
+    spawnSync('npm', ['install', '-g', `${cliName}@latest`], {
       stdio: 'inherit',
       shell: true,
     });
 
-    child.on('close', (code) => {
-      if (code === 0) {
-        const newResult = safeExec(`${cliName} --version`);
-        const newVersion = newResult.ok ? newResult.output : '未知';
-        if (newVersion !== currentVersion) {
-          log.success(`更新完成: ${currentVersion} → ${newVersion}`);
-        } else {
-          log.success(`已是最新版本: ${newVersion}`);
-        }
+    const newResult = safeExec(`${cliName} --version`);
+    const newVersion = newResult.ok ? newResult.output : '未知';
 
-        // 重启 Gateway
-        log.info('\n重启 Gateway...');
-        const restart = safeExec(`${cliName} gateway restart`);
-        if (restart.ok) {
-          log.success('Gateway 已重启');
-        } else {
-          log.hint(`手动重启: ${cliName} gateway restart`);
-        }
-      } else {
-        log.error('更新失败');
-        log.hint(`手动更新: npm install -g ${cliName}@latest`);
-      }
-      resolve();
-    });
-  });
+    if (newVersion !== currentVersion) {
+      log.success(`更新完成: ${currentVersion} → ${newVersion}`);
+    } else {
+      log.success(`已是最新版本: ${newVersion}`);
+    }
+
+    console.log(colors.gray('\n重启 Gateway...'));
+    safeExec(`${cliName} gateway restart`);
+    log.success('Gateway 已重启');
+  }
 }
 
 // ============ 完成信息 ============
 
 function showCompletionInfo(cliName) {
-  console.log(colors.bold(colors.green('\n========================================')));
-  console.log(colors.bold(colors.green('✅ OpenClaw 安装完成！')));
-  console.log(colors.bold(colors.green('========================================')));
+  console.log(colors.bold(colors.green('\n' + '='.repeat(60))));
+  console.log(colors.bold(colors.green('  ✅ OpenClaw 安装完成！')));
+  console.log(colors.bold(colors.green('='.repeat(60))));
 
-  console.log(colors.cyan('\n下一步 - 配置 AI 模型:'));
+  console.log(colors.cyan('\n下一步 - 配置 AI 模型（必须）:'));
   console.log(`  ${colors.yellow('npx openclawapi@latest preset-claude')}`);
 
   console.log(colors.cyan('\n常用命令:'));
@@ -440,7 +573,7 @@ function showCompletionInfo(cliName) {
   console.log(`  重启服务: ${colors.yellow(`${cliName} gateway restart`)}`);
   console.log(`  诊断问题: ${colors.yellow(`${cliName} doctor`)}`);
 
-  console.log(colors.cyan('\n配置聊天渠道:'));
+  console.log(colors.cyan('\n配置聊天渠道（可选）:'));
   console.log(`  Discord: ${colors.yellow('npx openclawdc')}`);
   console.log(`  飞书:    ${colors.yellow('npx openclaw-chat-cn@latest feishu')}`);
 
@@ -457,7 +590,7 @@ async function main() {
     process.exit(0);
   }
 
-  console.log(colors.bold(colors.cyan('\n🦞 OpenClaw 智能安装向导\n')));
+  console.log(colors.bold(colors.cyan('\n🦞 OpenClaw 安装向导\n')));
 
   // 检查 Node 版本
   checkNodeVersion();
@@ -477,10 +610,18 @@ async function main() {
     if (options.reinstall) {
       log.info('\n卸载现有安装...');
       safeExec(`${existing.name} gateway stop`);
-      safeExec(`npm uninstall -g ${existing.name}`);
-      if (existing.configDir && existsSync(existing.configDir)) {
-        rmSync(existing.configDir, { recursive: true, force: true });
-        log.success('配置已清除');
+
+      if (needsSudo()) {
+        console.log(colors.yellow('\n请运行以下命令卸载：'));
+        console.log(colors.green(`  sudo npm uninstall -g ${existing.name}`));
+        console.log(colors.green(`  rm -rf ~/.openclaw ~/.clawdbot\n`));
+        await waitForEnter('卸载完成后按回车继续...');
+      } else {
+        spawnSync('npm', ['uninstall', '-g', existing.name], { stdio: 'inherit', shell: true });
+        if (existing.configDir && existsSync(existing.configDir)) {
+          rmSync(existing.configDir, { recursive: true, force: true });
+        }
+        log.success('卸载完成');
       }
     } else {
       console.log(colors.cyan('\n已安装，可选操作:'));
@@ -492,22 +633,14 @@ async function main() {
     }
   }
 
-  try {
-    // 安装 CLI
-    const cliName = await installOpenClaw();
-
-    // 运行 onboard
-    await runOnboardWithAutoResponse(cliName, options);
+  // 安装 CLI
+  const cliName = await installOpenClaw();
 
-    // 显示完成信息
-    showCompletionInfo(cliName);
+  // 运行 onboard
+  await runOnboard(cliName);
 
-  } catch (err) {
-    exitWithError('ONBOARD_FAILED', err.message, [
-      '检查网络连接',
-      '手动安装: npm install -g openclaw && openclaw onboard --install-daemon',
-    ]);
-  }
+  // 显示完成信息
+  showCompletionInfo(cliName);
 }
 
 main().catch((e) => {

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "openclawsetup",
-  "version": "2.0.3",
-  "description": "OpenClaw 智能安装向导 - 调用官方交互界面，自动选择推荐配置",
+  "version": "2.1.1",
+  "description": "OpenClaw 安装向导 - 带中文指引的官方安装流程",
   "type": "module",
   "bin": {
     "openclawsetup": "bin/cli.mjs"
   },
+  "optionalDependencies": {
+    "node-pty": "^1.0.0"
+  },
   "scripts": {
     "start": "node bin/cli.mjs"
   },

package//344/275/277/347/224/250/350/257/264/346/230/216.md

@@ -10,7 +10,7 @@
 npx openclawsetup@latest
 ```
 
-你会看到官方的 `openclaw onboard` 界面，但所有选项会自动选择推荐配置。
+你会看到官方的 `openclaw onboard` 界面，但所有选项会自动选择推荐配置（按任意键可接管）。
 
 ### 方式二：手动模式
 
@@ -20,7 +20,15 @@ npx openclawsetup@latest
 npx openclawsetup@latest --manual
 ```
 
-### 方式三：一键脚本
+### 方式三：强制自动模式
+
+```bash
+npx openclawsetup@latest --auto
+```
+
+自动应答不可用时将直接退出（适合脚本化场景）。
+
+### 方式四：一键脚本
 
 自动检测并安装 Node.js，无需任何前置条件。
 
@@ -49,6 +57,10 @@ irm https://unpkg.com/openclawsetup@latest/install.ps1 | iex
 | Daemon/Service | 安装 (y) |
 | UI 选择 | Web Dashboard |
 
+> 需要在安装过程中配置模型或渠道时，可使用：
+> - `--with-model`：检测到模型配置步骤时暂停自动选择
+> - `--with-channel`：检测到渠道配置步骤时暂停自动选择
+
 **为什么跳过模型和渠道？**
 - 模型配置：后续用 `npx openclawapi` 单独配置，更灵活
 - 渠道配置：后续用 `npx openclawdc`（Discord）或 `npx openclaw-chat-cn@latest feishu`（飞书）配置
@@ -142,13 +154,17 @@ curl -fsSL https://unpkg.com/openclawsetup@latest/install.sh | bash
 
 ### 自动选择没有生效
 **现象**：安装过程中需要手动输入
-**原因**：可能是终端环境问题
+**原因**：可能是终端环境问题或自动应答依赖不可用
 **解决**：
 1. 使用手动模式：
    ```bash
    npx openclawsetup@latest --manual
    ```
-2. 或直接运行官方命令：
+2. 需要脚本化时使用强制自动模式（不可用会退出）：
+   ```bash
+   npx openclawsetup@latest --auto
+   ```
+3. 或直接运行官方命令：
    ```bash
    npm install -g openclaw@latest
    openclaw onboard --install-daemon