codewave-openclaw-installer 1.0.2 → 2.1.1

package/bin/install.mjs

@@ -1,117 +1,859 @@
 #!/usr/bin/env node
 
 import { spawn } from 'node:child_process';
-import { cpSync, rmSync, existsSync, mkdirSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, rmSync, unlinkSync } from 'node:fs';
+import { dirname, resolve, join } from 'node:path';
+import * as path from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
+import { createInterface } from 'node:readline/promises';
+
+import {
+  CHANNEL_DEFINITIONS,
+  SKILL_SUMMARIES,
+  buildRazelConfigBootstrap,
+  classifyPythonInstallFailure,
+  createInstallContext,
+  evaluateChannelDetection,
+  shouldDryRun,
+} from './install-lib.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+const PKG_ROOT = resolve(__dirname, '..');
 
-// ─── 颜色辅助 ───
 const bold = (s) => `\x1b[1m${s}\x1b[0m`;
-const green = (s) => `\x1b[32m${s}\x1b[0m`;
-const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
-const red = (s) => `\x1b[31m${s}\x1b[0m`;
-const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+const green = (s) => `\x1b[92m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[93m${s}\x1b[0m`;
+const red = (s) => `\x1b[91m${s}\x1b[0m`;
+const cyan = (s) => `\x1b[96m${s}\x1b[0m`;
+const dim = (s) => `\x1b[97m${s}\x1b[0m`;
 
-// ─── 跨平台 npx 路径 ───
 const isWin = process.platform === 'win32';
-const NPX = isWin ? 'npx.cmd' : 'npx';
+const NPM = 'npm';
+const PIP = isWin ? 'pip' : 'pip3';
+const DRY_RUN = shouldDryRun(process.argv);
+
+function step(index, total, title) {
+  console.log('');
+  console.log(bold(`📦 阶段 ${index}/${total}: ${title}`));
+  console.log('');
+}
 
-// ─── 等待子进程结束的 Promise 包装 ───
-function runCommand(cmd, args) {
+function run(cmd, args, opts = {}) {
+  if (DRY_RUN) {
+    console.log(dim(`  [dry-run] ${cmd} ${args.join(' ')}`));
+    return Promise.resolve(0);
+  }
   return new Promise((resolve) => {
-    const child = spawn(cmd, args, { stdio: 'inherit' });
+    const child = spawn(cmd, args, { stdio: 'inherit', shell: isWin, ...opts });
     child.on('close', (code) => resolve(code ?? 1));
     child.on('error', (err) => {
-      console.log(yellow(`   进程启动失败: ${err.message}`));
+      console.log(yellow(`  ⚠ 进程启动失败: ${err.message}`));
       resolve(1);
     });
   });
 }
 
-// ─── 步骤 1: 欢迎信息 ───
-console.log('');
-console.log(bold('🦀 网易智企寄居蟹 Skill 包 — 一键安装器'));
-console.log('');
-console.log('将自动完成以下步骤：');
-console.log(cyan('  1. 安装寄居蟹智能客服 Skill'));
-console.log(cyan('  2. 安装飞书 OpenClaw 插件并绑定机器人（二维码）'));
-console.log('');
-console.log('─'.repeat(50));
-console.log('');
+function runCapture(cmd, args, opts = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'], shell: isWin, ...opts });
+    let stdout = '';
+    let stderr = '';
+    child.stdout?.on('data', (chunk) => { stdout += chunk.toString(); });
+    child.stderr?.on('data', (chunk) => { stderr += chunk.toString(); });
+    child.on('close', (code) => resolve({ code: code ?? 1, stdout, stderr }));
+    child.on('error', (err) => resolve({ code: 1, stdout, stderr: err.message }));
+  });
+}
+
+function commandExists(cmd) {
+  return new Promise((resolve) => {
+    const check = isWin ? 'where' : 'which';
+    const child = spawn(check, [cmd], { stdio: 'ignore', shell: isWin });
+    child.on('close', (code) => resolve(code === 0));
+    child.on('error', () => resolve(false));
+  });
+}
+
+function contextResult(context, key, value) {
+  context.results[key] = value;
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function findDesktopApps(appNames = []) {
+  const roots = [
+    '/Applications',
+    join(homedir(), 'Applications'),
+  ];
+  const matches = [];
+  for (const appName of appNames) {
+    for (const root of roots) {
+      const appPath = join(root, appName);
+      if (existsSync(appPath)) {
+        matches.push(appPath);
+      }
+    }
+  }
+  return [...new Set(matches)];
+}
+
+function detectDesktopClients() {
+  const candidates = {
+    feishu: ['Feishu.app', 'Lark.app', '飞书.app'],
+    dingtalk: ['DingTalk.app', '钉钉.app'],
+    wecom: ['企业微信.app', 'WeCom.app', 'WeChatWork.app'],
+  };
+
+  return Object.fromEntries(
+    Object.entries(candidates).map(([key, names]) => {
+      const installedPaths = findDesktopApps(names);
+      return [key, {
+        installed: installedPaths.length > 0,
+        installedPaths,
+      }];
+    }),
+  );
+}
+
+async function confirmPrompt(message, defaultYes = true) {
+  if (DRY_RUN || !process.stdin.isTTY) {
+    return defaultYes;
+  }
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  const answer = (await rl.question(message)).trim().toLowerCase();
+  rl.close();
+
+  if (!answer) {
+    return defaultYes;
+  }
+  return answer === 'y' || answer === 'yes';
+}
+
+function resolveChannelClientInfo(channelKey, desktopClients) {
+  if (!desktopClients) return { installed: false, displayName: '' };
+  if (channelKey === 'lark') return { installed: desktopClients.feishu.installed, displayName: '飞书' };
+  if (channelKey === 'dingtalk') return { installed: desktopClients.dingtalk.installed, displayName: '钉钉' };
+  if (channelKey === 'wecom') return { installed: desktopClients.wecom.installed, displayName: '企业微信' };
+  return { installed: false, displayName: '' };
+}
+
+async function ensureCommand(command, installArgs, resultKey, context, initArgs = []) {
+  if (await commandExists(command)) {
+    console.log(dim(`  ↺ 已检测到 ${command}，跳过安装`));
+    contextResult(context, resultKey, 'reused');
+    return;
+  }
+
+  const installCode = await run(installArgs[0], installArgs.slice(1));
+  if (installCode !== 0) {
+    console.log(yellow(`  ⚠️ ${command} 安装失败`));
+    contextResult(context, resultKey, 'failed');
+    return;
+  }
+
+  console.log(green(`  ✅ ${command} 安装成功`));
+
+  if (initArgs.length > 0) {
+    console.log(dim('  正在初始化...'));
+    const initCode = await run(command, initArgs);
+    contextResult(context, resultKey, initCode === 0 ? 'ok' : 'installed (init failed)');
+    return;
+  }
+
+  contextResult(context, resultKey, 'ok');
+}
+
+async function installPythonCli(context) {
+  const hasPython = await commandExists('python3');
+  const hasPython313 = await commandExists('python3.13');
+  const hasPip = await commandExists(PIP);
+  const hasPipx = await commandExists('pipx');
+
+  if (!hasPython) {
+    console.log(yellow(`  ⚠️ 缺少 python3，请先安装 Python 3`));
+    contextResult(context, 'python3', hasPython ? 'reused' : 'missing');
+    contextResult(context, 'pip', hasPip ? 'reused' : 'missing');
+    contextResult(context, 'pipx', hasPipx ? 'reused' : 'missing');
+    contextResult(context, 'razel-py-cli', 'skipped (missing python3)');
+    return;
+  }
+
+  contextResult(context, 'python3', 'reused');
+  contextResult(context, 'pip', 'reused');
+  contextResult(context, 'pipx', hasPipx ? 'reused' : 'missing');
+
+  if (await commandExists('razel-py-cli')) {
+    console.log(dim('  ↺ 已检测到 razel-py-cli，跳过安装'));
+    contextResult(context, 'razel-py-cli', 'reused');
+    return;
+  }
+
+  if (!hasPipx) {
+    console.log(yellow('  ⚠️ 未检测到 pipx，建议先安装 pipx 后再安装 razel-py-cli'));
+    if (hasPip) {
+      const classification = classifyPythonInstallFailure('externally-managed-environment');
+      console.log(dim(`  提示: ${classification.message}`));
+    }
+    contextResult(context, 'razel-py-cli', 'blocked (pipx missing)');
+    return;
+  }
+
+  const pipxPython = hasPython313 ? 'python3.13' : 'python3';
+  if (hasPython313) {
+    console.log(dim('  已检测到 python3.13，pipx 将优先使用 python3.13 安装 razel-py-cli'));
+  } else {
+    console.log(dim('  未检测到 python3.13，pipx 将使用默认 python3 安装 razel-py-cli'));
+  }
+
+  const pipxCode = await run('pipx', ['install', '--python', pipxPython, 'razel-py-cli']);
+  if (pipxCode !== 0) {
+    console.log(yellow(`  ⚠️ razel-py-cli 通过 pipx 安装失败 (python=${pipxPython})`));
+    contextResult(context, 'razel-py-cli', 'failed (pipx)');
+    return;
+  }
+
+  console.log(green('  ✅ razel-py-cli 通过 pipx 安装成功'));
+  console.log(dim('  正在初始化...'));
+  const initCode = await run('razel-py-cli', ['init']);
+  contextResult(context, 'razel-py-cli', initCode === 0 ? 'ok' : 'installed via pipx (init failed)');
+}
+
+async function applyConfigWrites(writes) {
+  let applied = 0;
+  const successKeys = new Set();
+
+  for (const write of writes) {
+    console.log(dim(`  准备写入 ${write.key} (${write.cli} config set)`));
+    const code = await run(write.cli, ['config', 'set', write.key, write.value]);
+    if (code === 0) {
+      applied += 1;
+      successKeys.add(write.key);
+      continue;
+    }
+    console.log(yellow(`  ⚠️ ${write.cli} config set ${write.key} 执行失败`));
+  }
+
+  return { applied, successKeys };
+}
+
+function printConfigGuidance(missing) {
+  if (missing.length === 0) {
+    return;
+  }
+
+  console.log('');
+  console.log(yellow('  仍有配置项缺失，可直接使用以下命令继续补齐：'));
+  for (const item of missing) {
+    console.log(dim(`    • ${item.title}`));
+    for (const command of item.commands) {
+      console.log(cyan(`      ${command}`));
+    }
+  }
+}
+
+function resolveMissingAfterWrites(missing, successKeys, options = {}) {
+  const has = (key) => successKeys.has(key);
+  const { skipPopo = false } = options;
+
+  return missing.filter((item) => {
+    if (item.group === 'popo') {
+      if (skipPopo) {
+        return false;
+      }
+      return !(has('popo_app_id') && has('popo_app_secret'));
+    }
+    if (item.group === 'llm') {
+      return !(has('llm_base_url') && has('llm_api_key'));
+    }
+    if (item.group === 'asr') {
+      const hasDashscope = has('dashscope_api_key');
+      const hasLocal = has('local_server');
+      const hasAigw = has('aigw_base_url') && has('aigw_api_key');
+      return !(hasDashscope || hasLocal || hasAigw);
+    }
+    return true;
+  });
+}
+
+async function collectInteractiveConfigWrites(missing, options = {}) {
+  const { hasPopoConfigured = false } = options;
+  if (!process.stdin.isTTY || DRY_RUN || missing.length === 0) {
+    return { writes: [], skipPopo: false };
+  }
+
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  const ask = async (prompt) => (await rl.question(prompt)).trim();
+  const askYesNo = async (prompt, defaultNo = true) => {
+    const raw = (await ask(prompt)).toLowerCase();
+    if (!raw) {
+      return !defaultNo;
+    }
+    return raw === 'y' || raw === 'yes';
+  };
+
+  const writes = [];
+  const hasGroup = (group) => missing.some((item) => item.group === group);
+
+  console.log(dim('  检测到关键配置缺失，可现在交互配置（支持跳过）'));
+  const shouldConfigure = await askYesNo('  现在进入配置向导吗？[y/N] ', true);
+  if (!shouldConfigure) {
+    rl.close();
+    return { writes: [], skipPopo: false };
+  }
+
+  if (hasGroup('llm')) {
+    console.log(dim('  [LLM] 回车可跳过'));
+    const baseUrl = await ask('    llm_base_url: ');
+    const apiKey = await ask('    llm_api_key: ');
+    if (baseUrl && apiKey) {
+      writes.push({ cli: 'razel-py-cli', key: 'llm_base_url', value: baseUrl });
+      writes.push({ cli: 'razel-py-cli', key: 'llm_api_key', value: apiKey });
+    }
+  }
 
-// ─── 步骤 2: 安装 smart-customer-service Skill ───
-console.log(bold('📂 步骤 1/2: 安装寄居蟹智能客服 Skill...'));
-console.log('');
+  if (hasGroup('asr')) {
+    console.log(dim('  [语音转写] speed-to-text 需要配置语音转文字服务'));
+    console.log(dim('  [ASR] 选择 provider，回车跳过'));
+    console.log(dim('    1) DashScope  2) AIGW  3) Local Server'));
+    const provider = await ask('    请选择 [1/2/3, skip=Enter]: ');
 
-const skillName = 'smart-customer-service';
-const srcDir = join(__dirname, '..', 'skills', skillName);
-const destBase = join(homedir(), '.openclaw', 'skills');
-const destDir = join(destBase, skillName);
+    if (provider === '1') {
+      const dashscopeKey = await ask('    dashscope_api_key: ');
+      if (dashscopeKey) {
+        writes.push({ cli: 'razel-py-cli', key: 'dashscope_api_key', value: dashscopeKey });
+      }
+    } else if (provider === '2') {
+      const aigwBaseUrl = await ask('    aigw_base_url: ');
+      const aigwApiKey = await ask('    aigw_api_key: ');
+      if (aigwBaseUrl && aigwApiKey) {
+        writes.push({ cli: 'razel-py-cli', key: 'aigw_base_url', value: aigwBaseUrl });
+        writes.push({ cli: 'razel-py-cli', key: 'aigw_api_key', value: aigwApiKey });
+      }
+    } else if (provider === '3') {
+      const localServer = await ask('    local_server: ');
+      if (localServer) {
+        writes.push({ cli: 'razel-py-cli', key: 'local_server', value: localServer });
+      }
+    }
+  }
+
+  let skipPopo = false;
+  const wantsPopoConfig = await askYesNo('  是否需要配置 PoPo-doc / PoPo 机器人？[y/N] ', true);
+  if (wantsPopoConfig) {
+    let shouldCollectPopo = true;
+    if (hasPopoConfigured) {
+      shouldCollectPopo = await askYesNo('  已检测到现有 PoPo 配置，是否覆盖？[y/N] ', true);
+    }
+    if (shouldCollectPopo) {
+      console.log(dim('  [PoPo] 回车可跳过'));
+      const appId = await ask('    popo_app_id: ');
+      const appSecret = await ask('    popo_app_secret: ');
+      if (appId && appSecret) {
+        writes.push({ cli: 'razel-cli', key: 'popo_app_id', value: appId });
+        writes.push({ cli: 'razel-cli', key: 'popo_app_secret', value: appSecret });
+      }
+    }
+  } else if (hasGroup('popo')) {
+    skipPopo = true;
+    console.log(dim('  已选择跳过 PoPo 服务配置'));
+  }
 
-let skillInstallSuccess = true;
+  rl.close();
+  return { writes, skipPopo };
+}
 
-try {
-  if (!existsSync(srcDir)) {
-    throw new Error(`源 Skill 目录不存在: ${srcDir}`);
+async function inspectChannel(definition) {
+  const commands = [];
+  for (const cmd of definition.detectCommands) {
+    if (await commandExists(cmd)) {
+      commands.push(cmd);
+    }
   }
 
-  if (!existsSync(destBase)) {
-    mkdirSync(destBase, { recursive: true });
-    console.log(`  创建目录: ${destBase}`);
+  const configPaths = definition.configPaths.filter((configPath) => existsSync(configPath));
+  const envVars = definition.envVars.filter((key) => Boolean(process.env[key]));
+  const desktopApps = findDesktopApps(definition.desktopAppCandidates ?? []);
+
+  const openclawConfigPath = join(homedir(), '.openclaw', 'openclaw.json');
+  const openclawConfig = readJson(openclawConfigPath);
+  if ((definition.label === '飞书' || definition.label === 'Lark') && openclawConfig?.channels?.feishu) {
+    configPaths.push(`${openclawConfigPath}#channels.feishu`);
   }
 
-  if (existsSync(destDir)) {
-    console.log(`  检测到已有版本，正在更新...`);
-    rmSync(destDir, { recursive: true, force: true });
+  return { commands, configPaths, envVars, desktopApps };
+}
+
+async function detectChannel(definition) {
+  return evaluateChannelDetection(definition, await inspectChannel(definition));
+}
+
+async function runFirstAvailable(candidates) {
+  for (const [cmd, args] of candidates) {
+    if (await commandExists(cmd)) {
+      const code = await run(cmd, args);
+      if (code === 0) {
+        return { ok: true, command: cmd, args };
+      }
+    }
   }
+  return { ok: false };
+}
 
-  cpSync(srcDir, destDir, {
-    recursive: true,
-    filter: (src) => {
-      const name = src.split('/').pop();
-      if (name === '.DS_Store') return false;
-      if (name === '__MACOSX') return false;
+async function hasRuntimeCommand(definition) {
+  for (const cmd of definition.runtimeCommands) {
+    if (await commandExists(cmd)) {
       return true;
-    },
+    }
+  }
+  return false;
+}
+
+async function getFirstAvailableRuntime(definition) {
+  for (const cmd of definition.runtimeCommands) {
+    if (await commandExists(cmd)) {
+      return cmd;
+    }
+  }
+  return null;
+}
+
+async function inferChannelActivation(channelKey) {
+  const definition = CHANNEL_DEFINITIONS[channelKey];
+  const details = await inspectChannel(definition);
+  const runtimeCommand = await getFirstAvailableRuntime(definition);
+
+  const hasConfigHints = details.configPaths.length > 0 || details.envVars.length > 0 || details.desktopApps.length > 0;
+  const hasRuntime = Boolean(runtimeCommand);
+
+  if (channelKey === 'lark') {
+    const openclawConfig = readJson(join(homedir(), '.openclaw', 'openclaw.json'));
+    const feishuConfig = openclawConfig?.channels?.feishu;
+    const hasFeishuAccount = Boolean(
+      feishuConfig?.enabled && (feishuConfig?.appId || feishuConfig?.accounts?.main?.appId),
+    );
+
+    if (hasRuntime && hasFeishuAccount) {
+      return {
+        status: 'configured',
+        message: `Lark 已存在可用配置 (${runtimeCommand})`,
+      };
+    }
+  }
+
+  if (channelKey === 'dingtalk') {
+    const hasCreds = details.envVars.includes('DWS_CLIENT_ID') && details.envVars.includes('DWS_CLIENT_SECRET');
+    const hasLocalState = details.configPaths.some((configPath) => configPath.includes('.dws'));
+
+    if (hasRuntime && (hasCreds || hasLocalState)) {
+      return {
+        status: 'configured',
+        message: `DingTalk 已存在运行与认证线索 (${runtimeCommand})`,
+      };
+    }
+  }
+
+  if (hasRuntime && hasConfigHints) {
+    return {
+      status: 'detected_uninitialized',
+      message: `${definition.label} 已检测到，存在配置线索但未确认完成初始化`,
+    };
+  }
+
+  if (hasRuntime) {
+    return {
+      status: 'runtime_only',
+      message: `${definition.label} 已检测到运行入口 ${runtimeCommand}，但尚无明确配置线索`,
+    };
+  }
+
+  if (hasConfigHints) {
+    return {
+      status: 'hinted',
+      message: `${definition.label} 仍只有环境线索，尚未形成可用运行入口`,
+    };
+  }
+
+  return {
+    status: 'absent',
+    message: `${definition.label} 未检测到可用状态`,
+  };
+}
+
+async function bootstrapChannel(channelKey, context) {
+  const definition = CHANNEL_DEFINITIONS[channelKey];
+  const detection = await detectChannel(definition);
+  context.channels[channelKey] = detection;
+  const clientInfo = resolveChannelClientInfo(channelKey, context.desktopClients);
+
+  const shouldReuse = channelKey === 'lark'
+    ? true
+    : detection.status === 'ready' || detection.status === 'hinted';
+  if (!shouldReuse) {
+    console.log(dim(`  • ${definition.label}: 未检测到环境线索，跳过`));
+    return;
+  }
+
+  console.log(cyan(`  • ${definition.label}: ${detection.message}`));
+
+  const shouldStartBinding = await confirmPrompt(
+    `  是否现在为${clientInfo.displayName || definition.label}安装/绑定机器人？[Y/n] `,
+    true,
+  );
+  if (!shouldStartBinding) {
+    context.channels[channelKey] = {
+      status: 'skipped-by-choice',
+      source: detection.source,
+      message: `已跳过${definition.label}机器人绑定`,
+    };
+    return;
+  }
+
+  if (channelKey === 'lark') {
+    const [installCmd, installArgs] = definition.installCommand;
+    console.log(dim(`  按官方流程执行 ${definition.label} 绑定（二维码创建/关联机器人）...`));
+    const installCode = await run(installCmd, installArgs);
+    if (installCode !== 0) {
+      context.channels[channelKey] = {
+        status: 'failed',
+        source: detection.source,
+        message: `${definition.label} 绑定流程失败（${installCmd} ${installArgs.join(' ')}）`,
+      };
+      return;
+    }
+
+    const activated = await inferChannelActivation(channelKey);
+    context.channels[channelKey] = {
+      status: DRY_RUN ? 'would-enter-binding' : 'binding-flow-entered',
+      source: detection.source,
+      message: DRY_RUN
+        ? `${definition.label} 将执行官方绑定流程 (${installCmd} ${installArgs.join(' ')})`
+        : `${definition.label} 已执行官方绑定流程 (${installCmd} ${installArgs.join(' ')})；${activated.message}`,
+    };
+    return;
+  }
+
+  let runtimeCommand = await getFirstAvailableRuntime(definition);
+  if (!runtimeCommand && detection.status === 'hinted') {
+    const [installCmd, installArgs] = definition.installCommand;
+    console.log(dim(`  未发现可用运行入口，按官方方式安装 ${definition.label}...`));
+    const installCode = await run(installCmd, installArgs);
+    if (installCode !== 0) {
+      context.channels[channelKey] = {
+        status: 'failed',
+        source: detection.source,
+        message: `${definition.label} 官方安装失败`,
+      };
+      return;
+    }
+    runtimeCommand = await getFirstAvailableRuntime(definition);
+  }
+
+  if (!runtimeCommand) {
+    context.channels[channelKey] = {
+      status: 'failed',
+      source: detection.source,
+      message: `${definition.label} 缺少可执行入口，无法继续初始化`,
+    };
+    return;
+  }
+
+  console.log(dim(`  复用现有 ${definition.label} 入口: ${runtimeCommand}`));
+
+  const initResult = await runFirstAvailable(definition.initCandidates);
+  if (initResult.ok) {
+    const activated = await inferChannelActivation(channelKey);
+    const flowLabel = channelKey === 'lark'
+      ? '飞书绑定流程'
+      : channelKey === 'dingtalk'
+        ? '钉钉登录流程'
+        : '引导流程';
+    context.channels[channelKey] = {
+      status: DRY_RUN
+        ? 'would-enter-binding'
+        : (activated.status === 'configured' ? 'binding-flow-entered' : activated.status),
+      source: detection.source,
+      message: DRY_RUN
+        ? `${definition.label} 将复用现有入口并进入${flowLabel} (${initResult.command} ${initResult.args.join(' ')})`
+        : `${definition.label} 已复用现有入口并进入${flowLabel} (${initResult.command} ${initResult.args.join(' ')})；${activated.message}`,
+    };
+    return;
+  }
+
+  const qrResult = await runFirstAvailable(definition.qrCandidates);
+  if (qrResult.ok) {
+    const activated = await inferChannelActivation(channelKey);
+    context.channels[channelKey] = {
+      status: activated.status === 'configured' ? 're-onboarded' : 'waiting_auth',
+      source: detection.source,
+      message: activated.status === 'configured'
+        ? `${definition.label} 已复用现有入口并执行二维码引导；${activated.message}`
+        : `${definition.label} 已拉起二维码流程，请完成扫码授权`,
+    };
+    return;
+  }
+
+  const activated = await inferChannelActivation(channelKey);
+  context.channels[channelKey] = {
+    status: activated.status,
+    source: detection.source,
+    message: `${activated.message}；未找到可用初始化命令，尚未完成新的引导流程`,
+  };
+}
+
+async function runPreflight(context) {
+  console.log(dim(`  平台: ${context.platform}`));
+  if (DRY_RUN) {
+    console.log(dim('  模式: dry-run（只展示流程，不执行变更）'));
+  }
+  console.log(dim(`  OpenClaw: ${await commandExists('openclaw') ? 'detected' : 'missing'}`));
+
+  context.channels.lark = await detectChannel(CHANNEL_DEFINITIONS.lark);
+  context.channels.dingtalk = await detectChannel(CHANNEL_DEFINITIONS.dingtalk);
+  context.channels.wecom = await detectChannel(CHANNEL_DEFINITIONS.wecom);
+  context.desktopClients = detectDesktopClients();
+
+  console.log(dim(`  飞书: ${context.channels.lark.message}`));
+  console.log(dim(`  钉钉: ${context.channels.dingtalk.message}`));
+  console.log(dim(`  企业微信: ${context.channels.wecom.message}`));
+}
+
+async function runCoreInstall(context) {
+  await installPythonCli(context);
+  await ensureCommand('razel-cli', [NPM, 'install', '-g', '@lcap-delivery/razel-cli@latest'], 'razel-cli', context, ['init']);
+}
+
+async function runConfigBootstrap(context) {
+  const razelConfigPath = join(homedir(), '.razel', 'config.json');
+  const razelConfig = readJson(razelConfigPath) || {};
+  const openclawConfig = readJson(join(homedir(), '.openclaw', 'openclaw.json'));
+  const plan = buildRazelConfigBootstrap({
+    razelConfig,
+    env: process.env,
+    hasOpenclawLlm: Boolean(openclawConfig?.providers || openclawConfig?.model || openclawConfig?.models),
   });
 
-  console.log(green(`  ✅ Skill 已安装到: ~/.openclaw/skills/${skillName}/`));
-} catch (err) {
-  skillInstallSuccess = false;
-  console.log(red(`  ❌ Skill 安装失败: ${err.message}`));
+  if (plan.writes.length === 0 && plan.missing.length === 0) {
+    console.log(dim('  ↺ 已检测到关键配置，跳过 config bootstrap'));
+    contextResult(context, 'razel-config', 'reused');
+    return;
+  }
+
+  let applied = 0;
+  const successKeys = new Set();
+  if (plan.writes.length > 0) {
+    const result = await applyConfigWrites(plan.writes);
+    applied += result.applied;
+    for (const key of result.successKeys) {
+      successKeys.add(key);
+    }
+  }
+
+  const hasPopoConfigured = Boolean(razelConfig.popo_app_id && razelConfig.popo_app_secret);
+  const interactive = await collectInteractiveConfigWrites(plan.missing, { hasPopoConfigured });
+  if (interactive.writes.length > 0) {
+    const result = await applyConfigWrites(interactive.writes);
+    applied += result.applied;
+    for (const key of result.successKeys) {
+      successKeys.add(key);
+    }
+  }
+
+  const remainingMissing = resolveMissingAfterWrites(plan.missing, successKeys, { skipPopo: interactive.skipPopo });
+  context.configGuidance = remainingMissing;
+  if (applied > 0 && remainingMissing.length === 0) {
+    contextResult(context, 'razel-config', `synced ${applied} key(s)`);
+  } else if (applied > 0) {
+    contextResult(context, 'razel-config', `synced ${applied} key(s), guidance needed`);
+  } else if (remainingMissing.length > 0) {
+    contextResult(context, 'razel-config', 'guidance needed');
+  } else {
+    contextResult(context, 'razel-config', 'reused');
+  }
+
+  printConfigGuidance(remainingMissing);
 }
 
-console.log('');
-console.log('─'.repeat(50));
-console.log('');
+async function runExtensionInstall(context) {
+  const extensionId = 'codewave-toolkit';
+  const extensionsDir = join(homedir(), '.openclaw', 'extensions');
+  const extensionTarget = join(extensionsDir, extensionId);
+  const pluginJsonPath = join(PKG_ROOT, 'openclaw.plugin.json');
+  const skillsDir = join(PKG_ROOT, 'skills');
+
+  if (!existsSync(extensionsDir)) {
+    mkdirSync(extensionsDir, { recursive: true });
+  }
+
+  if (!existsSync(pluginJsonPath)) {
+    console.log(red('  ❌ 包结构异常: 缺少 openclaw.plugin.json'));
+    contextResult(context, 'extension', 'failed (missing manifest)');
+    return;
+  }
+
+  if (!existsSync(skillsDir)) {
+    console.log(red('  ❌ 包结构异常: 缺少 skills/ 目录'));
+    contextResult(context, 'extension', 'failed (missing skills)');
+    return;
+  }
+
+  try {
+    if (existsSync(extensionTarget)) {
+      const stat = lstatSync(extensionTarget);
+      if (stat.isSymbolicLink()) {
+        unlinkSync(extensionTarget);
+      } else {
+        rmSync(extensionTarget, { recursive: true, force: true });
+      }
+    }
+  } catch {
+    // ignore cleanup errors and rely on copy failure if target remains invalid
+  }
 
-// ─── 步骤 3: 安装飞书 OpenClaw 插件 ───
-console.log(bold('📦 步骤 2/2: 安装飞书 OpenClaw 插件...'));
-console.log('');
+  if (DRY_RUN) {
+    console.log(dim(`  [dry-run] 将复制 ${PKG_ROOT} 到 ${extensionTarget}`));
+    contextResult(context, 'extension', 'dry-run');
+    console.log('');
+    console.log(dim('  Skills 将由 OpenClaw 自动从扩展目录加载:'));
+    for (const skill of SKILL_SUMMARIES) {
+      console.log(dim(`    • ${skill}`));
+    }
+    return;
+  }
 
-const exitCode = await runCommand(NPX, ['-y', '@larksuite/openclaw-lark', 'install']);
-const larkInstallSuccess = exitCode === 0;
+  try {
+    cpSync(PKG_ROOT, extensionTarget, {
+      recursive: true,
+      filter: (src) => {
+        const base = path.basename(src);
+        return base !== 'node_modules'
+          && base !== '.git'
+          && base !== '.DS_Store'
+          && base !== '__MACOSX';
+      },
+    });
+    console.log(green('  ✅ OpenClaw 扩展安装成功'));
+    console.log(dim(`  路径: ${extensionTarget}`));
+    contextResult(context, 'extension', 'ok');
+  } catch (err) {
+    console.log(red(`  ❌ 复制失败: ${err.message}`));
+    contextResult(context, 'extension', 'failed');
+  }
 
-if (larkInstallSuccess) {
   console.log('');
-  console.log(green('✅ 飞书插件安装完成'));
-} else {
+  console.log(dim('  Skills 将由 OpenClaw 自动从扩展目录加载:'));
+  for (const skill of SKILL_SUMMARIES) {
+    console.log(dim(`    • ${skill}`));
+  }
+}
+
+async function runPostflight(context) {
+  if (DRY_RUN) {
+    contextResult(context, 'gateway-restart', 'dry-run');
+    console.log(dim('  [dry-run] 跳过 gateway restart 与 postflight check 执行'));
+    return;
+  }
+
+  if (!(await commandExists('openclaw'))) {
+    console.log(yellow('  ⚠️ openclaw 命令未找到，请手动重启'));
+    contextResult(context, 'gateway-restart', 'skipped (no openclaw)');
+  } else {
+    const code = await run('openclaw', ['gateway', 'restart']);
+    contextResult(context, 'gateway-restart', code === 0 ? 'ok' : 'skipped');
+  }
+
+  const checkResult = await runCapture(process.execPath, [join(PKG_ROOT, 'bin', 'check.mjs'), '--json']);
+  if (checkResult.stdout) {
+    try {
+      context.postflight = JSON.parse(checkResult.stdout);
+      console.log(dim(`  postflight: ${context.postflight.summary.ok}/${context.postflight.summary.total} 个 Skill 就绪`));
+    } catch {
+      console.log(yellow('  ⚠️ postflight 输出无法解析为 JSON'));
+    }
+  }
+}
+
+async function main() {
+  const context = createInstallContext(process.platform);
+
+  console.log('');
+  console.log(bold('🦀 网易智企 CodeWave OpenClaw 扩展安装器 v3.0'));
   console.log('');
-  console.log(yellow('⚠️  飞书插件安装未成功（可能已安装过，或手动取消）'));
-}
-
-// ─── 步骤 4: 完成提示 ───
-console.log('');
-console.log('─'.repeat(50));
-console.log('');
-console.log(bold(green('🦀 安装完成！')));
-console.log('');
-console.log(`  - 寄居蟹智能客服 Skill: ${skillInstallSuccess ? green('已安装到 ~/.openclaw/skills/smart-customer-service/') : red('安装失败')}`);
-console.log(`  - 飞书插件:             ${larkInstallSuccess ? green('已安装') : yellow('跳过（请手动安装）')}`);
-console.log('');
-console.log('  请在飞书中与机器人对话测试！');
-console.log('');
+  console.log('将自动完成以下阶段：');
+  for (let i = 0; i < context.phases.length; i++) {
+    console.log(cyan(`  ${i + 1}. ${context.phases[i]}`));
+  }
+  console.log('');
+  console.log('─'.repeat(55));
+
+  step(1, context.phases.length, context.phases[0]);
+  await runPreflight(context);
+
+  step(2, context.phases.length, context.phases[1]);
+  await runCoreInstall(context);
+
+  step(3, context.phases.length, context.phases[2]);
+  await bootstrapChannel('lark', context);
+  await bootstrapChannel('dingtalk', context);
+  await bootstrapChannel('wecom', context);
+
+  step(4, context.phases.length, context.phases[3]);
+  await runExtensionInstall(context);
+
+  step(5, context.phases.length, context.phases[4]);
+  await runPostflight(context);
+
+  step(6, context.phases.length, context.phases[5]);
+  await runConfigBootstrap(context);
+
+  console.log('');
+  console.log('─'.repeat(55));
+  console.log('');
+  console.log(bold(green('🦀 安装完成！')));
+  console.log('');
+  console.log('  安装结果：');
+  for (const [key, value] of Object.entries(context.results)) {
+    console.log(`    ${key.padEnd(20, ' ')} : ${value}`);
+  }
+  console.log('');
+  console.log('  渠道状态：');
+  console.log(`    飞书                 : ${context.channels.lark.status} (${context.channels.lark.message})`);
+  console.log(`    钉钉                 : ${context.channels.dingtalk.status} (${context.channels.dingtalk.message})`);
+  console.log(`    企业微信             : ${context.channels.wecom.status} (${context.channels.wecom.message})`);
+  console.log('');
+  if (context.configGuidance?.length) {
+    console.log('  待补配置：');
+    for (const item of context.configGuidance) {
+      console.log(`    ${item.group.padEnd(20, ' ')} : ${item.title}`);
+    }
+    console.log('');
+  }
+  if (context.postflight) {
+    console.log(`  Skill 就绪情况: ${context.postflight.summary.ok} ok / ${context.postflight.summary.warn} warn / ${context.postflight.summary.fail} fail`);
+    console.log('');
+  }
+  console.log('  使用方式：');
+  console.log(cyan('    razel-py-cli --help'));
+  console.log(cyan('    razel-cli --help'));
+  console.log('');
+}
+
+main().catch((err) => {
+  console.error(red(`Fatal: ${err.message}`));
+  process.exit(2);
+});