backtrace-console 0.0.3 → 0.0.4

package/lib/cli/args.js

@@ -0,0 +1,177 @@
+// 解析 bin/backtrace-cli.js 使用的轻量命令行语法，
+// 把 argv 数组转换成后续流程需要的标准化选项对象。
+function printCliUsage() {
+  console.log([
+    "Usage:",
+    "  backtrace <command> [options]",
+    "",
+    "Commands:",
+    "  list",
+    "  fingerprint",
+    "  collect",
+    "  summarize-errors",
+    "  fix-plan",
+    "  apply-fix",
+    "",
+    "Shared options:",
+    "  --fingerprint <value[,value2,...]>",
+    "  --from <unixTs>                 default: 1",
+    "  --to <unixTs>                   default: now",
+    "  --query-url <url>",
+    "  --proxy <url>",
+    "  --workdir <dir>",
+    "  --storage-dir <dir>",
+    "  --download-concurrency <n>",
+    "",
+    "Fix-plan options:",
+    "  --fingerprint <value>        required for backtrace fix-plan",
+    "  --report-path <path>        relative path under fingerprints/",
+    "  --repair-plan-path <path>   relative path of existing repair plan file",
+    "  --repair-version <value>",
+    "  --plan-file <path>          load plan text from file",
+    "  --plan-text <text>          pass plan text directly",
+    "",
+    "Examples:",
+    "  backtrace list",
+    "  backtrace fingerprint",
+    "  backtrace fingerprint db221f7a4f76...",
+    "  backtrace collect --fingerprint db221f7",
+    "  backtrace summarize-errors --fingerprint db221f7a4f76...",
+    "  backtrace fix-plan --fingerprint db221f7a4f76...",
+    "  backtrace apply-fix --fingerprint db221f7a4f76...",
+  ].join("\n"));
+}
+
+// 保持显式解析，这样每个支持的参数都只映射到一个确定字段，
+// 调用方也能明确区分“显示帮助”和“执行命令”两种模式。
+function parseCliArgs(argv) {
+  const args = Array.from(argv || []);
+  if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
+    return { help: true };
+  }
+
+  const command = args[0];
+  let index = 1;
+
+  const options = {
+    command,
+    fingerprint: "",
+    objectId: "",
+    from: "",
+    to: "",
+    queryUrl: "",
+    proxy: "",
+    workdir: "",
+    storageDir: "",
+    downloadConcurrency: "",
+    limit: "",
+    offset: "",
+    select: "",
+    reportPath: "",
+    repairPlanPath: "",
+    repairVersion: "",
+    planFile: "",
+    planText: "",
+  };
+
+  // 按顺序解析参数，因为这里只支持简单的
+  // "--name value" 形式，以及一个可选的 fix-plan 子命令。
+  for (; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg.startsWith("-") && command === "fingerprint" && !options.fingerprint) {
+      options.fingerprint = arg;
+      continue;
+    }
+    if (arg === "--fingerprint") {
+      options.fingerprint = args[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    if (arg === "--object-id") {
+      options.objectId = args[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    if (arg === "--from") {
+      options.from = args[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    if (arg === "--to") {
+      options.to = args[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    if (arg === "--query-url") {
+      options.queryUrl = args[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    if (arg === "--proxy") {
+      options.proxy = args[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    if (arg === "--workdir") {
+      options.workdir = args[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    if (arg === "--storage-dir") {
+      options.storageDir = args[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    if (arg === "--download-concurrency") {
+      options.downloadConcurrency = args[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    if (arg === "--limit") {
+      options.limit = args[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    if (arg === "--offset") {
+      options.offset = args[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    if (arg === "--select") {
+      options.select = args[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    if (arg === "--report-path") {
+      options.reportPath = args[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    if (arg === "--repair-plan-path") {
+      options.repairPlanPath = args[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    if (arg === "--repair-version") {
+      options.repairVersion = args[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    if (arg === "--plan-file") {
+      options.planFile = args[index + 1] || "";
+      index += 1;
+      continue;
+    }
+    if (arg === "--plan-text") {
+      options.planText = args[index + 1] || "";
+      index += 1;
+    }
+  }
+
+  return { help: false, options };
+}
+
+module.exports = {
+  printCliUsage,
+  parseCliArgs,
+};

package/lib/cli/run.js

@@ -0,0 +1,191 @@
+const fs = require("node:fs/promises");
+const { createOptions, runBacktraceCommand, printList } = require("../BacktraceCodexTool");
+const { applyFixFromFingerprint, generateRepairPlanFromFingerprint } = require("../backtrace/repair-fingerprint");
+
+// 把 CLI 原始字符串参数转换成底层 Backtrace 工具共用的标准选项结构。
+function buildBacktraceOverrides(rawOptions, command) {
+  const overrides = { command };
+  // 这里只复制用户显式传入的字段，避免把空字符串覆盖默认值。
+  if (rawOptions.fingerprint) {
+    overrides.fingerprint = rawOptions.fingerprint;
+  }
+  if (rawOptions.objectId) {
+    overrides.objectId = rawOptions.objectId;
+  }
+  if (rawOptions.from) {
+    overrides.from = rawOptions.from;
+  }
+  if (rawOptions.to) {
+    overrides.to = rawOptions.to;
+  }
+  if (rawOptions.queryUrl) {
+    overrides.queryUrl = rawOptions.queryUrl;
+  }
+  if (rawOptions.proxy) {
+    overrides.proxy = rawOptions.proxy;
+  }
+  if (rawOptions.workdir) {
+    overrides.workdir = rawOptions.workdir;
+  }
+  if (rawOptions.storageDir) {
+    overrides.storageDir = rawOptions.storageDir;
+  }
+  if (rawOptions.downloadConcurrency) {
+    overrides.downloadConcurrency = Number(rawOptions.downloadConcurrency);
+  }
+  if (rawOptions.limit) {
+    overrides.limit = Number(rawOptions.limit);
+  }
+  if (rawOptions.offset) {
+    overrides.offset = Number(rawOptions.offset);
+  }
+  if (rawOptions.select) {
+    overrides.select = rawOptions.select;
+  }
+  return createOptions(overrides);
+}
+
+// CLI 默认输出结构化 JSON，便于管道处理和人工查看。
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+function formatUnixTimestamp(value) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric) || numeric <= 0) {
+    return String(value || "");
+  }
+  return `${numeric} (${new Date(numeric * 1000).toISOString()})`;
+}
+
+function formatObjectTimestamp(value) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric) || numeric <= 0) {
+    return String(value || "");
+  }
+  const date = new Date(numeric * 1000);
+  const year = String(date.getFullYear());
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hour = String(date.getHours()).padStart(2, "0");
+  const minute = String(date.getMinutes()).padStart(2, "0");
+  const second = String(date.getSeconds()).padStart(2, "0");
+  return `${year}-${month}-${day} ${hour}:${minute}:${second} (${numeric})`;
+}
+
+function truncateLine(value, maxLength = 200) {
+  const text = String(value || "").replace(/\s+/g, " ").trim();
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return `${text.slice(0, maxLength)}...`;
+}
+
+function printFingerprintDetail(result) {
+  console.log(`Fingerprint: ${result.fingerprint}`);
+  console.log(`First Seen: ${formatUnixTimestamp(result.firstSeen)}`);
+  console.log(`Issue State: ${result.issueState || ""}`);
+  console.log(`Classifiers: ${result.classifiers || ""}`);
+  console.log(`Object Count: ${result.objectCount}`);
+  console.log(`Query Total Rows: ${result.querySummary?.totalRows ?? result.objectCount}`);
+  console.log(`Fetched Objects: ${result.querySummary?.fetchedRows ?? result.objectCount}`);
+  console.log(`Page Limit: ${result.querySummary?.pageLimit ?? ""}`);
+  console.log(`Error Message: ${truncateLine(result.errorMessage, 240)}`);
+  console.log("");
+  console.log("Objects:");
+
+  if (!Array.isArray(result.objects) || result.objects.length === 0) {
+    console.log("No objects found.");
+    return;
+  }
+
+  result.objects.forEach((item, index) => {
+    console.log(`${index + 1}. ${item.objectIdHex}  ${formatObjectTimestamp(item.timestamp)}`);
+  });
+}
+
+function printLocalFingerprintList(items) {
+  if (!Array.isArray(items) || items.length === 0) {
+    console.log("No local fingerprints found.");
+    return;
+  }
+
+  items.forEach((item, index) => {
+    console.log(`${index + 1}. ${item.fingerprint}`);
+    console.log(`   State: ${item.issueState || ""}`);
+    console.log(`   Error: ${truncateLine(item.errorMessage, 200)}`);
+  });
+}
+
+// 根据解析后的命令分发到对应的 Backtrace 或修复流程。
+async function runCliCommand(rawOptions) {
+  if (rawOptions.command === "list") {
+    const options = buildBacktraceOverrides(rawOptions, "list");
+    const result = await runBacktraceCommand("list", options);
+    printLocalFingerprintList(result.items);
+    return;
+  }
+
+  if (rawOptions.command === "fingerprint") {
+    // fingerprint 只查远端并打印指纹列表，不涉及本地分析和报告生成。
+    const options = buildBacktraceOverrides(rawOptions, "fingerprint");
+    const result = await runBacktraceCommand("fingerprint", options);
+    if (result.mode === "detail") {
+      printFingerprintDetail(result);
+      return;
+    }
+    printList(result.items, {
+      from: options.from,
+      to: options.to,
+      totalRows: result.querySummary.totalRows,
+      totalListed: result.querySummary.fetchedRows,
+      objectCount: result.querySummary.objectCount,
+      pageLimit: result.querySummary.pageLimit,
+    });
+    return;
+  }
+
+  if (rawOptions.command === "collect") {
+    // collect 只做下载，不生成分析报告。
+    const options = buildBacktraceOverrides(rawOptions, "collect-all");
+    const result = await runBacktraceCommand("collect-all", options);
+    printJson({
+      command: "collect",
+      fingerprint: options.fingerprint || "",
+      downloadedCount: result.downloadedItems.length,
+      storageDir: options.storageDir,
+    });
+    return;
+  }
+
+  if (rawOptions.command === "summarize-errors") {
+    const options = buildBacktraceOverrides(rawOptions, "summarize-fingerprint-errors");
+    const result = await runBacktraceCommand("summarize-fingerprint-errors", options);
+    printJson(result);
+    return;
+  }
+
+  if (rawOptions.command === "fix-plan") {
+    if (!rawOptions.fingerprint) {
+      throw new Error("--fingerprint is required for fix-plan");
+    }
+    const result = await generateRepairPlanFromFingerprint({ fingerprint: rawOptions.fingerprint }, rawOptions);
+    printJson(result);
+    return;
+  }
+
+  if (rawOptions.command === "apply-fix") {
+    if (!rawOptions.fingerprint) {
+      throw new Error("--fingerprint is required for apply-fix");
+    }
+    const result = await applyFixFromFingerprint({ fingerprint: rawOptions.fingerprint }, rawOptions);
+    printJson(result);
+    return;
+  }
+
+  throw new Error("Unsupported command. Use --help to see available commands.");
+}
+
+module.exports = {
+  runCliCommand,
+};

package/lib/feishu.js

@@ -0,0 +1,66 @@
+const https = require('node:https');
+const http = require('node:http');
+
+const TEMPLATE_ID = 'AAqtY8l8Sr3hO';
+const TEMPLATE_VERSION = '1.0.3';
+
+function postJson(url, body) {
+  return new Promise(function(resolve, reject) {
+    var parsed = new URL(url);
+    var isHttps = parsed.protocol === 'https:';
+    var payload = JSON.stringify(body);
+    var options = {
+      hostname: parsed.hostname,
+      port: parsed.port || (isHttps ? 443 : 80),
+      path: parsed.pathname + (parsed.search || ''),
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload),
+      },
+    };
+    var transport = isHttps ? https : http;
+    var req = transport.request(options, function(res) {
+      var chunks = [];
+      res.on('data', function(chunk) { chunks.push(chunk); });
+      res.on('end', function() {
+        var text = Buffer.concat(chunks).toString('utf8');
+        var data = null;
+        try { data = JSON.parse(text); } catch (_) { data = text; }
+        resolve({ statusCode: res.statusCode, body: data });
+      });
+    });
+    req.on('error', reject);
+    req.write(payload);
+    req.end();
+  });
+}
+
+async function sendFeishuCard(webhookUrl, fingerprintData) {
+  var templateVariable = {
+    fingerprint: fingerprintData.fingerprint || '',
+    errormessage: fingerprintData.errorMessage || '',
+    classifiers: fingerprintData.classifiers || '',
+    jumpurl: fingerprintData.jumpUrl || ('http://127.0.0.1:3000/chat.html?fingerprint=' + (fingerprintData.fingerprint || '')),
+  };
+
+  var cardContent = {
+    type: 'template',
+    data: {
+      template_id: TEMPLATE_ID,
+      template_version_name: TEMPLATE_VERSION,
+      template_variable: templateVariable,
+    },
+  };
+
+  var body = {
+    msg_type: 'interactive',
+    card: JSON.stringify(cardContent),
+  };
+
+  var result = await postJson(webhookUrl, body);
+  var ok = result.statusCode === 200 && result.body && result.body.code === 0;
+  return { ok: ok, statusCode: result.statusCode, body: result.body };
+}
+
+module.exports = { sendFeishuCard };

package/lib/scheduler.js

@@ -0,0 +1,126 @@
+var fs = require('node:fs/promises');
+var cron = require('node-cron');
+var { BacktraceCodexTool } = require('./backtrace/tool');
+var { sendFeishuCard } = require('./feishu');
+var { readFingerprintMeta, writeFingerprintMeta, FINGERPRINTS_ROOT } = require('../routes/backtrace-shared');
+
+var SCHEDULER_CRON = process.env.SCHEDULER_CRON || '*/5 * * * *';
+var FEISHU_WEBHOOK_URL = process.env.FEISHU_WEBHOOK_URL || '';
+
+// 从 cron 表达式推算间隔秒数，用于首次执行时确定查询起点。
+// 支持常见格式：*/N（每N分钟）、单个数字（每小时/天固定时刻）。
+function cronToIntervalSeconds(cronExpr) {
+  var parts = String(cronExpr || '').trim().split(/\s+/);
+  if (parts.length < 5) return 300;
+
+  var minute = parts[0];
+  var hour = parts[1];
+  var dayOfMonth = parts[2];
+
+  // */N 分钟
+  var everyNMin = minute.match(/^\*\/(\d+)$/);
+  if (everyNMin) return parseInt(everyNMin[1], 10) * 60;
+
+  // */N 小时
+  var everyNHour = hour.match(/^\*\/(\d+)$/);
+  if (everyNHour) return parseInt(everyNHour[1], 10) * 3600;
+
+  // 固定分钟（如 "0 * * * *" = 每小时）
+  if (/^\d+$/.test(minute) && hour === '*') return 3600;
+
+  // 固定小时（如 "0 9 * * *" = 每天）
+  if (/^\d+$/.test(minute) && /^\d+$/.test(hour) && dayOfMonth === '*') return 86400;
+
+  return 300;
+}
+
+async function runScheduledTask() {
+  var now = Math.floor(Date.now() / 1000);
+  var intervalSeconds = cronToIntervalSeconds(SCHEDULER_CRON);
+  var from = String(now - intervalSeconds);
+
+  console.log('[scheduler] 开始执行，时间范围 from=' + from + ' to=' + now);
+
+  var tool = new BacktraceCodexTool();
+
+  // 1. 查询远端新增 fingerprint
+  var remoteFingerprints = [];
+  try {
+    var result = await tool.fingerprint({ from: String(from), to: String(now) });
+    remoteFingerprints = (result.items || []).map(function(item) {
+      return item.fingerprint || (item.values && item.values.fingerprint) || '';
+    }).filter(Boolean);
+    console.log('[scheduler] 远端查询到 ' + remoteFingerprints.length + ' 个 fingerprint');
+  } catch (err) {
+    console.error('[scheduler] 查询 fingerprint 失败:', err.message);
+  }
+
+  // 2. 扫描本地目录，找出所有没有 feishuNotifiedAt 的 fingerprint
+  var localDirs = await fs.readdir(FINGERPRINTS_ROOT, { withFileTypes: true }).catch(function() { return []; });
+  var localFingerprints = localDirs
+    .filter(function(e) { return e.isDirectory() && !e.name.startsWith('.'); })
+    .map(function(e) { return e.name; });
+
+  // 3. 合并去重：远端新增 + 本地未推送，统一过一遍 meta 检查
+  var allFingerprints = Array.from(new Set(remoteFingerprints.concat(localFingerprints)));
+
+  var pendingItems = [];
+  for (var i = 0; i < allFingerprints.length; i++) {
+    var fp = allFingerprints[i];
+    var meta = await readFingerprintMeta(fp).catch(function() { return null; });
+    if (!meta || meta.feishuNotifiedAt) continue;
+    pendingItems.push({ fp: fp, meta: meta });
+  }
+
+  console.log('[scheduler] 待推送 fingerprint: ' + pendingItems.length + ' 个');
+
+  if (pendingItems.length > 0) {
+    if (!FEISHU_WEBHOOK_URL) {
+      console.warn('[scheduler] FEISHU_WEBHOOK_URL 未配置，跳过推送');
+    } else {
+      for (var j = 0; j < pendingItems.length; j++) {
+        var entry = pendingItems[j];
+        var sendResult = await sendFeishuCard(FEISHU_WEBHOOK_URL, {
+          fingerprint: entry.fp,
+          errorMessage: entry.meta.errorMessage || '',
+          classifiers: entry.meta.classifiers || '',
+        }).catch(function(err) {
+          return { ok: false, error: err.message };
+        });
+
+        if (sendResult.ok) {
+          var updated = Object.assign({}, entry.meta, { feishuNotifiedAt: new Date().toISOString() });
+          await writeFingerprintMeta(entry.fp, updated).catch(function(err) {
+            console.error('[scheduler] 写入 meta.json 失败 ' + entry.fp + ':', err.message);
+          });
+          console.log('[scheduler] 推送成功: ' + entry.fp);
+        } else {
+          console.error('[scheduler] 推送失败: ' + entry.fp, sendResult.body || sendResult.error);
+        }
+      }
+    }
+  }
+
+  // 4. 同步本地已有 fingerprint 的 object 列表（不触发推送）
+  console.log('[scheduler] 同步本地 fingerprint 的 object 列表，共 ' + localFingerprints.length + ' 个');
+  for (var k = 0; k < localFingerprints.length; k++) {
+    var syncFp = localFingerprints[k];
+    try {
+      await tool.fingerprint({ fingerprint: syncFp, from: '1', to: String(now) });
+      console.log('[scheduler] 同步完成: ' + syncFp);
+    } catch (syncErr) {
+      console.error('[scheduler] 同步失败: ' + syncFp, syncErr.message);
+    }
+  }
+}
+
+function start() {
+  console.log('[scheduler] 启动定时任务，cron=' + SCHEDULER_CRON);
+  cron.schedule(SCHEDULER_CRON, function() {
+    runScheduledTask().catch(function(err) {
+      console.error('[scheduler] 任务异常:', err.message);
+    });
+  });
+}
+
+module.exports = { start };

package/package.json

@@ -1,23 +1,27 @@
 {
   "name": "backtrace-console",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "CLI server manager for backtrace-console — run/start/stop the Express server.",
   "private": false,
   "files": [
-    "bin/backtrace-server.js"
+    "bin/backtrace-server.js",
+    "bin/www",
+    "app.js",
+    "lib",
+    "public",
+    "routes"
   ],
   "bin": {
     "backtrace-server": "bin/backtrace-server.js"
   },
   "scripts": {
     "start": "node ./bin/www",
-    "backtrace": "node ./bin/backtrace-cli.js",
     "server:run": "node ./bin/backtrace-server.js run",
     "server:start": "node ./bin/backtrace-server.js start",
     "server:stop": "node ./bin/backtrace-server.js stop",
     "server:status": "node ./bin/backtrace-server.js status"
   },
-  "devDependencies": {
+  "dependencies": {
     "@openai/codex-sdk": "^0.128.0",
     "cookie-parser": "~1.4.4",
     "debug": "~2.6.9",