@lark-project/openclaw-lark-project 2026.3.131

package/dist/src/commands/diagnose.js

@@ -0,0 +1,658 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import { probeFeishu } from "../channel/probe";
+import { getLarkAccountIds, getLarkAccount, getEnabledLarkAccounts } from "../core/accounts";
+import { LarkClient } from "../core/lark-client";
+function resolveGlobalConfig(config) {
+  return LarkClient.globalConfig ?? config;
+}
+import { assertLarkOk, formatLarkError } from "../core/api-error";
+import { resolveAnyEnabledToolsConfig } from "../core/tools-config";
+const PLUGIN_VERSION = "2026.2.10";
+const LOG_READ_BYTES = 256 * 1024;
+const MAX_ERROR_LINES = 20;
+const TIMESTAMPED_LINE_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
+const ERROR_LEVEL_RE = /\[error\]|\[warn\]/i;
+function maskSecret(secret) {
+  if (!secret) return "(\u672A\u8BBE\u7F6E)";
+  if (secret.length <= 4) return "****";
+  return secret.slice(0, 4) + "****";
+}
+async function extractRecentErrors(logPath) {
+  try {
+    await fs.access(logPath);
+  } catch {
+    return [];
+  }
+  try {
+    const stat = await fs.stat(logPath);
+    const readSize = Math.min(stat.size, LOG_READ_BYTES);
+    const fd = await fs.open(logPath, "r");
+    try {
+      const buffer = Buffer.alloc(readSize);
+      await fd.read(buffer, 0, readSize, Math.max(0, stat.size - readSize));
+      const content = buffer.toString("utf-8");
+      const lines = content.split("\n").filter(Boolean);
+      const errorLines = lines.filter((line) => TIMESTAMPED_LINE_RE.test(line) && ERROR_LEVEL_RE.test(line));
+      return errorLines.slice(-MAX_ERROR_LINES);
+    } finally {
+      await fd.close();
+    }
+  } catch {
+    return [];
+  }
+}
+async function checkAppScopes(client) {
+  const res = await client.application.scope.list({});
+  assertLarkOk(res);
+  const scopes = res.data?.scopes ?? [];
+  const granted = scopes.filter((s) => s.grant_status === 1);
+  const pending = scopes.filter((s) => s.grant_status !== 1);
+  return {
+    granted: granted.length,
+    pending: pending.length,
+    summary: `${granted.length} \u5DF2\u6388\u6743, ${pending.length} \u5F85\u6388\u6743`
+  };
+}
+function detectRegisteredTools(config) {
+  const accounts = getEnabledLarkAccounts(config);
+  if (accounts.length === 0) return [];
+  const toolsCfg = resolveAnyEnabledToolsConfig(accounts);
+  const tools = [];
+  if (toolsCfg.doc) tools.push("feishu_doc");
+  if (toolsCfg.scopes) tools.push("feishu_app_scopes");
+  if (toolsCfg.wiki) tools.push("feishu_wiki");
+  if (toolsCfg.drive) tools.push("feishu_drive");
+  if (toolsCfg.perm) tools.push("feishu_perm");
+  tools.push(
+    "feishu_bitable_get_meta",
+    "feishu_bitable_list_fields",
+    "feishu_bitable_list_records",
+    "feishu_bitable_get_record",
+    "feishu_bitable_create_record",
+    "feishu_bitable_update_record"
+  );
+  tools.push("feishu_task");
+  tools.push("feishu_calendar");
+  return tools;
+}
+async function diagnoseAccount(account) {
+  const checks = [];
+  const result = {
+    accountId: account.accountId,
+    name: account.name,
+    enabled: account.enabled,
+    configured: account.configured,
+    appId: account.appId ?? "(\u672A\u8BBE\u7F6E)",
+    brand: account.brand,
+    checks
+  };
+  checks.push({
+    name: "\u51ED\u8BC1\u5B8C\u6574\u6027",
+    status: account.configured ? "pass" : "fail",
+    message: account.configured ? `appId: ${account.appId}, appSecret: ${maskSecret(account.appSecret)}` : "\u7F3A\u5C11 appId \u6216 appSecret"
+  });
+  checks.push({
+    name: "\u8D26\u6237\u542F\u7528",
+    status: account.enabled ? "pass" : "warn",
+    message: account.enabled ? "\u5DF2\u542F\u7528" : "\u5DF2\u7981\u7528"
+  });
+  if (!account.configured || !account.appId || !account.appSecret) {
+    checks.push({
+      name: "API \u8FDE\u901A\u6027",
+      status: "skip",
+      message: "\u51ED\u8BC1\u672A\u914D\u7F6E\uFF0C\u8DF3\u8FC7"
+    });
+    return result;
+  }
+  try {
+    const probeResult = await probeFeishu({
+      accountId: account.accountId,
+      appId: account.appId,
+      appSecret: account.appSecret,
+      brand: account.brand
+    });
+    checks.push({
+      name: "API \u8FDE\u901A\u6027",
+      status: probeResult.ok ? "pass" : "fail",
+      message: probeResult.ok ? `\u8FDE\u63A5\u6210\u529F` : `\u8FDE\u63A5\u5931\u8D25: ${probeResult.error}`
+    });
+    if (probeResult.ok) {
+      checks.push({
+        name: "Bot \u4FE1\u606F",
+        status: probeResult.botName ? "pass" : "warn",
+        message: probeResult.botName ? `${probeResult.botName} (${probeResult.botOpenId})` : "\u672A\u83B7\u53D6\u5230 Bot \u540D\u79F0"
+      });
+    }
+  } catch (err) {
+    checks.push({
+      name: "API \u8FDE\u901A\u6027",
+      status: "fail",
+      message: `\u63A2\u6D4B\u5F02\u5E38: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+  try {
+    const client = LarkClient.fromAccount(account).sdk;
+    const scopesResult = await checkAppScopes(client);
+    checks.push({
+      name: "\u5E94\u7528\u6743\u9650",
+      status: scopesResult.pending > 0 ? "warn" : "pass",
+      message: scopesResult.summary,
+      details: scopesResult.pending > 0 ? "\u5B58\u5728\u672A\u6388\u6743\u7684\u6743\u9650\uFF0C\u53EF\u80FD\u5F71\u54CD\u90E8\u5206\u529F\u80FD" : void 0
+    });
+  } catch (err) {
+    checks.push({
+      name: "\u5E94\u7528\u6743\u9650",
+      status: "warn",
+      message: `\u6743\u9650\u68C0\u67E5\u5931\u8D25: ${formatLarkError(err)}`
+    });
+  }
+  checks.push({
+    name: "\u54C1\u724C\u914D\u7F6E",
+    status: "pass",
+    message: `brand: ${account.brand}`
+  });
+  return result;
+}
+async function runDiagnosis(params) {
+  const { config } = params;
+  const globalCfg = resolveGlobalConfig(config);
+  const globalChecks = [];
+  const nodeVer = parseInt(process.version.slice(1), 10);
+  globalChecks.push({
+    name: "Node.js \u7248\u672C",
+    status: nodeVer >= 18 ? "pass" : "warn",
+    message: process.version,
+    details: nodeVer < 18 ? "\u5EFA\u8BAE\u5347\u7EA7\u5230 Node.js 18+" : void 0
+  });
+  const accountIds = getLarkAccountIds(globalCfg);
+  globalChecks.push({
+    name: "\u98DE\u4E66\u8D26\u6237\u6570\u91CF",
+    status: accountIds.length > 0 ? "pass" : "fail",
+    message: `${accountIds.length} \u4E2A\u8D26\u6237`
+  });
+  const logPath = path.join(os.homedir(), ".openclaw", "logs", "gateway.log");
+  let logExists = false;
+  try {
+    await fs.access(logPath);
+    logExists = true;
+  } catch {
+  }
+  globalChecks.push({
+    name: "\u65E5\u5FD7\u6587\u4EF6",
+    status: logExists ? "pass" : "warn",
+    message: logExists ? logPath : `\u672A\u627E\u5230: ${logPath}`
+  });
+  const accountResults = [];
+  for (const id of accountIds) {
+    const account = getLarkAccount(globalCfg, id);
+    const result = await diagnoseAccount(account);
+    accountResults.push(result);
+  }
+  const tools = detectRegisteredTools(globalCfg);
+  const recentErrors = await extractRecentErrors(logPath);
+  globalChecks.push({
+    name: "\u6700\u8FD1\u9519\u8BEF\u65E5\u5FD7",
+    status: recentErrors.length > 0 ? "warn" : "pass",
+    message: recentErrors.length > 0 ? `\u53D1\u73B0 ${recentErrors.length} \u6761\u9519\u8BEF` : "\u65E0\u6700\u8FD1\u9519\u8BEF"
+  });
+  const allChecks = [...globalChecks, ...accountResults.flatMap((a) => a.checks)];
+  const hasFail = allChecks.some((c) => c.status === "fail");
+  const hasWarn = allChecks.some((c) => c.status === "warn");
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    environment: {
+      nodeVersion: process.version,
+      platform: process.platform,
+      arch: process.arch,
+      pluginVersion: PLUGIN_VERSION
+    },
+    accounts: accountResults,
+    toolsRegistered: tools,
+    recentErrors,
+    overallStatus: hasFail ? "unhealthy" : hasWarn ? "degraded" : "healthy",
+    checks: globalChecks
+  };
+}
+const STATUS_LABEL = {
+  pass: "[PASS]",
+  warn: "[WARN]",
+  fail: "[FAIL]",
+  skip: "[SKIP]"
+};
+function formatCheck(c) {
+  let line = `  ${STATUS_LABEL[c.status]} ${c.name}: ${c.message}`;
+  if (c.details) {
+    line += `
+         ${c.details}`;
+  }
+  return line;
+}
+function formatDiagReportText(report) {
+  const lines = [];
+  const sep = "====================================";
+  lines.push(sep);
+  lines.push("  \u98DE\u4E66\u63D2\u4EF6\u8BCA\u65AD\u62A5\u544A");
+  lines.push(`  ${report.timestamp}`);
+  lines.push(sep);
+  lines.push("");
+  lines.push("\u3010\u73AF\u5883\u4FE1\u606F\u3011");
+  lines.push(`  Node.js:     ${report.environment.nodeVersion}`);
+  lines.push(`  \u63D2\u4EF6\u7248\u672C:    ${report.environment.pluginVersion}`);
+  lines.push(`  \u7CFB\u7EDF:        ${report.environment.platform} ${report.environment.arch}`);
+  lines.push("");
+  lines.push("\u3010\u5168\u5C40\u68C0\u67E5\u3011");
+  for (const c of report.checks) {
+    lines.push(formatCheck(c));
+  }
+  lines.push("");
+  for (const acct of report.accounts) {
+    lines.push(`\u3010\u8D26\u6237: ${acct.accountId}\u3011`);
+    if (acct.name) lines.push(`  \u540D\u79F0:     ${acct.name}`);
+    lines.push(`  App ID:   ${acct.appId}`);
+    lines.push(`  \u54C1\u724C:     ${acct.brand}`);
+    lines.push("");
+    for (const c of acct.checks) {
+      lines.push(formatCheck(c));
+    }
+    lines.push("");
+  }
+  lines.push("\u3010\u5DE5\u5177\u6CE8\u518C\u3011");
+  if (report.toolsRegistered.length > 0) {
+    lines.push(`  ${report.toolsRegistered.join(", ")}`);
+    lines.push(`  \u5171 ${report.toolsRegistered.length} \u4E2A`);
+  } else {
+    lines.push("  \u65E0\u5DE5\u5177\u6CE8\u518C\uFF08\u672A\u627E\u5230\u5DF2\u914D\u7F6E\u7684\u8D26\u6237\uFF09");
+  }
+  lines.push("");
+  if (report.recentErrors.length > 0) {
+    lines.push(`\u3010\u6700\u8FD1\u9519\u8BEF\u3011(${report.recentErrors.length} \u6761)`);
+    for (let i = 0; i < report.recentErrors.length; i++) {
+      lines.push(`  ${i + 1}. ${report.recentErrors[i]}`);
+    }
+    lines.push("");
+  }
+  const statusMap = {
+    healthy: "HEALTHY",
+    degraded: "DEGRADED (\u5B58\u5728\u8B66\u544A)",
+    unhealthy: "UNHEALTHY (\u5B58\u5728\u5931\u8D25\u9879)"
+  };
+  lines.push(sep);
+  lines.push(`  \u603B\u4F53\u72B6\u6001: ${statusMap[report.overallStatus]}`);
+  lines.push(sep);
+  return lines.join("\n");
+}
+const ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  gray: "\x1B[90m"
+};
+const STATUS_LABEL_CLI = {
+  pass: `${ANSI.green}[PASS]${ANSI.reset}`,
+  warn: `${ANSI.yellow}[WARN]${ANSI.reset}`,
+  fail: `${ANSI.red}[FAIL]${ANSI.reset}`,
+  skip: `${ANSI.gray}[SKIP]${ANSI.reset}`
+};
+function formatCheckCli(c) {
+  let line = `  ${STATUS_LABEL_CLI[c.status]} ${c.name}: ${c.message}`;
+  if (c.details) {
+    line += `
+         ${ANSI.gray}${c.details}${ANSI.reset}`;
+  }
+  return line;
+}
+async function traceByMessageId(messageId) {
+  const logPath = path.join(os.homedir(), ".openclaw", "logs", "gateway.log");
+  try {
+    await fs.access(logPath);
+  } catch {
+    return [];
+  }
+  const TRACE_READ_BYTES = 1024 * 1024;
+  try {
+    const stat = await fs.stat(logPath);
+    const readSize = Math.min(stat.size, TRACE_READ_BYTES);
+    const fd = await fs.open(logPath, "r");
+    try {
+      const buffer = Buffer.alloc(readSize);
+      await fd.read(buffer, 0, readSize, Math.max(0, stat.size - readSize));
+      const content = buffer.toString("utf-8");
+      const needle = `[msg:${messageId}]`;
+      return content.split("\n").filter((line) => line.includes(needle));
+    } finally {
+      await fd.close();
+    }
+  } catch {
+    return [];
+  }
+}
+function formatTraceOutput(lines, messageId) {
+  const sep = "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500";
+  if (lines.length === 0) {
+    return [
+      sep,
+      `  \u672A\u627E\u5230 ${messageId} \u7684\u8FFD\u8E2A\u65E5\u5FD7`,
+      "",
+      "  \u53EF\u80FD\u539F\u56E0:",
+      "  1. \u8BE5\u6D88\u606F\u5C1A\u672A\u88AB\u5904\u7406",
+      "  2. \u65E5\u5FD7\u5DF2\u88AB\u8F6E\u8F6C",
+      "  3. \u8FFD\u8E2A\u529F\u80FD\u672A\u542F\u7528\uFF08\u9700\u8981\u66F4\u65B0\u63D2\u4EF6\u7248\u672C\uFF09",
+      sep
+    ].join("\n");
+  }
+  const header = `\u8FFD\u8E2A ${messageId} \u7684\u5904\u7406\u94FE\u8DEF (${lines.length} \u6761\u65E5\u5FD7):`;
+  const output = [header, sep];
+  for (const line of lines) {
+    output.push(line);
+  }
+  output.push(sep);
+  return output.join("\n");
+}
+function classifyEvent(body) {
+  if (body.startsWith("received from")) return "received";
+  if (body.startsWith("sender resolved")) return "sender_resolved";
+  if (body.startsWith("rejected:")) return "rejected";
+  if (body.startsWith("dispatching to agent")) return "dispatching";
+  if (body.startsWith("dispatch complete")) return "dispatch_complete";
+  if (body.startsWith("card entity created")) return "card_created";
+  if (body.startsWith("card message sent")) return "card_sent";
+  if (body.startsWith("cardkit cardElement.content:")) return "card_stream";
+  if (body.startsWith("card stream update failed")) return "card_stream_fail";
+  if (body.startsWith("cardkit card.settings:")) return "card_settings";
+  if (body.startsWith("cardkit card.update:")) return "card_update";
+  if (body.startsWith("card creation failed")) return "card_fallback";
+  if (body.startsWith("reply completed")) return "reply_completed";
+  if (body.startsWith("reply error")) return "reply_error";
+  if (body.startsWith("tool call:")) return "tool_call";
+  if (body.startsWith("tool done:")) return "tool_done";
+  if (body.startsWith("tool fail:")) return "tool_fail";
+  return "other";
+}
+const EVENT_LABEL = {
+  received: "\u6D88\u606F\u63A5\u6536",
+  sender_resolved: "Sender \u89E3\u6790",
+  rejected: "\u6D88\u606F\u62D2\u7EDD",
+  dispatching: "\u5206\u53D1\u5230 Agent",
+  dispatch_complete: "Agent \u5904\u7406\u5B8C\u6210",
+  card_created: "\u5361\u7247\u521B\u5EFA",
+  card_sent: "\u5361\u7247\u6D88\u606F\u53D1\u9001",
+  card_stream: "\u6D41\u5F0F\u66F4\u65B0",
+  card_stream_fail: "\u6D41\u5F0F\u66F4\u65B0\u5931\u8D25",
+  card_settings: "\u5361\u7247\u8BBE\u7F6E",
+  card_update: "\u5361\u7247\u6700\u7EC8\u66F4\u65B0",
+  card_fallback: "\u5361\u7247\u964D\u7EA7",
+  reply_completed: "\u56DE\u590D\u5B8C\u6210",
+  reply_error: "\u56DE\u590D\u9519\u8BEF",
+  tool_call: "\u5DE5\u5177\u8C03\u7528",
+  tool_done: "\u5DE5\u5177\u5B8C\u6210",
+  tool_fail: "\u5DE5\u5177\u5931\u8D25"
+};
+const EXPECTED_STAGES = [
+  { kind: "received", label: "\u6D88\u606F\u63A5\u6536 (received from)" },
+  { kind: "dispatching", label: "\u5206\u53D1\u5230 Agent (dispatching to agent)" },
+  { kind: "card_created", label: "\u5361\u7247\u521B\u5EFA (card entity created)" },
+  { kind: "card_sent", label: "\u5361\u7247\u6D88\u606F\u53D1\u9001 (card message sent)" },
+  { kind: "card_stream", label: "\u6D41\u5F0F\u8F93\u51FA (cardElement.content)" },
+  { kind: "dispatch_complete", label: "\u5904\u7406\u5B8C\u6210 (dispatch complete)" },
+  { kind: "reply_completed", label: "\u56DE\u590D\u6536\u5C3E (reply completed)" }
+];
+const PERF_THRESHOLDS = [
+  { from: "received", to: "dispatching", warnMs: 500, label: "\u6D88\u606F\u63A5\u6536 \u2192 \u5206\u53D1" },
+  { from: "dispatching", to: "card_created", warnMs: 5e3, label: "\u5206\u53D1 \u2192 \u5361\u7247\u521B\u5EFA" },
+  { from: "card_created", to: "card_stream", warnMs: 3e4, label: "\u5361\u7247\u521B\u5EFA \u2192 \u9996\u6B21\u6D41\u5F0F\u8F93\u51FA" }
+];
+function parseTraceLines(lines) {
+  const events = [];
+  const re = /^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z)\s.*?\]:\s(.+)$/;
+  for (const line of lines) {
+    const m = line.match(re);
+    if (m) {
+      events.push({ timestamp: new Date(m[1]), raw: line, body: m[2] });
+    }
+  }
+  return events;
+}
+function analyzeTrace(lines, _messageId) {
+  const events = parseTraceLines(lines);
+  if (events.length === 0) {
+    return `\u65E0\u6CD5\u89E3\u6790\u65E5\u5FD7\u884C\uFF0C\u8BF7\u786E\u8BA4\u65E5\u5FD7\u683C\u5F0F\u6B63\u786E\u3002`;
+  }
+  const out = [];
+  const sep = "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500";
+  const startTime = events[0].timestamp.getTime();
+  const totalMs = events[events.length - 1].timestamp.getTime() - startTime;
+  out.push("");
+  out.push(`${ANSI.bold}\u3010\u65F6\u95F4\u7EBF\u3011${ANSI.reset} (${events.length} \u6761\u65E5\u5FD7\uFF0C\u8DE8\u5EA6 ${(totalMs / 1e3).toFixed(1)}s)`);
+  out.push(sep);
+  let prevMs = startTime;
+  let streamCount = 0;
+  let streamFirstSeq = "";
+  let streamLastSeq = "";
+  function flushStream() {
+    if (streamCount > 0) {
+      const label = streamCount === 1 ? `  ${ANSI.gray}...${ANSI.reset} \u6D41\u5F0F\u66F4\u65B0 seq=${streamFirstSeq}` : `  ${ANSI.gray}...${ANSI.reset} \u6D41\u5F0F\u66F4\u65B0 x${streamCount} (seq=${streamFirstSeq}~${streamLastSeq})`;
+      out.push(label);
+      streamCount = 0;
+    }
+  }
+  for (const ev of events) {
+    const kind = classifyEvent(ev.body);
+    const deltaMs = ev.timestamp.getTime() - prevMs;
+    prevMs = ev.timestamp.getTime();
+    const offsetMs = ev.timestamp.getTime() - startTime;
+    const offsetStr = `+${offsetMs}ms`.padStart(10);
+    if (kind === "card_stream") {
+      const seqMatch = ev.body.match(/seq=(\d+)/);
+      const seq = seqMatch ? seqMatch[1] : "?";
+      if (streamCount === 0) streamFirstSeq = seq;
+      streamLastSeq = seq;
+      streamCount++;
+      continue;
+    }
+    flushStream();
+    const label = EVENT_LABEL[kind] ?? kind;
+    const gapWarn = deltaMs > 5e3 ? ` ${ANSI.yellow}\u26A0 ${(deltaMs / 1e3).toFixed(1)}s${ANSI.reset}` : "";
+    let marker = "  ";
+    if (kind === "rejected" || kind === "reply_error" || kind === "tool_fail" || kind === "card_stream_fail" || kind === "card_fallback") {
+      marker = `${ANSI.red}\u2718 ${ANSI.reset}`;
+    } else if (kind === "tool_call") {
+      marker = "\u2192 ";
+    }
+    let detail = "";
+    if (kind === "received") {
+      const m = ev.body.match(/from (\S+) in (\S+) \((\w+)\)/);
+      if (m) detail = `sender=${m[1]}, chat=${m[2]} (${m[3]})`;
+    } else if (kind === "dispatching") {
+      const m = ev.body.match(/session=(\S+)\)/);
+      if (m) detail = `session=${m[1]}`;
+    } else if (kind === "dispatch_complete") {
+      const m = ev.body.match(/replies=(\d+), elapsed=(\d+)ms/);
+      if (m) detail = `replies=${m[1]}, elapsed=${m[2]}ms`;
+    } else if (kind === "tool_call") {
+      const m = ev.body.match(/tool call: (\S+)/);
+      if (m) detail = m[1];
+    } else if (kind === "tool_fail") {
+      detail = ev.body.replace("tool fail: ", "");
+    } else if (kind === "card_created") {
+      const m = ev.body.match(/card_id=(\S+)\)/);
+      if (m) detail = `card_id=${m[1]}`;
+    } else if (kind === "reply_completed") {
+      const m = ev.body.match(/elapsed=(\d+)ms/);
+      if (m) detail = `elapsed=${m[1]}ms`;
+    } else if (kind === "rejected") {
+      detail = ev.body.replace("rejected: ", "");
+    }
+    out.push(`${ANSI.gray}[${offsetStr}]${ANSI.reset} ${marker}${label}${detail ? ` \u2014 ${detail}` : ""}${gapWarn}`);
+  }
+  flushStream();
+  out.push("");
+  const issues = [];
+  const kindSet = new Set(events.map((e) => classifyEvent(e.body)));
+  for (const stage of EXPECTED_STAGES) {
+    if (!kindSet.has(stage.kind)) {
+      if ((stage.kind === "dispatch_complete" || stage.kind === "reply_completed") && !kindSet.has("dispatching"))
+        continue;
+      if ((stage.kind === "card_created" || stage.kind === "card_sent" || stage.kind === "card_stream") && kindSet.has("rejected"))
+        continue;
+      issues.push(`\u7F3A\u5931\u9636\u6BB5: ${stage.label}`);
+    }
+  }
+  for (const ev of events) {
+    const kind = classifyEvent(ev.body);
+    if (kind === "rejected") issues.push(`\u6D88\u606F\u88AB\u62D2\u7EDD: ${ev.body.replace("rejected: ", "")}`);
+    if (kind === "reply_error") issues.push(`\u56DE\u590D\u9519\u8BEF: ${ev.body}`);
+    if (kind === "tool_fail") issues.push(`\u5DE5\u5177\u5931\u8D25: ${ev.body}`);
+    if (kind === "card_stream_fail") issues.push(`\u6D41\u5F0F\u66F4\u65B0\u5931\u8D25: ${ev.body}`);
+    if (kind === "card_fallback") issues.push(`\u5361\u7247\u964D\u7EA7: ${ev.body}`);
+    if (kind === "card_stream" || kind === "card_update" || kind === "card_settings" || kind === "card_created") {
+      const codeMatch = ev.body.match(/code=(\d+)/);
+      if (codeMatch && codeMatch[1] !== "0") {
+        issues.push(`API \u8FD4\u56DE\u9519\u8BEF\u7801: code=${codeMatch[1]} \u2014 ${ev.body}`);
+      }
+    }
+  }
+  const firstByKind = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    const kind = classifyEvent(ev.body);
+    if (!firstByKind.has(kind)) firstByKind.set(kind, ev);
+  }
+  for (const rule of PERF_THRESHOLDS) {
+    const from = firstByKind.get(rule.from);
+    const to = firstByKind.get(rule.to);
+    if (from && to) {
+      const gap = to.timestamp.getTime() - from.timestamp.getTime();
+      if (gap > rule.warnMs) {
+        issues.push(
+          `\u6027\u80FD\u8B66\u544A: ${rule.label} \u8017\u65F6 ${(gap / 1e3).toFixed(1)}s\uFF08\u9608\u503C ${(rule.warnMs / 1e3).toFixed(0)}s\uFF09`
+        );
+      }
+    }
+  }
+  const receivedCount = events.filter((e) => classifyEvent(e.body) === "received").length;
+  if (receivedCount > 1) {
+    issues.push(`\u91CD\u590D\u6295\u9012: \u540C\u4E00\u6D88\u606F\u88AB\u63A5\u6536 ${receivedCount} \u6B21\uFF08WebSocket \u91CD\u6295\u9012\uFF09`);
+  }
+  const streamSeqs = [];
+  for (const ev of events) {
+    if (classifyEvent(ev.body) === "card_stream") {
+      const m = ev.body.match(/seq=(\d+)/);
+      if (m) streamSeqs.push(parseInt(m[1], 10));
+    }
+  }
+  if (streamSeqs.length > 1) {
+    for (let i = 1; i < streamSeqs.length; i++) {
+      if (streamSeqs[i] !== streamSeqs[i - 1] + 1) {
+        issues.push(
+          `\u6D41\u5F0F seq \u4E0D\u8FDE\u7EED: seq=${streamSeqs[i - 1]} \u2192 seq=${streamSeqs[i]}\uFF08\u8DF3\u8FC7\u4E86 ${streamSeqs[i] - streamSeqs[i - 1] - 1} \u4E2A\uFF09`
+        );
+        break;
+      }
+    }
+  }
+  out.push(`${ANSI.bold}\u3010\u5F02\u5E38\u68C0\u6D4B\u3011${ANSI.reset}`);
+  out.push(sep);
+  if (issues.length === 0) {
+    out.push(`  ${ANSI.green}\u672A\u53D1\u73B0\u5F02\u5E38${ANSI.reset}`);
+  } else {
+    for (let i = 0; i < issues.length; i++) {
+      const isError = issues[i].startsWith("\u5DE5\u5177\u5931\u8D25") || issues[i].startsWith("\u56DE\u590D\u9519\u8BEF") || issues[i].startsWith("API \u8FD4\u56DE\u9519\u8BEF\u7801") || issues[i].startsWith("\u6D41\u5F0F\u66F4\u65B0\u5931\u8D25");
+      const color = isError ? ANSI.red : ANSI.yellow;
+      out.push(`  ${color}${i + 1}. ${issues[i]}${ANSI.reset}`);
+    }
+  }
+  out.push("");
+  out.push(`${ANSI.bold}\u3010\u8BCA\u65AD\u603B\u7ED3\u3011${ANSI.reset}`);
+  out.push(sep);
+  const hasError = issues.some(
+    (i) => i.startsWith("\u5DE5\u5177\u5931\u8D25") || i.startsWith("\u56DE\u590D\u9519\u8BEF") || i.startsWith("API \u8FD4\u56DE\u9519\u8BEF\u7801") || i.startsWith("\u6D41\u5F0F\u66F4\u65B0\u5931\u8D25") || i.startsWith("\u7F3A\u5931\u9636\u6BB5")
+  );
+  const hasWarn = issues.length > 0;
+  if (!hasWarn) {
+    out.push(`  \u72B6\u6001: ${ANSI.green}\u2713 \u6B63\u5E38${ANSI.reset}`);
+    out.push(`  \u6D88\u606F\u5904\u7406\u94FE\u8DEF\u5B8C\u6574\uFF0C\u5168\u7A0B\u8017\u65F6 ${(totalMs / 1e3).toFixed(1)}s\u3002`);
+    const dispatchComplete = events.find(
+      (e) => classifyEvent(e.body) === "dispatch_complete" && e.body.includes("replies=") && !e.body.includes("replies=0")
+    );
+    if (dispatchComplete) {
+      const m = dispatchComplete.body.match(/elapsed=(\d+)ms/);
+      if (m) {
+        out.push(`  \u5176\u4E2D Agent \u5904\u7406\u8017\u65F6 ${(parseInt(m[1], 10) / 1e3).toFixed(1)}s\uFF08\u542B AI \u63A8\u7406 + \u5DE5\u5177\u8C03\u7528\uFF09\u3002`);
+      }
+    }
+  } else if (hasError) {
+    out.push(`  \u72B6\u6001: ${ANSI.red}\u2718 \u5F02\u5E38${ANSI.reset}`);
+    out.push(`  \u53D1\u73B0 ${issues.length} \u4E2A\u95EE\u9898\uFF0C\u9700\u8981\u6392\u67E5\u3002`);
+  } else {
+    out.push(`  \u72B6\u6001: ${ANSI.yellow}\u26A0 \u6709\u8B66\u544A${ANSI.reset}`);
+    out.push(`  \u53D1\u73B0 ${issues.length} \u4E2A\u8B66\u544A\uFF0C\u529F\u80FD\u53EF\u7528\u4F46\u9700\u5173\u6CE8\u3002`);
+  }
+  out.push("");
+  return out.join("\n");
+}
+function formatDiagReportCli(report) {
+  const lines = [];
+  const sep = "====================================";
+  lines.push(sep);
+  lines.push(`  ${ANSI.bold}\u98DE\u4E66\u63D2\u4EF6\u8BCA\u65AD\u62A5\u544A${ANSI.reset}`);
+  lines.push(`  ${report.timestamp}`);
+  lines.push(sep);
+  lines.push("");
+  lines.push(`${ANSI.bold}\u3010\u73AF\u5883\u4FE1\u606F\u3011${ANSI.reset}`);
+  lines.push(`  Node.js:     ${report.environment.nodeVersion}`);
+  lines.push(`  \u63D2\u4EF6\u7248\u672C:    ${report.environment.pluginVersion}`);
+  lines.push(`  \u7CFB\u7EDF:        ${report.environment.platform} ${report.environment.arch}`);
+  lines.push("");
+  lines.push(`${ANSI.bold}\u3010\u5168\u5C40\u68C0\u67E5\u3011${ANSI.reset}`);
+  for (const c of report.checks) {
+    lines.push(formatCheckCli(c));
+  }
+  lines.push("");
+  for (const acct of report.accounts) {
+    lines.push(`${ANSI.bold}\u3010\u8D26\u6237: ${acct.accountId}\u3011${ANSI.reset}`);
+    if (acct.name) lines.push(`  \u540D\u79F0:     ${acct.name}`);
+    lines.push(`  App ID:   ${acct.appId}`);
+    lines.push(`  \u54C1\u724C:     ${acct.brand}`);
+    lines.push("");
+    for (const c of acct.checks) {
+      lines.push(formatCheckCli(c));
+    }
+    lines.push("");
+  }
+  lines.push(`${ANSI.bold}\u3010\u5DE5\u5177\u6CE8\u518C\u3011${ANSI.reset}`);
+  if (report.toolsRegistered.length > 0) {
+    lines.push(`  ${report.toolsRegistered.join(", ")}`);
+    lines.push(`  \u5171 ${report.toolsRegistered.length} \u4E2A`);
+  } else {
+    lines.push("  \u65E0\u5DE5\u5177\u6CE8\u518C\uFF08\u672A\u627E\u5230\u5DF2\u914D\u7F6E\u7684\u8D26\u6237\uFF09");
+  }
+  lines.push("");
+  if (report.recentErrors.length > 0) {
+    lines.push(`${ANSI.bold}\u3010\u6700\u8FD1\u9519\u8BEF\u3011${ANSI.reset}(${report.recentErrors.length} \u6761)`);
+    for (let i = 0; i < report.recentErrors.length; i++) {
+      lines.push(`  ${ANSI.gray}${i + 1}. ${report.recentErrors[i]}${ANSI.reset}`);
+    }
+    lines.push("");
+  }
+  const statusColorMap = {
+    healthy: `${ANSI.green}HEALTHY${ANSI.reset}`,
+    degraded: `${ANSI.yellow}DEGRADED (\u5B58\u5728\u8B66\u544A)${ANSI.reset}`,
+    unhealthy: `${ANSI.red}UNHEALTHY (\u5B58\u5728\u5931\u8D25\u9879)${ANSI.reset}`
+  };
+  lines.push(sep);
+  lines.push(`  \u603B\u4F53\u72B6\u6001: ${statusColorMap[report.overallStatus]}`);
+  lines.push(sep);
+  return lines.join("\n");
+}
+export {
+  analyzeTrace,
+  formatDiagReportCli,
+  formatDiagReportText,
+  formatTraceOutput,
+  runDiagnosis,
+  traceByMessageId
+};
+//# sourceMappingURL=diagnose.js.map