backtrace-console 0.0.1 → 0.0.2

package/lib/backtrace/repair.js

@@ -485,7 +485,42 @@ async function readRepairPlanText(input, overrides = {}) {
   return file.content;
 }
 
+
+async function runChatTurn(input, overrides = {}) {
+  const context = createRepairContext(overrides);
+  const prompt = String(input.prompt || "").trim();
+  const threadId = input.threadId;
+
+  if (!prompt) {
+    throw new Error("prompt is required");
+  }
+
+  const codex = await getCodex(context.proxy);
+  let thread;
+  
+  if (threadId) {
+    thread = codex.resumeThread(threadId);
+  } else {
+    thread = codex.startThread({
+      workingDirectory: context.workdir,
+      skipGitRepoCheck: true,
+      sandboxMode: "read-only",
+      approvalPolicy: "never",
+      modelReasoningEffort: "low"
+    });
+  }
+
+  const turn = await runCodexTurnWithStreaming(thread, prompt, "[backtrace-chat]", "run-chat", { threadId: thread.id });
+
+  return {
+    ok: true,
+    reply: turn.finalResponse,
+    threadId: thread.id
+  };
+}
+
 module.exports = {
+  runChatTurn,
   createRepairContext,
   formatRepairVersion,
   resolveCodexProxy,

package/lib/backtrace/tool.js

@@ -27,14 +27,29 @@ async function writeFingerprintMetadata(items, options) {
     const fingerprint = normalizeFingerprint(item.fingerprint || item.values.fingerprint);
     const fingerprintDir = path.join(options.storageDir, fingerprint);
     const metaPath = path.join(fingerprintDir, "meta.json");
-    const meta = {
+
+    const incoming = {
       fingerprint,
       firstSeen: item.values["fingerprint;first_seen"] || "",
       issueState: item.values["fingerprint;issues;state"] || "",
-      errorMessage: item.values["error.message"] || "",
       classifiers: item.values.classifiers || "",
     };
 
+    // 保留已有字段（如 feishuNotifiedAt），只更新远端字段
+    let existing = {};
+    const raw = await fs.readFile(metaPath, "utf8").catch(() => "");
+    if (raw) {
+      try { existing = JSON.parse(raw); } catch (_) { existing = {}; }
+    }
+
+    // errorMessage 只在首次写入，后续不覆盖（Backtrace 每次可能返回不同 object 的值）
+    const errorMessage = item.values["error.message"] || "";
+    if (!existing.errorMessage && errorMessage) {
+      incoming.errorMessage = errorMessage;
+    }
+
+    const meta = { ...existing, ...incoming };
+
     await ensureDirectory(fingerprintDir);
     await fs.writeFile(metaPath, JSON.stringify(meta, null, 2), "utf8");
     written.push({ fingerprint, metaPath });
@@ -183,6 +198,22 @@ class BacktraceCodexTool {
     if (command === "fingerprint" && getRequestedFingerprints(options).length === 1) {
       const detail = await queryFingerprintDetail(session, options);
       const writtenMeta = await writeFingerprintMetadata([detail.summary], options);
+
+      // 为每个 object 创建本地目录并缓存元数据，避免重复请求远端
+      const logsRoot = path.join(options.storageDir, normalizeFingerprint(detail.fingerprint), "logs");
+      await ensureDirectory(logsRoot);
+      for (const obj of detail.objects) {
+        /* eslint-disable no-await-in-loop */
+        const objDir = path.join(logsRoot, obj.objectIdHex);
+        await ensureDirectory(objDir);
+        const objMetaPath = path.join(objDir, "object-meta.json");
+        const objMetaExists = await fs.stat(objMetaPath).catch(() => null);
+        if (!objMetaExists) {
+          await fs.writeFile(objMetaPath, JSON.stringify({ objectIdHex: obj.objectIdHex, timestamp: obj.timestamp }, null, 2), "utf8");
+        }
+        /* eslint-enable no-await-in-loop */
+      }
+
       return {
         command,
         mode: "detail",
@@ -330,4 +361,4 @@ async function runBacktraceCommand(command, overrides = {}) {
 module.exports = {
   BacktraceCodexTool,
   runBacktraceCommand,
-};
+};

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,6 +1,6 @@
 {
   "name": "backtrace-console",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "CLI for querying Backtrace fingerprints, collecting artifacts, and generating repair plans.",
   "private": false,
   "files": [
@@ -11,19 +11,25 @@
     "routes"
   ],
   "bin": {
-    "backtrace": "bin/backtrace-cli.js"
+    "backtrace": "bin/backtrace-cli.js",
+    "backtrace-server": "bin/backtrace-server.js"
   },
   "scripts": {
     "start": "node ./bin/www",
-    "backtrace": "node ./bin/backtrace-cli.js"
+    "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"
   },
   "dependencies": {
-    "@openai/codex-sdk": "^0.118.0",
+    "@openai/codex-sdk": "^0.128.0",
     "cookie-parser": "~1.4.4",
     "debug": "~2.6.9",
     "dotenv": "^17.4.1",
     "express": "~4.16.1",
     "morgan": "~1.9.1",
+    "node-cron": "^4.2.1",
     "undici": "^7.24.8"
   }
 }