openclawsetup 2.5.3 → 2.8.0

package/bin/cli.mjs

@@ -11,8 +11,19 @@
  */
 
 import { exec, execSync, spawnSync } from 'child_process';
-import { existsSync, accessSync, constants as fsConstants, rmSync, readFileSync } from 'fs';
-import { homedir, platform } from 'os';
+import {
+  existsSync,
+  accessSync,
+  constants as fsConstants,
+  rmSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  mkdirSync,
+  writeFileSync,
+} from 'fs';
+import { createServer } from 'net';
+import { homedir, platform, arch, release, hostname } from 'os';
 import { join } from 'path';
 import { createInterface } from 'readline';
 
@@ -70,40 +81,530 @@ const log = {
   guide: (msg) => console.log(colors.bgYellow(` 📖 ${msg} `)),
 };
 
+const DEFAULT_GATEWAY_PORT = 18789;
+const STRONG_FIX_MAX_PASSES = 3;
+const STRONG_PORT_CANDIDATES = [
+  18789,
+  18790,
+  18791,
+  18792,
+  18793,
+  18794,
+  18795,
+  18889,
+  18989,
+];
+
+const EVIDENCE_DIR_NAME = 'openclaw-evidence';
+
 function safeExec(cmd, options = {}) {
   try {
-    const output = execSync(cmd, { encoding: 'utf8', stdio: 'pipe', ...options });
+    const output = execSync(cmd, {
+      encoding: 'utf8',
+      stdio: 'pipe',
+      timeout: 30000,
+      maxBuffer: 8 * 1024 * 1024,
+      ...options,
+    });
     return { ok: true, output: output.trim() };
   } catch (e) {
-    return { ok: false, error: e.message, stderr: e.stderr?.toString() || '' };
+    return {
+      ok: false,
+      error: e.message,
+      stderr: e.stderr?.toString() || '',
+      status: Number.isInteger(e?.status) ? e.status : null,
+    };
   }
 }
 
 function parseArgs() {
   const args = process.argv.slice(2);
+  const strongFix = args.includes('--strong-fix') || args.includes('--extreme-fix');
   return {
     update: args.includes('--update'),
     reinstall: args.includes('--reinstall'),
     uninstall: args.includes('--uninstall'),
     check: args.includes('--check'),
     fix: args.includes('--fix'),
+    strongFix,
+    strong: args.includes('--strong') || strongFix,
     manual: args.includes('--manual'),
     auto: args.includes('--auto'),
     withModel: args.includes('--with-model'),
     withChannel: args.includes('--with-channel'),
+    optimizeToken: args.includes('--optimize-token'),
+    collectEvidence: args.includes('--collect-evidence') || args.includes('--evidence'),
+    evidenceQuick: args.includes('--evidence-quick'),
     quiet: args.includes('--quiet') || args.includes('-q'),
     help: args.includes('--help') || args.includes('-h'),
   };
 }
 
+function parseSemver(version) {
+  if (!version || typeof version !== 'string') return null;
+  const core = version.trim().replace(/^v/i, '').split('-')[0];
+  const parts = core.split('.').map((item) => Number.parseInt(item, 10));
+  if (parts.length < 2 || parts.some((item) => Number.isNaN(item))) return null;
+  while (parts.length < 3) parts.push(0);
+  return parts.slice(0, 3);
+}
+
+function compareSemver(currentVersion, targetVersion) {
+  const current = parseSemver(currentVersion);
+  const target = parseSemver(targetVersion);
+  if (!current || !target) return 0;
+
+  for (let index = 0; index < 3; index += 1) {
+    if (current[index] < target[index]) return -1;
+    if (current[index] > target[index]) return 1;
+  }
+  return 0;
+}
+
+function timestampForFile() {
+  const now = new Date();
+  const pad = (v) => String(v).padStart(2, '0');
+  return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+}
+
+function sanitizeText(input = '') {
+  if (!input) return '';
+  const patterns = [
+    /(token\s*[=:]\s*)([A-Za-z0-9._\-]{8,})/gi,
+    /("token"\s*:\s*")([^"]+)(")/gi,
+    /("api[_-]?key"\s*:\s*")([^"]+)(")/gi,
+    /(sk-[A-Za-z0-9]{12,})/g,
+    /(Bearer\s+)([A-Za-z0-9._\-]{8,})/gi,
+    /([?&]token=)([^&\s]+)/gi,
+  ];
+
+  let result = input;
+  for (const pattern of patterns) {
+    result = result.replace(pattern, (match, p1, p2, p3) => {
+      if (typeof p3 === 'string') {
+        return `${p1}<REDACTED>${p3}`;
+      }
+      return `${p1}<REDACTED>`;
+    });
+  }
+  return result;
+}
+
+function truncateText(input = '', limit = 20000) {
+  if (!input) return '';
+  if (input.length <= limit) return input;
+  return `${input.slice(0, limit)}\n\n...[TRUNCATED ${input.length - limit} chars]`;
+}
+
+function safeFileRead(path) {
+  try {
+    if (!path || !existsSync(path)) return '';
+    return readFileSync(path, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function runCmdCapture(cmd, timeout = 20000) {
+  const result = safeExec(cmd, { timeout });
+  if (result.ok) {
+    return {
+      ok: true,
+      cmd,
+      output: sanitizeText(truncateText(result.output || '', 40000)),
+    };
+  }
+
+  return {
+    ok: false,
+    cmd,
+    error: sanitizeText(truncateText(result.stderr || result.error || 'unknown error', 12000)),
+  };
+}
+
+function detectDesktopPath() {
+  const home = homedir();
+  const candidates = [
+    join(home, 'Desktop'),
+    join(home, '桌面'),
+  ];
+
+  for (const path of candidates) {
+    if (existsSync(path)) return path;
+  }
+  return process.cwd();
+}
+
+function maskPathForUser(path) {
+  const home = homedir();
+  return path.startsWith(home) ? path.replace(home, '~') : path;
+}
+
+function gatherEnvironmentSnapshot() {
+  const config = getConfigInfo();
+  const existing = detectExistingInstall();
+
+  const snapshot = {
+    timestamp: new Date().toISOString(),
+    os: {
+      platform: platform(),
+      release: release(),
+      arch: arch(),
+      hostname: hostname(),
+    },
+    runtime: {
+      node: process.version,
+      npm: runCmdCapture('npm -v', 10000),
+      npx: runCmdCapture('npx -v', 10000),
+    },
+    openclaw: {
+      detectedInstall: existing,
+      configPath: config.configPath || '',
+      configDir: config.configDir || '',
+      gatewayPort: Number(config.port || DEFAULT_GATEWAY_PORT),
+      hasToken: Boolean(getDashboardToken(config)),
+      hasModelConfig: config.raw.includes('"models"') || config.raw.includes('"providers"') || config.raw.includes('"apiKey"') || config.raw.includes('"api_key"'),
+    },
+  };
+
+  return snapshot;
+}
+
+function jsonSafeParse(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function detectConfigFormat(configPath = '') {
+  const lower = (configPath || '').toLowerCase();
+  if (lower.endsWith('.json5')) return 'json5';
+  return 'json';
+}
+
+function createTokenOptimizationPlan() {
+  return {
+    memory: {
+      enabled: true,
+      collections: {
+        conversations: {
+          retention_days: 14,
+          max_entries: 2000,
+          auto_summarize: true,
+          summarize_threshold: 25,
+        },
+      },
+      retrieval: {
+        default_limit: 4,
+        similarity_threshold: 0.82,
+        rerank: true,
+      },
+    },
+  };
+}
+
+function ensureObjectPath(base, pathParts) {
+  let cursor = base;
+  for (const part of pathParts) {
+    if (!cursor[part] || typeof cursor[part] !== 'object' || Array.isArray(cursor[part])) {
+      cursor[part] = {};
+    }
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+
+function applyTokenOptimizationToJson(configJson) {
+  const root = configJson && typeof configJson === 'object' ? configJson : {};
+  const before = JSON.parse(JSON.stringify(root));
+
+  const memory = ensureObjectPath(root, ['memory']);
+  memory.enabled = true;
+
+  const collections = ensureObjectPath(memory, ['collections']);
+  const conversations = ensureObjectPath(collections, ['conversations']);
+  conversations.retention_days = 14;
+  conversations.max_entries = 2000;
+  conversations.auto_summarize = true;
+  conversations.summarize_threshold = 25;
+
+  const retrieval = ensureObjectPath(memory, ['retrieval']);
+  retrieval.default_limit = 4;
+  retrieval.similarity_threshold = 0.82;
+  retrieval.rerank = true;
+
+  return { before, after: root };
+}
+
+function applyTokenOptimizationToJson5Raw(raw) {
+  const addSnippet = [
+    '',
+    '// openclawsetup token optimization start',
+    'memory: {',
+    '  enabled: true,',
+    '  collections: {',
+    '    conversations: {',
+    '      retention_days: 14,',
+    '      max_entries: 2000,',
+    '      auto_summarize: true,',
+    '      summarize_threshold: 25,',
+    '    },',
+    '  },',
+    '  retrieval: {',
+    '    default_limit: 4,',
+    '    similarity_threshold: 0.82,',
+    '    rerank: true,',
+    '  },',
+    '},',
+    '// openclawsetup token optimization end',
+    '',
+  ].join('\n');
+
+  if (!raw || typeof raw !== 'string') return addSnippet;
+  if (raw.includes('openclawsetup token optimization start')) {
+    return raw;
+  }
+
+  const trimmed = raw.trimEnd();
+  if (trimmed.endsWith('}')) {
+    const idx = raw.lastIndexOf('}');
+    return `${raw.slice(0, idx)}${addSnippet}\n}`;
+  }
+  return `${raw}\n${addSnippet}`;
+}
+
+function calculateTokenOptimizationDiff(beforeObj, afterObj) {
+  const get = (obj, path, fallback = null) => {
+    const keys = path.split('.');
+    let cursor = obj;
+    for (const key of keys) {
+      if (!cursor || typeof cursor !== 'object' || !(key in cursor)) return fallback;
+      cursor = cursor[key];
+    }
+    return cursor;
+  };
+
+  return {
+    conversationsRetentionDays: {
+      before: get(beforeObj, 'memory.collections.conversations.retention_days', '<unset>'),
+      after: get(afterObj, 'memory.collections.conversations.retention_days', '<unset>'),
+    },
+    conversationsMaxEntries: {
+      before: get(beforeObj, 'memory.collections.conversations.max_entries', '<unset>'),
+      after: get(afterObj, 'memory.collections.conversations.max_entries', '<unset>'),
+    },
+    summarizeThreshold: {
+      before: get(beforeObj, 'memory.collections.conversations.summarize_threshold', '<unset>'),
+      after: get(afterObj, 'memory.collections.conversations.summarize_threshold', '<unset>'),
+    },
+    retrievalLimit: {
+      before: get(beforeObj, 'memory.retrieval.default_limit', '<unset>'),
+      after: get(afterObj, 'memory.retrieval.default_limit', '<unset>'),
+    },
+    similarityThreshold: {
+      before: get(beforeObj, 'memory.retrieval.similarity_threshold', '<unset>'),
+      after: get(afterObj, 'memory.retrieval.similarity_threshold', '<unset>'),
+    },
+  };
+}
+
+async function optimizeTokenUsage(cliName = 'openclaw') {
+  console.log(colors.bold(colors.cyan('\n🪶 输入 Token 优化\n')));
+
+  const config = getConfigInfo();
+  if (!config.configPath || !existsSync(config.configPath)) {
+    log.warn('未找到配置文件，尝试先生成配置...');
+    const ensured = ensureConfigFilePresent(config, cliName);
+    if (!ensured.ok) {
+      log.error('无法生成配置文件，Token 优化中止');
+      return { ok: false, reason: 'config-missing' };
+    }
+  }
+
+  const freshConfig = getConfigInfo();
+  const raw = safeFileRead(freshConfig.configPath);
+  const format = detectConfigFormat(freshConfig.configPath);
+  const backupPath = `${freshConfig.configPath}.token-optimize.bak.${Date.now()}`;
+
+  try {
+    renameSync(freshConfig.configPath, backupPath);
+  } catch (e) {
+    log.error(`备份配置失败: ${e.message}`);
+    return { ok: false, reason: 'backup-failed' };
+  }
+
+  const optimizationPlan = createTokenOptimizationPlan();
+  let optimizationDiff = null;
+
+  try {
+    if (format === 'json') {
+      const parsed = jsonSafeParse(raw) || {};
+      const { before, after } = applyTokenOptimizationToJson(parsed);
+      optimizationDiff = calculateTokenOptimizationDiff(before, after);
+      writeFileSync(freshConfig.configPath, `${JSON.stringify(after, null, 2)}\n`, 'utf8');
+    } else {
+      const updatedRaw = applyTokenOptimizationToJson5Raw(raw);
+      writeFileSync(freshConfig.configPath, updatedRaw, 'utf8');
+      optimizationDiff = {
+        format: 'json5',
+        action: 'append-snippet',
+      };
+    }
+  } catch (e) {
+    writeFileSync(freshConfig.configPath, raw, 'utf8');
+    log.error(`写入优化配置失败，已恢复原配置: ${e.message}`);
+    return { ok: false, reason: 'write-failed' };
+  }
+
+  const restartResult = await ensureGatewayRunning(cliName, 'restart');
+  if (!restartResult.ok) {
+    log.warn('配置已更新，但 Gateway 重启失败，请手动执行 gateway restart');
+  }
+
+  log.success('Token 优化配置已应用');
+  log.hint(`原配置备份: ${maskPathForUser(backupPath)}`);
+  console.log(colors.cyan('优化目标: 降低长期记忆召回和历史膨胀导致的输入 token')); 
+
+  if (optimizationDiff && optimizationDiff.format !== 'json5') {
+    console.log(colors.gray(`  retention_days: ${optimizationDiff.conversationsRetentionDays.before} -> ${optimizationDiff.conversationsRetentionDays.after}`));
+    console.log(colors.gray(`  max_entries: ${optimizationDiff.conversationsMaxEntries.before} -> ${optimizationDiff.conversationsMaxEntries.after}`));
+    console.log(colors.gray(`  summarize_threshold: ${optimizationDiff.summarizeThreshold.before} -> ${optimizationDiff.summarizeThreshold.after}`));
+    console.log(colors.gray(`  retrieval.default_limit: ${optimizationDiff.retrievalLimit.before} -> ${optimizationDiff.retrievalLimit.after}`));
+    console.log(colors.gray(`  retrieval.similarity_threshold: ${optimizationDiff.similarityThreshold.before} -> ${optimizationDiff.similarityThreshold.after}`));
+  } else {
+    console.log(colors.gray('  已为 JSON5 配置追加 token 优化片段（可手动微调）。'));
+  }
+
+  console.log('');
+  return { ok: true, backupPath, optimizationPlan, optimizationDiff };
+}
+
+async function collectEvidencePackage(options = {}) {
+  const quick = Boolean(options.quick);
+  const startedAt = Date.now();
+
+  console.log(colors.bold(colors.cyan('\n📦 生成 OpenClaw 排障证据包\n')));
+  log.info('正在采集环境信息、状态、日志（已自动脱敏）...');
+
+  const desktopPath = detectDesktopPath();
+  const stamp = timestampForFile();
+  const folderName = `${EVIDENCE_DIR_NAME}-${stamp}`;
+  const evidenceDir = join(desktopPath, folderName);
+  mkdirSync(evidenceDir, { recursive: true });
+
+  const snapshot = gatherEnvironmentSnapshot();
+  const tokenOptimizationPreview = createTokenOptimizationPlan();
+  const cliName = snapshot.openclaw.detectedInstall?.name || findWorkingCliName() || 'openclaw';
+
+  const captures = {
+    doctor: runCmdCapture(`${cliName} doctor`, quick ? 20000 : 90000),
+    status: runCmdCapture(`${cliName} status`, 20000),
+    gatewayLogs: runCmdCapture(`${cliName} gateway logs`, quick ? 20000 : 45000),
+    cliVersion: runCmdCapture(`${cliName} --version`, 15000),
+    npmListGlobalOpenclaw: runCmdCapture('npm ls -g openclaw --depth=0', 20000),
+    npmListGlobalClawdbot: runCmdCapture('npm ls -g clawdbot --depth=0', 20000),
+  };
+
+  const port = snapshot.openclaw.gatewayPort || DEFAULT_GATEWAY_PORT;
+  captures.portCheck = runCmdCapture(
+    platform() === 'win32'
+      ? `netstat -ano | findstr :${port}`
+      : `lsof -nP -iTCP:${port} -sTCP:LISTEN 2>/dev/null || netstat -tlnp 2>/dev/null | grep :${port}`,
+    15000,
+  );
+  captures.health = runCmdCapture(`curl -sS --max-time 5 http://127.0.0.1:${port}/health`, 10000);
+
+  let strongCheckResult = null;
+  if (!quick && snapshot.openclaw.detectedInstall?.installed) {
+    log.hint('执行一次强力检测并附加结果...');
+    strongCheckResult = await runHealthCheck(cliName, false, true);
+  }
+
+  const configRaw = safeFileRead(snapshot.openclaw.configPath);
+  const safeConfigPreview = sanitizeText(truncateText(configRaw, 20000));
+
+  const summary = {
+    meta: {
+      generatedAt: new Date().toISOString(),
+      durationMs: Date.now() - startedAt,
+      quick,
+      evidenceVersion: '1.0.0',
+    },
+    snapshot,
+    tokenOptimizationPreview,
+    captures,
+    strongCheck: strongCheckResult
+      ? {
+        issuesCount: strongCheckResult.issues?.length || 0,
+        fixedCount: strongCheckResult.fixed?.length || 0,
+        issues: strongCheckResult.issues || [],
+        fixed: strongCheckResult.fixed || [],
+      }
+      : null,
+  };
+
+  writeFileSync(join(evidenceDir, 'summary.json'), `${JSON.stringify(summary, null, 2)}\n`, 'utf8');
+  writeFileSync(join(evidenceDir, 'config.preview.json.txt'), `${safeConfigPreview || '<empty>'}\n`, 'utf8');
+
+  const readme = [
+    '# OpenClaw 排障证据包',
+    '',
+    `生成时间: ${new Date().toLocaleString()}`,
+    `系统: ${snapshot.os.platform} ${snapshot.os.release} (${snapshot.os.arch})`,
+    `检测 CLI: ${cliName}`,
+    '',
+    '## 文件说明',
+    '- summary.json: 机器可解析的完整诊断结果（已脱敏）',
+    '- config.preview.json.txt: 配置文件预览（已脱敏）',
+    '',
+    '## 发给技术支持',
+    '请把整个证据包文件夹（或 zip）发给技术支持即可。',
+  ].join('\n');
+  writeFileSync(join(evidenceDir, 'README.txt'), `${readme}\n`, 'utf8');
+
+  let archivePath = '';
+  if (platform() !== 'win32') {
+    const tarPath = `${evidenceDir}.tar.gz`;
+    const tarResult = safeExec(`tar -czf "${tarPath}" -C "${desktopPath}" "${folderName}"`, { timeout: 30000 });
+    if (tarResult.ok && existsSync(tarPath)) {
+      archivePath = tarPath;
+    }
+  }
+
+  console.log('');
+  log.success('证据包已生成（内容已自动脱敏）');
+  console.log(colors.cyan(`目录: ${maskPathForUser(evidenceDir)}`));
+  if (archivePath) {
+    console.log(colors.cyan(`压缩包: ${maskPathForUser(archivePath)}`));
+  }
+  console.log(colors.yellow('请将该目录（或压缩包）直接发给技术支持。'));
+  console.log('');
+
+  return { evidenceDir, archivePath, summary };
+}
+
 function showHelp() {
+  const pkgVersion = (() => {
+    try {
+      const pkgJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+      return pkgJson.version || 'unknown';
+    } catch {
+      return 'unknown';
+    }
+  })();
+
   console.log(`
-${colors.bold('OpenClaw 安装向导 v2.3')}
+${colors.bold(`OpenClaw 安装向导 v${pkgVersion}`)}
 
 ${colors.cyan('基础用法:')}
   npx openclawsetup              交互式菜单（已安装）/ 安装向导（未安装）
   npx openclawsetup --check      检查配置和服务状态
   npx openclawsetup --fix        检查并自动修复常见问题
+  npx openclawsetup --strong-fix 强力模式（多轮深度检查 + 强修复）
+  npx openclawsetup --optimize-token 一键优化输入 token（记忆/召回瘦身）
+  npx openclawsetup --collect-evidence  一键导出排障证据包（给技术支持）
   npx openclawsetup --update     更新已安装的 OpenClaw
   npx openclawsetup --reinstall  卸载后重新安装
   npx openclawsetup --uninstall  卸载 OpenClaw
@@ -116,6 +617,11 @@ ${colors.cyan('安装模式:')}
 ${colors.cyan('高级选项:')}
   --with-model    检测到模型配置时暂停自动选择
   --with-channel  检测到渠道配置时暂停自动选择
+  --strong        与 --check/--fix 搭配，启用强力策略
+  --strong-fix    直接执行强力检查修复
+  --optimize-token 直接执行 token 优化配置（无需进菜单）
+  --evidence      等价于 --collect-evidence
+  --evidence-quick 快速证据包（跳过深度检测）
 
 ${colors.cyan('安装后配置模型:')}
   npx openclawapi@latest preset-claude    # 一键配置 Claude
@@ -204,26 +710,48 @@ function fixNpmCacheOwnership() {
   }
 }
 
+function isRealGatewayCli(name) {
+  const result = safeExec(`${name} --version`);
+  if (!result.ok) return false;
+  if (result.output && result.output.toLowerCase().includes('openclawapi')) return false;
+
+  const whichResult = safeExec(platform() === 'win32' ? `where ${name}` : `command -v ${name}`);
+  if (whichResult.ok && whichResult.output) {
+    try {
+      const realPath = realpathSync(whichResult.output.trim());
+      if (realPath.toLowerCase().includes('openclawapi')) return false;
+    } catch {
+      // ignore
+    }
+  }
+  return true;
+}
+
+function findWorkingCliName() {
+  for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
+    if (isRealGatewayCli(name)) return name;
+  }
+  return null;
+}
+
 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 };
+  if (existsSync(openclawDir) || existsSync(clawdbotDir)) {
+    const configDir = existsSync(openclawDir) ? openclawDir : clawdbotDir;
+    const cliName = findWorkingCliName();
+    if (cliName) {
+      return { installed: true, configDir, name: cliName };
+    }
+    // Config dir exists but no working CLI found
+    return { installed: true, configDir, name: existsSync(openclawDir) ? 'openclaw' : 'clawdbot', cliMissing: true };
   }
 
-  const clawdbotResult = safeExec('clawdbot --version');
-  if (clawdbotResult.ok) {
-    return { installed: true, name: 'clawdbot', version: clawdbotResult.output };
+  const cliName = findWorkingCliName();
+  if (cliName) {
+    return { installed: true, name: cliName };
   }
 
   return { installed: false };
@@ -268,6 +796,490 @@ function getConfigInfo() {
   return { configDir: '', configPath: '', token: '', port: 18789, bind: '', raw: '' };
 }
 
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isPortInUse(port, host = '127.0.0.1') {
+  return new Promise((resolve) => {
+    const server = createServer();
+
+    server.once('error', (err) => {
+      if (err && err.code === 'EADDRINUSE') {
+        resolve(true);
+      } else {
+        resolve(false);
+      }
+    });
+
+    server.once('listening', () => {
+      server.close(() => resolve(false));
+    });
+
+    server.listen(port, host);
+  });
+}
+
+async function findAvailablePort(preferredPort = DEFAULT_GATEWAY_PORT) {
+  const candidates = [preferredPort, ...STRONG_PORT_CANDIDATES.filter((p) => p !== preferredPort)];
+  for (const port of candidates) {
+    const inUse = await isPortInUse(port);
+    if (!inUse) return port;
+  }
+
+  for (let dynamicPort = 19000; dynamicPort <= 19999; dynamicPort += 1) {
+    const inUse = await isPortInUse(dynamicPort);
+    if (!inUse) return dynamicPort;
+  }
+  return null;
+}
+
+function extractAuthToken(configRaw = '') {
+  if (!configRaw) return '';
+  const tokenPatterns = [
+    /"token"\s*:\s*"([^"]+)"/i,
+    /"gatewayToken"\s*:\s*"([^"]+)"/i,
+    /"auth"\s*:\s*\{[\s\S]*?"token"\s*:\s*"([^"]+)"/i,
+  ];
+  for (const pattern of tokenPatterns) {
+    const match = configRaw.match(pattern);
+    if (match?.[1]) return match[1];
+  }
+  return '';
+}
+
+function getDashboardToken(config) {
+  if (config?.token) return config.token;
+  return extractAuthToken(config?.raw || '') || '';
+}
+
+function parseStatusOutput(statusOutput) {
+  const text = (statusOutput || '').toLowerCase();
+  const runningKeywords = ['running', 'active', '已运行', '运行中', '在线'];
+  const stoppedKeywords = ['stopped', 'inactive', 'not running', '未运行', '停止'];
+
+  if (runningKeywords.some((word) => text.includes(word))) return 'running';
+  if (stoppedKeywords.some((word) => text.includes(word))) return 'stopped';
+  return 'unknown';
+}
+
+function getPortCheckOutput(port) {
+  const cmd = platform() === 'win32'
+    ? `netstat -ano | findstr :${port}`
+    : `lsof -nP -iTCP:${port} -sTCP:LISTEN 2>/dev/null || netstat -tlnp 2>/dev/null | grep :${port}`;
+  return safeExec(cmd);
+}
+
+function getPortConflictDetail(port) {
+  const cmd = platform() === 'win32'
+    ? `netstat -ano | findstr :${port} | findstr LISTENING`
+    : `lsof -nP -iTCP:${port} -sTCP:LISTEN 2>/dev/null | head -8`;
+  return safeExec(cmd);
+}
+
+function isLikelyOpenClawProcess(output = '') {
+  const text = output.toLowerCase();
+  return (
+    text.includes('openclaw') ||
+    text.includes('clawdbot') ||
+    text.includes('moltbot') ||
+    text.includes('gateway') ||
+    text.includes('node')
+  );
+}
+
+function gatewayHealthRequest(port, path = '/health') {
+  const endpoint = `http://127.0.0.1:${port}${path}`;
+  const curlCmd = `curl -sS --max-time 5 --connect-timeout 2 ${endpoint}`;
+  return safeExec(curlCmd, { timeout: 7000 });
+}
+
+function parseHealthOutput(raw = '') {
+  if (!raw) return { healthy: false, detail: '空响应' };
+
+  const lower = raw.toLowerCase();
+  if (lower.includes('ok') || lower.includes('healthy') || lower.includes('success')) {
+    return { healthy: true, detail: raw.slice(0, 300) };
+  }
+
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.status === 'ok' || parsed?.healthy === true || parsed?.ok === true) {
+      return { healthy: true, detail: JSON.stringify(parsed).slice(0, 300), parsed };
+    }
+    return { healthy: false, detail: JSON.stringify(parsed).slice(0, 300), parsed };
+  } catch {
+    return { healthy: false, detail: raw.slice(0, 300) };
+  }
+}
+
+function runGatewayCommand(cliName, action) {
+  return safeExec(`${cliName} gateway ${action}`);
+}
+
+async function ensureGatewayRunning(cliName, preferredAction = 'start') {
+  const actions = preferredAction === 'restart'
+    ? ['restart', 'start', 'stop', 'start']
+    : ['start', 'restart', 'stop', 'start'];
+
+  for (const action of actions) {
+    const result = runGatewayCommand(cliName, action);
+    if (result.ok) {
+      await sleep(2200);
+      const statusCheck = safeExec(`${cliName} status`);
+      if (statusCheck.ok && parseStatusOutput(statusCheck.output) === 'running') {
+        return { ok: true, action };
+      }
+    }
+  }
+  return { ok: false, action: actions[actions.length - 1] };
+}
+
+function parseDoctorProblems(output = '') {
+  const text = output.toLowerCase();
+  const keywords = ['error', 'fail', 'failed', 'problem', '问题', '失败', '错误'];
+  return keywords.some((word) => text.includes(word));
+}
+
+function detectNpmInstallState(packageName) {
+  const result = safeExec(`npm ls -g ${packageName} --depth=0`);
+  if (!result.ok) return { installed: false, output: result.stderr || result.error || '' };
+  return { installed: true, output: result.output || '' };
+}
+
+function installCliPackage(packageName, strongMode = false) {
+  const useSudo = needsSudo();
+  const baseInstall = useSudo
+    ? `sudo npm install -g ${packageName}@latest`
+    : `npm install -g ${packageName}@latest`;
+
+  const registries = strongMode
+    ? ['', 'https://registry.npmjs.org', 'https://registry.npmmirror.com']
+    : [''];
+
+  for (const registry of registries) {
+    const cmd = registry
+      ? `${baseInstall} --registry ${registry}`
+      : baseInstall;
+    const result = safeExec(cmd, { timeout: 240000 });
+    if (result.ok) {
+      return { ok: true, method: registry ? `registry:${registry}` : 'default' };
+    }
+  }
+
+  if (strongMode) {
+    safeExec('npm cache clean --force', { timeout: 120000 });
+    for (const registry of registries) {
+      const cmd = registry
+        ? `${baseInstall} --registry ${registry}`
+        : baseInstall;
+      const retry = safeExec(cmd, { timeout: 240000 });
+      if (retry.ok) {
+        return { ok: true, method: registry ? `cache-retry:${registry}` : 'cache-retry:default' };
+      }
+    }
+  }
+
+  if (strongMode) {
+    const tarball = safeExec(`npm view ${packageName}@latest dist.tarball --registry https://registry.npmjs.org`);
+    if (tarball.ok && tarball.output) {
+      const tarballInstall = useSudo
+        ? `sudo npm install -g ${tarball.output.trim()}`
+        : `npm install -g ${tarball.output.trim()}`;
+      const tarballResult = safeExec(tarballInstall, { timeout: 240000 });
+      if (tarballResult.ok) {
+        return { ok: true, method: 'tarball' };
+      }
+    }
+  }
+
+  return { ok: false, method: 'failed' };
+}
+
+function tryRecoverCliBinary(cliName, strongMode = false) {
+  const candidates = [
+    { bin: 'openclaw', pkg: 'openclaw' },
+    { bin: 'clawdbot', pkg: 'clawdbot' },
+    { bin: 'moltbot', pkg: 'moltbot' },
+  ];
+
+  const preferred = candidates.find((item) => item.bin === cliName);
+  const ordered = preferred
+    ? [preferred, ...candidates.filter((item) => item.bin !== cliName)]
+    : candidates;
+
+  for (const candidate of ordered) {
+    const installedState = detectNpmInstallState(candidate.pkg);
+    if (!installedState.installed) {
+      const installResult = installCliPackage(candidate.pkg, strongMode);
+      if (!installResult.ok) continue;
+    }
+
+    if (isRealGatewayCli(candidate.bin)) {
+      return { ok: true, cliName: candidate.bin, packageName: candidate.pkg };
+    }
+
+    if (strongMode) {
+      const uninstallCmd = needsSudo()
+        ? `sudo npm uninstall -g ${candidate.pkg}`
+        : `npm uninstall -g ${candidate.pkg}`;
+      safeExec(uninstallCmd, { timeout: 120000 });
+    }
+
+    const reinstallResult = installCliPackage(candidate.pkg, strongMode);
+    if (reinstallResult.ok && isRealGatewayCli(candidate.bin)) {
+      return { ok: true, cliName: candidate.bin, packageName: candidate.pkg };
+    }
+  }
+
+  return { ok: false, cliName };
+}
+
+function ensureConfigFilePresent(config, cliName) {
+  if (config.configPath && existsSync(config.configPath)) {
+    return { ok: true, repaired: false, note: '配置文件存在' };
+  }
+  const result = safeExec(`${cliName} onboard --install-daemon`, { timeout: 240000 });
+  if (!result.ok && process.stdin.isTTY && process.stdout.isTTY) {
+    spawnSync(cliName, ['onboard'], { stdio: 'inherit', shell: true });
+  }
+  const recheck = getConfigInfo();
+  if (recheck.configPath && existsSync(recheck.configPath)) {
+    return { ok: true, repaired: true, note: '已重新生成配置文件' };
+  }
+  return { ok: false, repaired: false, note: '无法自动生成配置文件' };
+}
+
+function backupBrokenConfig(configPath) {
+  const backupPath = `${configPath}.bak.${Date.now()}`;
+  renameSync(configPath, backupPath);
+  return backupPath;
+}
+
+async function repairBrokenConfig(config, cliName, strongMode = false) {
+  if (!config.configPath || !existsSync(config.configPath)) {
+    return { ok: false, repaired: false, note: '配置文件不存在' };
+  }
+
+  try {
+    JSON.parse(readFileSync(config.configPath, 'utf8'));
+    return { ok: true, repaired: false, note: '配置文件 JSON 正常' };
+  } catch {
+    try {
+      const backupPath = backupBrokenConfig(config.configPath);
+      const onboardArgs = strongMode ? ['onboard', '--install-daemon'] : ['onboard'];
+      spawnSync(cliName, onboardArgs, { stdio: 'inherit', shell: true });
+      const recheck = getConfigInfo();
+      if (recheck.configPath && existsSync(recheck.configPath)) {
+        return {
+          ok: true,
+          repaired: true,
+          note: `配置损坏已备份并重建 (${backupPath})`,
+          backupPath,
+        };
+      }
+      return { ok: false, repaired: false, note: `配置已备份但重建失败 (${backupPath})`, backupPath };
+    } catch (e) {
+      return { ok: false, repaired: false, note: `配置修复失败: ${e.message}` };
+    }
+  }
+}
+
+function selectHealthPort(config, strongMode = false) {
+  const candidate = Number(config?.port || DEFAULT_GATEWAY_PORT);
+  if (Number.isInteger(candidate) && candidate > 0) return candidate;
+  return strongMode ? STRONG_PORT_CANDIDATES[0] : DEFAULT_GATEWAY_PORT;
+}
+
+async function tryFixPortConflict(cliName, currentPort) {
+  const availablePort = await findAvailablePort(currentPort);
+  if (!availablePort || availablePort === currentPort) {
+    return { ok: false, newPort: currentPort, note: '未找到可用替代端口' };
+  }
+
+  const setResult = safeExec(`${cliName} config set gateway.port ${availablePort}`);
+  if (!setResult.ok) {
+    return { ok: false, newPort: currentPort, note: `端口切换失败: ${setResult.stderr || setResult.error}` };
+  }
+
+  const restartResult = await ensureGatewayRunning(cliName, 'restart');
+  if (!restartResult.ok) {
+    return { ok: false, newPort: currentPort, note: '已切换端口但 Gateway 重启失败' };
+  }
+
+  return { ok: true, newPort: availablePort, note: `端口已切换到 ${availablePort}` };
+}
+
+function summarizeIssue(level, title, detail, solution, fixCmd = '') {
+  return { level, title, detail, solution, fixCmd };
+}
+
+function collectGatewayLogs(cliName, lines = 80) {
+  const candidates = [
+    `${cliName} gateway logs --lines ${lines}`,
+    `${cliName} gateway logs -n ${lines}`,
+    `${cliName} gateway logs`,
+  ];
+
+  for (const cmd of candidates) {
+    const result = safeExec(cmd, { timeout: 20000 });
+    if (result.ok && result.output) {
+      return { ok: true, output: result.output.slice(-2000) };
+    }
+  }
+  return { ok: false, output: '' };
+}
+
+async function runOfficialDoctor(cliName, autoFix = false, strongMode = false) {
+  const doctorResult = safeExec(`${cliName} doctor`, { timeout: strongMode ? 120000 : 60000 });
+
+  if (!doctorResult.ok) {
+    return {
+      ok: false,
+      issue: summarizeIssue(
+        'warning',
+        '官方诊断执行失败',
+        doctorResult.stderr || doctorResult.error || 'doctor 命令失败',
+        `运行 ${cliName} doctor 查看详情`,
+        `${cliName} doctor`,
+      ),
+    };
+  }
+
+  if (!parseDoctorProblems(doctorResult.output)) {
+    return { ok: true, fixed: false, issue: null };
+  }
+
+  if (!autoFix) {
+    return {
+      ok: false,
+      issue: summarizeIssue(
+        'warning',
+        '官方诊断发现问题',
+        doctorResult.output.slice(0, 260),
+        `运行 ${cliName} doctor --fix 尝试自动修复`,
+        `${cliName} doctor --fix`,
+      ),
+    };
+  }
+
+  const fixResult = safeExec(`${cliName} doctor --fix`, { timeout: strongMode ? 180000 : 90000 });
+  if (fixResult.ok) {
+    return { ok: true, fixed: true, issue: null };
+  }
+
+  return {
+    ok: false,
+    issue: summarizeIssue(
+      'warning',
+      '官方自动修复失败',
+      fixResult.stderr || fixResult.error || 'doctor --fix 执行失败',
+      `查看日志: ${cliName} gateway logs`,
+      `${cliName} doctor`,
+    ),
+  };
+}
+
+async function verifyGatewayApi(port, cliName, autoFix = false, strongMode = false) {
+  const paths = ['/health', '/api/health', '/status'];
+
+  for (const path of paths) {
+    const healthResult = gatewayHealthRequest(port, path);
+    if (!healthResult.ok) continue;
+    const parsed = parseHealthOutput(healthResult.output);
+    if (parsed.healthy) {
+      return { ok: true, issue: null };
+    }
+  }
+
+  const issue = summarizeIssue(
+    'error',
+    'API 无响应',
+    `无法连接到 Gateway API (127.0.0.1:${port})`,
+    `重启服务: ${cliName} gateway restart`,
+    `${cliName} gateway restart`,
+  );
+
+  if (!autoFix) {
+    return { ok: false, issue, fixed: false };
+  }
+
+  const recovered = await ensureGatewayRunning(cliName, 'restart');
+  if (!recovered.ok) {
+    return { ok: false, issue, fixed: false };
+  }
+
+  await sleep(strongMode ? 3500 : 2000);
+
+  for (const path of paths) {
+    const retryResult = gatewayHealthRequest(port, path);
+    if (!retryResult.ok) continue;
+    const parsed = parseHealthOutput(retryResult.output);
+    if (parsed.healthy) {
+      return { ok: true, issue: null, fixed: true };
+    }
+  }
+
+  return { ok: false, issue, fixed: false };
+}
+
+async function validateModelConfig(autoFix = false, strongMode = false) {
+  const config = getConfigInfo();
+  if (!config.raw) {
+    return {
+      ok: false,
+      issue: summarizeIssue(
+        'warning',
+        '模型配置状态未知',
+        '未读取到配置文件内容',
+        '运行 npx openclawapi@latest 配置模型',
+        'npx openclawapi@latest',
+      ),
+      fixed: false,
+    };
+  }
+
+  const hasModels = config.raw.includes('"models"') || config.raw.includes('"providers"');
+  const hasApiKey = config.raw.includes('"apiKey"') || config.raw.includes('"api_key"');
+  if (hasModels || hasApiKey) {
+    return { ok: true, issue: null, fixed: false };
+  }
+
+  const issue = summarizeIssue(
+    'warning',
+    '未配置 AI 模型',
+    '配置文件中未找到模型或 API Key 配置',
+    '运行 npx openclawapi@latest 配置模型',
+    'npx openclawapi@latest',
+  );
+
+  if (!autoFix) {
+    return { ok: false, issue, fixed: false };
+  }
+
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    return { ok: false, issue, fixed: false };
+  }
+
+  if (strongMode) {
+    const presetResult = safeExec('npx openclawapi@latest preset-claude', { timeout: 180000 });
+    if (presetResult.ok) {
+      return { ok: true, issue: null, fixed: true };
+    }
+  }
+
+  spawnSync('npx', ['openclawapi@latest'], { stdio: 'inherit', shell: true });
+  const recheck = getConfigInfo();
+  const recheckHasModels = recheck.raw.includes('"models"') || recheck.raw.includes('"providers"');
+  const recheckHasApiKey = recheck.raw.includes('"apiKey"') || recheck.raw.includes('"api_key"');
+
+  if (recheckHasModels || recheckHasApiKey) {
+    return { ok: true, issue: null, fixed: true };
+  }
+
+  return { ok: false, issue, fixed: false };
+}
+
 function detectVps() {
   if (platform() !== 'linux') return false;
   // Cloud provider markers
@@ -833,7 +1845,7 @@ function showCompletionInfo(cliName) {
 function showDashboardAccessInfo() {
   const config = getConfigInfo();
   const port = config.port || 18789;
-  const token = config.token || '<你的token>';
+  const token = getDashboardToken(config) || '<你的token>';
   const dashboardUrl = `http://127.0.0.1:${port}/?token=${token}`;
 
   if (detectVps()) {
@@ -904,83 +1916,82 @@ async function uninstallOpenClaw(existing) {
 
 // ============ 健康检查 ============
 
-async function runHealthCheck(cliName, autoFix = false) {
-  console.log(colors.bold(colors.cyan('\n🔍 OpenClaw 健康检查\n')));
+async function runHealthCheck(cliName, autoFix = false, strongMode = false) {
+  const title = strongMode
+    ? '\n🔍 OpenClaw 健康检查（强力模式）\n'
+    : '\n🔍 OpenClaw 健康检查\n';
+  console.log(colors.bold(colors.cyan(title)));
 
-  const issues = [];
+  if (strongMode) {
+    log.hint('强力模式已启用：多轮复检 + 深度回收修复');
+  }
+
+  let activeCli = cliName;
   const fixed = [];
-  const config = getConfigInfo();
+  let finalIssues = [];
+  const totalPasses = strongMode && autoFix ? STRONG_FIX_MAX_PASSES : 1;
 
-  // 1. 检查配置文件
-  console.log(colors.cyan('检查配置文件...'));
-  if (!config.configPath || !existsSync(config.configPath)) {
-    const issue = {
-      level: 'error',
-      title: '配置文件不存在',
-      detail: '未找到 openclaw.json 配置文件',
-      solution: '运行 openclaw onboard 重新配置',
-      fixCmd: `${cliName} onboard`,
-    };
-    if (autoFix) {
-      console.log(colors.yellow('  尝试运行 onboard 生成配置...'));
-      spawnSync(cliName, ['onboard'], { stdio: 'inherit', shell: true });
-      fixed.push('已运行 onboard 生成配置');
-    } else {
-      issues.push(issue);
+  for (let pass = 1; pass <= totalPasses; pass += 1) {
+    const issues = [];
+    const fixedBeforePass = fixed.length;
+
+    if (totalPasses > 1) {
+      console.log(colors.bold(colors.cyan(`\n--- 第 ${pass}/${totalPasses} 轮深度检查 ---`)));
     }
-  } else {
-    try {
-      const raw = readFileSync(config.configPath, 'utf8');
-      JSON.parse(raw);
-      log.success('配置文件格式正确');
-    } catch (e) {
-      const issue = {
-        level: 'error',
-        title: '配置文件 JSON 格式错误',
-        detail: `解析失败: ${e.message}`,
-        solution: '备份并重新生成配置文件',
-        fixCmd: `mv ${config.configPath} ${config.configPath}.bak && ${cliName} onboard`,
-      };
+
+    // 1. 检查 CLI
+    console.log(colors.cyan('检查 CLI 命令可用性...'));
+    if (!isRealGatewayCli(activeCli)) {
+      const issue = summarizeIssue(
+        'error',
+        'OpenClaw CLI 命令不可用',
+        `当前命令 ${activeCli} 不可执行或不是 Gateway CLI`,
+        '重新安装 CLI 包并恢复命令链接',
+        `npm install -g ${activeCli}@latest`,
+      );
+
       if (autoFix) {
-        console.log(colors.yellow('  尝试修复配置文件...'));
-        const backupPath = `${config.configPath}.bak.${Date.now()}`;
-        try {
-          const { renameSync } = await import('fs');
-          renameSync(config.configPath, backupPath);
-          log.success(`已备份损坏的配置到 ${backupPath}`);
-          fixed.push('配置文件已备份，请重新运行 onboard');
-        } catch {
+        console.log(colors.yellow(`  尝试恢复 CLI 命令 (${activeCli})...`));
+        const recovered = tryRecoverCliBinary(activeCli, strongMode);
+        if (recovered.ok && recovered.cliName) {
+          activeCli = recovered.cliName;
+          log.success(`CLI 已恢复: ${activeCli}`);
+          fixed.push(`CLI 已自动恢复（${activeCli}）`);
+        } else {
           issues.push(issue);
         }
       } else {
         issues.push(issue);
       }
+    } else {
+      log.success(`CLI 可用: ${activeCli}`);
     }
-  }
 
-  // 2. 检查 Gateway 进程
-  console.log(colors.cyan('检查 Gateway 进程...'));
-  const statusResult = safeExec(`${cliName} status`);
-  if (statusResult.ok) {
-    const output = statusResult.output.toLowerCase();
-    if (output.includes('running') || output.includes('active')) {
-      log.success('Gateway 进程正在运行');
-    } else if (output.includes('stopped') || output.includes('inactive') || output.includes('not running')) {
-      const issue = {
-        level: 'error',
-        title: 'Gateway 未运行',
-        detail: 'Gateway 服务已停止',
-        solution: `运行 ${cliName} gateway start 启动服务`,
-        fixCmd: `${cliName} gateway start`,
-      };
+    if (!isRealGatewayCli(activeCli)) {
+      finalIssues = issues;
+      break;
+    }
+
+    // 2. 检查配置文件
+    console.log(colors.cyan('检查配置文件...'));
+    let config = getConfigInfo();
+
+    if (!config.configPath || !existsSync(config.configPath)) {
+      const issue = summarizeIssue(
+        'error',
+        '配置文件不存在',
+        '未找到 openclaw/clawdbot 配置文件',
+        `运行 ${activeCli} onboard 重新生成配置`,
+        `${activeCli} onboard`,
+      );
+
       if (autoFix) {
-        console.log(colors.yellow('  尝试启动 Gateway...'));
-        const startResult = safeExec(`${cliName} gateway start`);
-        if (startResult.ok) {
-          console.log(colors.gray('  等待 Gateway 启动...'));
-          await new Promise(r => setTimeout(r, 5000));
-          log.success('Gateway 已启动');
-          fixed.push('Gateway 已自动启动');
+        const recovered = ensureConfigFilePresent(config, activeCli);
+        if (recovered.ok) {
+          log.success(recovered.note);
+          if (recovered.repaired) {
+            fixed.push(recovered.note);
+          }
         } else {
           issues.push(issue);
         }
@@ -988,75 +1999,127 @@ async function runHealthCheck(cliName, autoFix = false) {
         issues.push(issue);
       }
     }
-  } else {
-    issues.push({
-      level: 'warning',
-      title: '无法获取 Gateway 状态',
-      detail: statusResult.error || '状态检查失败',
-      solution: `尝试运行 ${cliName} status 查看详情`,
-    });
-  }
 
-  // 3. 检查端口监听
-  console.log(colors.cyan('检查端口监听...'));
-  const port = config.port || 18789;
-  const portCheckCmd = platform() === 'win32'
-    ? `netstat -an | findstr :${port}`
-    : `lsof -i :${port} 2>/dev/null || netstat -tlnp 2>/dev/null | grep :${port}`;
-  const portResult = safeExec(portCheckCmd);
+    config = getConfigInfo();
+    if (config.configPath && existsSync(config.configPath)) {
+      const configRepair = await repairBrokenConfig(config, activeCli, strongMode);
+      if (configRepair.ok) {
+        log.success(configRepair.note);
+        if (configRepair.repaired) {
+          fixed.push(configRepair.note);
+        }
+      } else {
+        issues.push(
+          summarizeIssue(
+            'error',
+            '配置文件 JSON 格式错误',
+            configRepair.note,
+            `备份后重建配置: ${activeCli} onboard`,
+            `${activeCli} onboard`,
+          ),
+        );
+      }
+    }
+
+    // 3. 检查 Gateway 进程
+    console.log(colors.cyan('检查 Gateway 进程...'));
+    const statusResult = safeExec(`${activeCli} status`);
+    const statusState = statusResult.ok ? parseStatusOutput(statusResult.output) : 'unknown';
+
+    if (statusResult.ok && statusState === 'running') {
+      log.success('Gateway 进程正在运行');
+    } else {
+      const issue = summarizeIssue(
+        'error',
+        'Gateway 未运行',
+        statusResult.ok ? 'Gateway 状态为停止/未知' : (statusResult.stderr || statusResult.error || '状态检查失败'),
+        `运行 ${activeCli} gateway start 启动服务`,
+        `${activeCli} gateway start`,
+      );
 
-  if (portResult.ok && portResult.output) {
-    log.success(`端口 ${port} 正在监听`);
-  } else {
-    // 检查是否有其他进程占用端口
-    const conflictCmd = platform() === 'win32'
-      ? `netstat -ano | findstr :${port} | findstr LISTENING`
-      : `lsof -i :${port} 2>/dev/null | head -5`;
-    const conflictCheck = safeExec(conflictCmd);
-    if (conflictCheck.ok && conflictCheck.output && !conflictCheck.output.includes('openclaw') && !conflictCheck.output.includes('node')) {
-      const issue = {
-        level: 'error',
-        title: `端口 ${port} 被其他程序占用`,
-        detail: conflictCheck.output.slice(0, 100),
-        solution: `更换端口: ${cliName} config set gateway.port 18790`,
-        fixCmd: `${cliName} config set gateway.port 18790 && ${cliName} gateway restart`,
-      };
       if (autoFix) {
-        console.log(colors.yellow('  尝试更换端口到 18790...'));
-        const portResult = safeExec(`${cliName} config set gateway.port 18790`);
-        const restartResult = safeExec(`${cliName} gateway restart`);
-        if (portResult.ok && restartResult.ok) {
-          log.success('已更换端口到 18790 并重启 Gateway');
-          fixed.push('端口冲突已自动解决（更换到 18790）');
+        console.log(colors.yellow('  尝试恢复 Gateway 运行状态...'));
+        const recovered = await ensureGatewayRunning(activeCli, 'start');
+        if (recovered.ok) {
+          log.success(`Gateway 已恢复运行（${recovered.action}）`);
+          fixed.push(`Gateway 已自动恢复（${recovered.action}）`);
         } else {
           issues.push(issue);
         }
       } else {
         issues.push(issue);
       }
-    } else {
-      const issue = {
-        level: 'error',
-        title: `端口 ${port} 未监听`,
-        detail: 'Gateway 端口未开放，服务可能未正常启动',
-        solution: `运行 ${cliName} gateway restart`,
-        fixCmd: `${cliName} gateway restart`,
-      };
+    }
+
+    // 4. 检查端口监听
+    config = getConfigInfo();
+    let port = selectHealthPort(config, strongMode);
+    console.log(colors.cyan(`检查端口监听 (${port})...`));
+    let portHealthy = false;
+
+    const portResult = getPortCheckOutput(port);
+    if (portResult.ok && portResult.output) {
+      if (isLikelyOpenClawProcess(portResult.output)) {
+        log.success(`端口 ${port} 正在监听`);
+        portHealthy = true;
+      } else {
+        const issue = summarizeIssue(
+          'error',
+          `端口 ${port} 被其他程序占用`,
+          portResult.output.slice(0, 180),
+          `更换端口: ${activeCli} config set gateway.port <新端口>`,
+          `${activeCli} config set gateway.port 18790 && ${activeCli} gateway restart`,
+        );
+
+        if (autoFix) {
+          const portFix = await tryFixPortConflict(activeCli, port);
+          if (portFix.ok) {
+            port = portFix.newPort;
+            log.success(portFix.note);
+            fixed.push(`端口冲突已自动修复（${port}）`);
+            portHealthy = true;
+          } else {
+            issues.push(issue);
+          }
+        } else {
+          issues.push(issue);
+        }
+      }
+    }
+
+    if (!portHealthy) {
+      const conflictDetail = getPortConflictDetail(port);
+      const conflictText = conflictDetail.ok ? conflictDetail.output : '';
+      const issue = summarizeIssue(
+        'error',
+        `端口 ${port} 未监听`,
+        conflictText ? `端口状态异常: ${conflictText.slice(0, 180)}` : 'Gateway 端口未监听',
+        `重启服务: ${activeCli} gateway restart`,
+        `${activeCli} gateway restart`,
+      );
+
       if (autoFix) {
-        console.log(colors.yellow('  尝试重启 Gateway...'));
-        const restartResult = safeExec(`${cliName} gateway restart`);
-        if (restartResult.ok) {
-          // 等待 Gateway 绑定端口
-          console.log(colors.gray('  等待 Gateway 启动...'));
-          await new Promise(r => setTimeout(r, 5000));
-          // 重新检查端口
-          const recheck = safeExec(portCheckCmd);
+        console.log(colors.yellow('  尝试重启并恢复端口监听...'));
+        const recovered = await ensureGatewayRunning(activeCli, 'restart');
+        if (recovered.ok) {
+          await sleep(2500);
+          const recheck = getPortCheckOutput(port);
           if (recheck.ok && recheck.output) {
-            log.success('Gateway 已重启，端口正常');
-            fixed.push('Gateway 已自动重启');
+            log.success(`端口 ${port} 已恢复监听`);
+            fixed.push(`端口监听已恢复（${port}）`);
+            portHealthy = true;
+          } else if (strongMode) {
+            const portFix = await tryFixPortConflict(activeCli, port);
+            if (portFix.ok) {
+              port = portFix.newPort;
+              log.success(portFix.note);
+              fixed.push(`强力模式切换端口成功（${port}）`);
+              portHealthy = true;
+            } else {
+              issues.push(issue);
+            }
           } else {
-            log.warn('Gateway 已重启但端口仍未监听');
-            issues.push({ ...issue, detail: 'Gateway 重启后端口仍未监听，可能配置有问题' });
+            issues.push(issue);
           }
         } else {
           issues.push(issue);
@@ -1065,106 +2128,112 @@ async function runHealthCheck(cliName, autoFix = false) {
         issues.push(issue);
       }
     }
-  }
 
-  // 4. 检查 API 健康
-  console.log(colors.cyan('检查 API 健康状态...'));
-  const healthResult = safeExec(`curl -s --connect-timeout 3 http://127.0.0.1:${port}/health`);
-  if (healthResult.ok && healthResult.output) {
-    try {
-      const health = JSON.parse(healthResult.output);
-      if (health.status === 'ok' || health.healthy) {
-        log.success('API 健康检查通过');
-      } else {
-        issues.push({
-          level: 'warning',
-          title: 'API 健康状态异常',
-          detail: JSON.stringify(health),
-          solution: `运行 ${cliName} gateway logs 查看日志`,
-        });
+    // 5. 检查 API 健康
+    console.log(colors.cyan('检查 API 健康状态...'));
+    const apiCheck = await verifyGatewayApi(port, activeCli, autoFix, strongMode);
+    if (apiCheck.ok) {
+      log.success('API 健康检查通过');
+      if (apiCheck.fixed) {
+        fixed.push('API 无响应问题已自动修复');
       }
-    } catch {
-      if (healthResult.output.includes('ok') || healthResult.output.includes('healthy')) {
-        log.success('API 健康检查通过');
-      } else {
-        log.warn('API 返回非标准格式');
+    } else if (apiCheck.issue) {
+      issues.push(apiCheck.issue);
+    }
+
+    // 6. 检查模型配置
+    console.log(colors.cyan('检查模型配置...'));
+    const modelCheck = await validateModelConfig(autoFix, strongMode);
+    if (modelCheck.ok) {
+      log.success('模型配置检查通过');
+      if (modelCheck.fixed) {
+        fixed.push('模型配置已自动补全');
       }
+    } else if (modelCheck.issue) {
+      issues.push(modelCheck.issue);
     }
-  } else {
-    const issue = {
-      level: 'error',
-      title: 'API 无响应',
-      detail: '无法连接到 Gateway API',
-      solution: `重启服务: ${cliName} gateway restart`,
-      fixCmd: `${cliName} gateway restart`,
-    };
-    if (autoFix) {
-      console.log(colors.yellow('  尝试重启 Gateway...'));
-      const restartResult = safeExec(`${cliName} gateway restart`);
-      if (restartResult.ok) {
-        console.log(colors.gray('  等待 Gateway 启动...'));
-        await new Promise(r => setTimeout(r, 5000));
-        log.success('Gateway 已重启');
-        fixed.push('Gateway 已自动重启（API 无响应）');
+
+    // 6.5 强力模式：探测模型实际连通
+    if (strongMode) {
+      console.log(colors.cyan('强力模式：测试模型连通性...'));
+      const chatProbe = await testModelChat(activeCli);
+      if (chatProbe.success) {
+        const modelHint = chatProbe.model
+          ? `${chatProbe.provider || 'provider'}/${chatProbe.model}`
+          : (chatProbe.provider || 'provider');
+        log.success(`模型连通性通过 (${modelHint})`);
       } else {
-        issues.push(issue);
+        issues.push(
+          summarizeIssue(
+            'warning',
+            '模型连通性测试失败',
+            chatProbe.error || '模型未返回可用结果',
+            '运行 npx openclawapi@latest 重新配置模型后再执行强力修复',
+            'npx openclawapi@latest',
+          ),
+        );
       }
-    } else {
-      issues.push(issue);
     }
-  }
 
-  // 5. 检查模型配置
-  console.log(colors.cyan('检查模型配置...'));
-  if (config.raw) {
-    const hasModels = config.raw.includes('"models"') || config.raw.includes('"providers"');
-    const hasApiKey = config.raw.includes('"apiKey"') || config.raw.includes('"api_key"');
-    if (!hasModels && !hasApiKey) {
-      const issue = {
-        level: 'warning',
-        title: '未配置 AI 模型',
-        detail: '配置文件中未找到模型或 API Key 配置',
-        solution: '运行 npx openclawapi@latest 配置模型',
-        fixCmd: 'npx openclawapi@latest',
-      };
-      if (autoFix) {
-        console.log(colors.yellow('  启动模型配置...'));
-        spawnSync('npx', ['openclawapi@latest'], { stdio: 'inherit', shell: true });
-        fixed.push('已启动模型配置向导');
-      } else {
-        issues.push(issue);
+    // 7. 运行官方诊断
+    console.log(colors.cyan('运行官方诊断...'));
+    const doctorCheck = await runOfficialDoctor(activeCli, autoFix, strongMode);
+    if (doctorCheck.ok) {
+      log.success('官方诊断通过');
+      if (doctorCheck.fixed) {
+        fixed.push('官方诊断问题已自动修复');
       }
-    } else {
-      log.success('已配置模型');
-    }
-  }
-
-  // 6. 运行官方诊断
-  console.log(colors.cyan('运行官方诊断...'));
-  const doctorResult = safeExec(`${cliName} doctor`);
-  if (doctorResult.ok) {
-    const output = doctorResult.output.toLowerCase();
-    if (output.includes('error') || output.includes('fail') || output.includes('问题')) {
-      const issue = {
-        level: 'warning',
-        title: '官方诊断发现问题',
-        detail: doctorResult.output.slice(0, 200),
-        solution: `运行 ${cliName} doctor --fix 尝试自动修复`,
-        fixCmd: `${cliName} doctor --fix`,
-      };
-      if (autoFix) {
-        console.log(colors.yellow('  运行官方自动修复...'));
-        const fixResult = safeExec(`${cliName} doctor --fix`);
-        if (fixResult.ok) {
-          fixed.push('官方诊断问题已尝试修复');
-        } else {
-          issues.push(issue);
+    } else if (doctorCheck.issue) {
+      issues.push(doctorCheck.issue);
+    }
+
+    // 8. 强力模式深度回收
+    if (strongMode && autoFix && issues.length > 0 && pass < totalPasses) {
+      console.log(colors.cyan('执行强力回收修复...'));
+      const deepActions = [];
+
+      const doctorFix = safeExec(`${activeCli} doctor --fix`, { timeout: 180000 });
+      if (doctorFix.ok) deepActions.push('doctor --fix');
+
+      const onboardRecovery = runOnboardFlags(activeCli, { withModel: false, withChannel: false });
+      if (onboardRecovery.ran) {
+        if (onboardRecovery.ok) {
+          deepActions.push('onboard 非交互重建');
+        }
+      } else if (process.stdin.isTTY && process.stdout.isTTY) {
+        const autoOnboard = await runOnboardAuto(activeCli, { withModel: false, withChannel: false });
+        if (autoOnboard.ok && autoOnboard.exitCode === 0) {
+          deepActions.push('onboard 自动应答重建');
         }
-      } else {
-        issues.push(issue);
       }
-    } else {
-      log.success('官方诊断通过');
+
+      const restartRecovery = await ensureGatewayRunning(activeCli, 'restart');
+      if (restartRecovery.ok) {
+        deepActions.push(`gateway ${restartRecovery.action}`);
+      }
+
+      if (deepActions.length) {
+        deepActions.forEach((action) => fixed.push(`[强力] 已执行 ${action}`));
+      }
+
+      await sleep(2500);
+    }
+
+    finalIssues = issues;
+
+    const fixedThisPass = fixed.length - fixedBeforePass;
+    const noIssueNow = finalIssues.length === 0;
+    const shouldContinueStrongPass = strongMode && autoFix && pass < totalPasses;
+
+    if (noIssueNow) {
+      if (!shouldContinueStrongPass || fixedThisPass === 0) {
+        break;
+      }
+      continue;
+    }
+
+    if (!shouldContinueStrongPass) {
+      break;
     }
   }
 
@@ -1173,19 +2242,23 @@ async function runHealthCheck(cliName, autoFix = false) {
 
   if (fixed.length > 0) {
     console.log(colors.bold(colors.green(`🔧 已自动修复 ${fixed.length} 个问题：`)));
-    fixed.forEach((f, i) => console.log(colors.green(`   ${i + 1}. ${f}`)));
+    fixed.forEach((item, index) => console.log(colors.green(`   ${index + 1}. ${item}`)));
     console.log('');
   }
 
-  if (issues.length === 0) {
-    console.log(colors.bold(colors.green('✅ 所有检查通过，OpenClaw 运行正常！')));
+  if (finalIssues.length === 0) {
+    if (strongMode) {
+      console.log(colors.bold(colors.green('✅ 强力模式检查通过，系统状态已稳定！')));
+    } else {
+      console.log(colors.bold(colors.green('✅ 所有检查通过，OpenClaw 运行正常！')));
+    }
   } else {
-    console.log(colors.bold(colors.yellow(`⚠ 发现 ${issues.length} 个问题：`)));
+    console.log(colors.bold(colors.yellow(`⚠ 发现 ${finalIssues.length} 个问题：`)));
     console.log('='.repeat(50));
 
-    issues.forEach((issue, i) => {
+    finalIssues.forEach((issue, index) => {
       const icon = issue.level === 'error' ? colors.red('❌') : colors.yellow('⚠');
-      console.log(`\n${icon} ${colors.bold(`问题 ${i + 1}: ${issue.title}`)}`);
+      console.log(`\n${icon} ${colors.bold(`问题 ${index + 1}: ${issue.title}`)}`);
       console.log(colors.gray(`   ${issue.detail}`));
       console.log(colors.cyan(`   解决方案: ${issue.solution}`));
       if (issue.fixCmd) {
@@ -1193,13 +2266,24 @@ async function runHealthCheck(cliName, autoFix = false) {
       }
     });
 
-    if (!autoFix && issues.some(i => i.fixCmd)) {
+    if (!autoFix && finalIssues.some((item) => item.fixCmd)) {
       console.log(colors.cyan('\n💡 提示: 运行 npx openclawsetup --fix 尝试自动修复'));
     }
+    if (!strongMode) {
+      console.log(colors.cyan('💡 深度修复: 运行 npx openclawsetup --strong-fix'));
+    }
+
+    if (strongMode && autoFix) {
+      const logs = collectGatewayLogs(activeCli, 80);
+      if (logs.ok && logs.output) {
+        console.log(colors.gray('\n最近 Gateway 日志（截断）：'));
+        console.log(colors.gray(logs.output));
+      }
+    }
   }
   console.log('');
 
-  return { issues, fixed };
+  return { issues: finalIssues, fixed, cliName: activeCli };
 }
 
 // ============ 交互式菜单 ============
@@ -1249,7 +2333,7 @@ function testModelChat(cliName) {
 async function showStatusInfo(cliName) {
   const config = getConfigInfo();
   const port = config.port || 18789;
-  const token = config.token || '<未配置>';
+  const token = getDashboardToken(config) || '<未配置>';
   const dashboardUrl = `http://127.0.0.1:${port}/?token=${token}`;
 
   console.log(colors.bold(colors.cyan('\n📊 OpenClaw 状态信息\n')));
@@ -1383,16 +2467,19 @@ async function showInteractiveMenu(existing) {
 
     console.log(colors.cyan('\n请选择操作：'));
     console.log(`  ${colors.yellow('1')}. 状态信息`);
-    console.log(`  ${colors.yellow('2')}. 检查修复`);
-    console.log(`  ${colors.yellow('3')}. 检查更新`);
-    console.log(`  ${colors.yellow('4')}. 配置模型`);
-    console.log(`  ${colors.yellow('5')}. 配置 Chat`);
-    console.log(`  ${colors.yellow('6')}. 配置技能`);
-    console.log(`  ${colors.yellow('7')}. 重新安装`);
-    console.log(`  ${colors.yellow('8')}. 完全卸载`);
+    console.log(`  ${colors.yellow('2')}. 检查修复（标准）`);
+    console.log(`  ${colors.yellow('3')}. 强力检查修复（多轮深度）`);
+    console.log(`  ${colors.yellow('4')}. Token 优化（降低输入 token）`);
+    console.log(`  ${colors.yellow('5')}. 导出排障证据包（发给技术支持）`);
+    console.log(`  ${colors.yellow('6')}. 检查更新`);
+    console.log(`  ${colors.yellow('7')}. 配置模型`);
+    console.log(`  ${colors.yellow('8')}. 配置 Chat`);
+    console.log(`  ${colors.yellow('9')}. 配置技能`);
+    console.log(`  ${colors.yellow('10')}. 重新安装`);
+    console.log(`  ${colors.yellow('11')}. 完全卸载`);
     console.log(`  ${colors.yellow('0')}. 退出`);
 
-    const choice = await askQuestion('\n请输入选项 (0-8): ');
+    const choice = await askQuestion('\n请输入选项 (0-11): ');
 
     switch (choice.trim()) {
       case '1':
@@ -1400,14 +2487,26 @@ async function showInteractiveMenu(existing) {
         await waitForEnter('\n按回车返回菜单...');
         break;
       case '2':
-        await runHealthCheck(cliName, true);
+        await runHealthCheck(cliName, true, false);
         await waitForEnter('\n按回车返回菜单...');
         break;
       case '3':
-        await updateOpenClaw(cliName);
+        await runHealthCheck(cliName, true, true);
         await waitForEnter('\n按回车返回菜单...');
         break;
       case '4':
+        await optimizeTokenUsage(cliName);
+        await waitForEnter('\n按回车返回菜单...');
+        break;
+      case '5':
+        await collectEvidencePackage({ quick: false });
+        await waitForEnter('\n按回车返回菜单...');
+        break;
+      case '6':
+        await updateOpenClaw(cliName);
+        await waitForEnter('\n按回车返回菜单...');
+        break;
+      case '7':
         console.log(colors.cyan('\n启动模型配置...'));
         spawnSync('npx', ['openclawapi@latest'], {
           stdio: 'inherit',
@@ -1415,7 +2514,7 @@ async function showInteractiveMenu(existing) {
         });
         await waitForEnter('\n按回车返回菜单...');
         break;
-      case '5':
+      case '8':
         console.log(colors.cyan('\n选择聊天渠道：'));
         console.log(`  ${colors.yellow('a')}. Discord`);
         console.log(`  ${colors.yellow('b')}. 飞书`);
@@ -1435,13 +2534,13 @@ async function showInteractiveMenu(existing) {
         }
         await waitForEnter('\n按回车返回菜单...');
         break;
-      case '6':
+      case '9':
         console.log(colors.cyan('\n配置技能（即将支持）...'));
         // TODO: 等待技能地址提供后实现
         log.warn('技能配置功能即将上线，请稍后再试');
         await waitForEnter('\n按回车返回菜单...');
         break;
-      case '7':
+      case '10':
         console.log(colors.yellow('\n即将重新安装 OpenClaw...'));
         const confirmReinstall = await askQuestion('确认重新安装？(y/N): ');
         if (confirmReinstall.toLowerCase() === 'y') {
@@ -1451,7 +2550,7 @@ async function showInteractiveMenu(existing) {
           showCompletionInfo(newCliName);
         }
         break;
-      case '8':
+      case '11':
         console.log(colors.red('\n⚠ 警告：卸载将删除所有配置！'));
         const confirmUninstall = await askQuestion('确认卸载？(y/N): ');
         if (confirmUninstall.toLowerCase() === 'y') {
@@ -1465,7 +2564,7 @@ async function showInteractiveMenu(existing) {
         console.log(colors.gray('\n再见！'));
         process.exit(0);
       default:
-        log.warn('无效选项，请输入 0-8');
+        log.warn('无效选项，请输入 0-11');
     }
   }
 }
@@ -1492,7 +2591,7 @@ async function main() {
     const latestResult = safeExec('npm view openclawsetup version 2>/dev/null');
     if (latestResult.ok && latestResult.output) {
       const latestVersion = latestResult.output.trim();
-      if (latestVersion && latestVersion !== currentVersion) {
+      if (latestVersion && compareSemver(currentVersion, latestVersion) < 0) {
         console.log(colors.yellow(`\n⚠ 当前版本 ${currentVersion}，最新版本 ${latestVersion}`));
         console.log(colors.yellow('  正在更新到最新版本...\n'));
         const updateCmd = platform() === 'win32'
@@ -1525,12 +2624,27 @@ async function main() {
     console.log(colors.green(`\n✓ 检测到已安装: ${existing.name}`));
 
     if (options.check) {
-      await runHealthCheck(existing.name, false);
+      await runHealthCheck(existing.name, false, options.strong);
+      process.exit(0);
+    }
+
+    if (options.optimizeToken) {
+      await optimizeTokenUsage(existing.name);
+      process.exit(0);
+    }
+
+    if (options.collectEvidence || options.evidenceQuick) {
+      await collectEvidencePackage({ quick: options.evidenceQuick });
       process.exit(0);
     }
 
     if (options.fix) {
-      await runHealthCheck(existing.name, true);
+      await runHealthCheck(existing.name, true, options.strong);
+      process.exit(0);
+    }
+
+    if (options.strongFix) {
+      await runHealthCheck(existing.name, true, true);
       process.exit(0);
     }
 
@@ -1552,6 +2666,16 @@ async function main() {
     }
   }
 
+  if (options.collectEvidence || options.evidenceQuick) {
+    await collectEvidencePackage({ quick: options.evidenceQuick });
+    process.exit(0);
+  }
+
+  if (options.optimizeToken) {
+    await optimizeTokenUsage('openclaw');
+    process.exit(0);
+  }
+
   // 安装 CLI
   const cliName = await installOpenClaw();