openclawsetup 2.1.0 → 2.1.2

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,11 +143,11 @@ openclaw doctor
 ## 工作原理
 
 1. 安装 `openclaw` npm 包
-2. 使用 `script` 命令（Unix）创建伪终端，运行 `openclaw onboard --install-daemon`
-3. 监听输出，识别交互提示后自动发送预设答案
-4. 用户看到完整的原版界面 + 自动选择过程
+2. 优先检测官方 `openclaw onboard` 的非交互参数（可用时直接自动完成）
+3. 如不支持，则使用 `node-pty` 创建伪终端进行自动应答（按任意键接管）
+4. 若自动应答不可用，退回手动模式
 
-## 自动应答规则
+## 自动应答规则（兜底）
 
 | 提示类型 | 自动选择 |
 |---------|---------|
@@ -149,6 +160,8 @@ openclaw doctor
 | Daemon/Service | 安装 (y) |
 | UI 选择 | Web Dashboard |
 
+> 使用 `--with-model` / `--with-channel` 时，自动模式会在对应步骤暂停并交给用户操作。
+
 ## 卸载
 
 ```bash

package/bin/cli.mjs

@@ -2,8 +2,8 @@
 /**
  * OpenClaw 安装向导
  *
- * 调用官方 openclaw onboard，在关键步骤前提供中文指引
- * 用户看到完整的原版安装过程，我们只提供选择建议
+ * 调用官方 openclaw onboard，自动选择推荐配置
+ * 用户可随时按任意键接管，切换为手动操作
  *
  * 用法:
  *   npx openclawsetup           # 带中文指引的安装
@@ -51,6 +51,10 @@ function parseArgs() {
   return {
     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'),
   };
 }
@@ -63,10 +67,16 @@ ${colors.cyan('用法:')}
   npx openclawsetup              带中文指引的安装
   npx openclawsetup --update     更新已安装的 OpenClaw
   npx openclawsetup --reinstall  卸载后重新安装
+  npx openclawsetup --manual     完全手动模式
+  npx openclawsetup --auto       强制自动模式
 
 ${colors.cyan('说明:')}
   本工具会调用官方 openclaw onboard 命令
-  在关键步骤前提供中文指引，告诉你该如何选择
+  自动选择推荐配置，按任意键可随时接管
+
+${colors.cyan('高级选项:')}
+  --with-model    检测到模型配置时暂停自动选择
+  --with-channel  检测到渠道配置时暂停自动选择
 
 ${colors.cyan('安装后配置模型:')}
   npx openclawapi@latest preset-claude
@@ -137,7 +147,7 @@ function showInstallGuide() {
   console.log(colors.bold(colors.cyan('='.repeat(60))));
 
   console.log(colors.yellow('\n接下来会运行官方 openclaw onboard 命令'));
-  console.log(colors.yellow('请按照以下指引选择：\n'));
+  console.log(colors.yellow('自动模式会按以下推荐选择（可随时接管）：\n'));
 
   console.log(colors.cyan('┌─────────────────────────────────────────────────────────┐'));
   console.log(colors.cyan('│') + colors.bold(' 步骤 1: 安全确认') + colors.cyan('                                       │'));
@@ -167,6 +177,91 @@ function showInstallGuide() {
   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 getOnboardHelp(cliName) {
+  const candidates = [
+    `${cliName} onboard --help`,
+    `${cliName} onboard -h`,
+    `${cliName} help onboard`,
+  ];
+
+  for (const cmd of candidates) {
+    const result = safeExec(cmd, { stdio: 'pipe' });
+    const output = result.ok ? result.output : '';
+    if (output && output.length > 20) {
+      return output;
+    }
+  }
+  return '';
+}
+
+function buildOnboardArgsFromHelp(helpText, options) {
+  const help = helpText.toLowerCase();
+  const args = [];
+  const enabled = [];
+
+  const pickFlag = (flags) => flags.find((flag) => help.includes(flag));
+
+  const yesFlag = pickFlag(['--yes', '--assume-yes', '--accept', '--agree']);
+  if (yesFlag) {
+    args.push(yesFlag);
+    enabled.push('yes');
+  }
+
+  const installDaemonFlag = pickFlag(['--install-daemon', '--daemon']);
+  if (installDaemonFlag) {
+    args.push(installDaemonFlag);
+  }
+
+  if (help.includes('--quickstart')) {
+    args.push('--quickstart');
+    enabled.push('quickstart');
+  } else if (help.includes('--mode') && (help.includes('quickstart') || help.includes('quick start'))) {
+    args.push('--mode', 'quickstart');
+    enabled.push('quickstart');
+  }
+
+  if (!options.withModel) {
+    const skipModelFlag = pickFlag(['--skip-model', '--no-model', '--skip-provider']);
+    if (skipModelFlag) {
+      args.push(skipModelFlag);
+      enabled.push('skip-model');
+    }
+  }
+
+  if (!options.withChannel) {
+    const skipChannelFlag = pickFlag(['--skip-channel', '--no-channel', '--skip-channels']);
+    if (skipChannelFlag) {
+      args.push(skipChannelFlag);
+      enabled.push('skip-channel');
+    }
+  }
+
+  if (help.includes('--ui') && (help.includes('web') || help.includes('dashboard'))) {
+    args.push('--ui', 'web');
+    enabled.push('ui-web');
+  } else if (help.includes('--web')) {
+    args.push('--web');
+    enabled.push('ui-web');
+  }
+
+  const autoCapable = enabled.length > 0 || Boolean(yesFlag);
+  return { args, enabled, autoCapable };
+}
+
+function getOnboardCommand(cliName, onboardArgs = ['onboard', '--install-daemon']) {
+  if (platform() === 'win32') {
+    return { file: 'cmd.exe', args: ['/c', cliName, ...onboardArgs] };
+  }
+  return { file: cliName, args: onboardArgs };
+}
+
 function waitForEnter(message) {
   return new Promise((resolve) => {
     const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -247,18 +342,291 @@ async function runOnboard(cliName) {
   console.log(colors.gray('以下是官方 openclaw onboard 界面：'));
   console.log(colors.gray('-'.repeat(60) + '\n'));
 
-  // 直接运行官方 onboard，完全交互
-  const result = spawnSync(cliName, ['onboard', '--install-daemon'], {
+  const options = parseArgs();
+  const preferAuto = !options.manual;
+  let usedAuto = false;
+
+  if (preferAuto) {
+    const flagResult = runOnboardFlags(cliName, options);
+    if (flagResult.ran) {
+      usedAuto = true;
+      console.log(colors.gray('\n' + '-'.repeat(60)));
+      if (!flagResult.ok) {
+        log.warn(`onboard 退出码: ${flagResult.exitCode}`);
+        log.hint('如果配置未完成，可以手动运行: ' + cliName + ' onboard');
+      }
+    } else {
+      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 {
+        log.warn('自动模式不可用，已切换为手动模式');
+        log.hint(autoResult.reason || '未能启用自动应答');
+      }
+    }
+  }
+
+  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',
-    shell: true,
   });
+}
 
-  console.log(colors.gray('\n' + '-'.repeat(60)));
+function runOnboardFlags(cliName, options) {
+  const help = getOnboardHelp(cliName);
+  if (!help) {
+    return { ran: false, reason: '未检测到 onboard 帮助信息' };
+  }
+
+  const { args, enabled, autoCapable } = buildOnboardArgsFromHelp(help, options);
+  if (!autoCapable) {
+    return { ran: false, reason: '未检测到可用的非交互参数' };
+  }
 
-  if (result.status !== 0) {
-    log.warn(`onboard 退出码: ${result.status}`);
-    log.hint('如果配置未完成，可以手动运行: ' + cliName + ' onboard');
+  log.info('检测到官方非交互参数，优先使用原生方式安装');
+  if (enabled.length) {
+    log.hint(`已启用: ${enabled.join(', ')}`);
   }
+
+  const { file, args: spawnArgs } = getOnboardCommand(cliName, ['onboard', ...args]);
+  const result = spawnSync(file, spawnArgs, {
+    stdio: 'inherit',
+  });
+
+  return { ran: true, ok: result.status === 0, exitCode: result.status ?? 1 };
+}
+
+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('是否继续')) {
+      if (tail.includes('yes') && tail.includes('no')) {
+        send('confirm-select', '\x1b[A\x1b[D\r');
+      } else {
+        send('confirm', 'y\r');
+      }
+      return;
+    }
+
+    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 (apiKeyPrompt) {
+      if (options.withModel) {
+        stopAuto('检测到 API Key 配置，已暂停自动选择（--with-model）');
+        return;
+      }
+      send('api-skip', tail.includes('skip') || tail.includes('跳过') ? 's\r' : '\r');
+      return;
+    }
+
+    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 (tail.includes('skills') || tail.includes('skill')) {
+      send('skills-skip', 's\r');
+      return;
+    }
+
+    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);
+  });
+
+  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 });
+    });
+  });
 }
 
 // ============ 更新 ============

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "openclawsetup",
-  "version": "2.1.0",
+  "version": "2.1.2",
   "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,8 @@
 npx openclawsetup@latest
 ```
 
-你会看到官方的 `openclaw onboard` 界面，但所有选项会自动选择推荐配置。
+你会看到官方的 `openclaw onboard` 界面，但所有选项会自动选择推荐配置（按任意键可接管）。
+默认优先使用官方提供的非交互参数，若版本不支持则使用自动应答兜底。
 
 ### 方式二：手动模式
 
@@ -20,7 +21,15 @@ npx openclawsetup@latest
 npx openclawsetup@latest --manual
 ```
 
-### 方式三：一键脚本
+### 方式三：强制自动模式
+
+```bash
+npx openclawsetup@latest --auto
+```
+
+自动应答不可用时将直接退出（适合脚本化场景）。
+
+### 方式四：一键脚本
 
 自动检测并安装 Node.js，无需任何前置条件。
 
@@ -49,6 +58,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 +155,23 @@ curl -fsSL https://unpkg.com/openclawsetup@latest/install.sh | bash
 
 ### 自动选择没有生效
 **现象**：安装过程中需要手动输入
-**原因**：可能是终端环境问题
+**原因**：可能是终端环境问题、无 TTY，或自动应答依赖不可用（node-pty 未安装成功）
 **解决**：
 1. 使用手动模式：
    ```bash
    npx openclawsetup@latest --manual
    ```
-2. 或直接运行官方命令：
+2. 需要脚本化时使用强制自动模式（不可用会退出）：
+   ```bash
+   npx openclawsetup@latest --auto
+   ```
+3. 在 Linux 服务器上补齐编译依赖后再试（Ubuntu 示例）：
+   ```bash
+   sudo apt-get update
+   sudo apt-get install -y build-essential python3 make g++ pkg-config
+   npx openclawsetup@latest --auto
+   ```
+4. 或直接运行官方命令：
    ```bash
    npm install -g openclaw@latest
    openclaw onboard --install-daemon