backtrace-console 0.0.4 → 0.0.6

package/lib/feishu.js

@@ -2,7 +2,8 @@ const https = require('node:https');
 const http = require('node:http');
 
 const TEMPLATE_ID = 'AAqtY8l8Sr3hO';
-const TEMPLATE_VERSION = '1.0.3';
+const TEMPLATE_VERSION = '1.0.5';
+const BASE_URL = (process.env.BACKTRACE_CONSOLE_URL || 'http://127.0.0.1:3000').replace(/\/$/, '');
 
 function postJson(url, body) {
   return new Promise(function(resolve, reject) {
@@ -41,7 +42,9 @@ async function sendFeishuCard(webhookUrl, fingerprintData) {
     fingerprint: fingerprintData.fingerprint || '',
     errormessage: fingerprintData.errorMessage || '',
     classifiers: fingerprintData.classifiers || '',
-    jumpurl: fingerprintData.jumpUrl || ('http://127.0.0.1:3000/chat.html?fingerprint=' + (fingerprintData.fingerprint || '')),
+    jumpurl: fingerprintData.jumpUrl || (BASE_URL + '/chat.html?fingerprint=' + (fingerprintData.fingerprint || '')),
+    claude_jumpurl: fingerprintData.claude_jumpUrl || (BASE_URL + '/chat-claude.html?fingerprint=' + (fingerprintData.fingerprint || '')),
+
   };
 
   var cardContent = {

package/lib/p4ops.js

@@ -0,0 +1,72 @@
+var { exec } = require('node:child_process');
+
+var P4PORT = process.env.P4PORT || '';
+var P4USER = process.env.P4USER || '';
+var P4CLIENT = process.env.P4CLIENT || '';
+var P4_WORKDIR = process.env.BACKTRACE_WORKDIR || process.cwd();
+
+function checkConfig() {
+  return Boolean(P4PORT && P4USER && P4CLIENT);
+}
+
+function buildArgs(cmdParts) {
+  var args = [];
+  if (P4PORT) { args.push('-p'); args.push(P4PORT); }
+  if (P4USER) { args.push('-u'); args.push(P4USER); }
+  if (P4CLIENT) { args.push('-c'); args.push(P4CLIENT); }
+  return args.concat(cmdParts);
+}
+
+function p4exec(args) {
+  return new Promise(function(resolve) {
+    var childEnv = Object.assign({}, process.env);
+    if (process.env.P4PASSWD) childEnv.P4PASSWD = process.env.P4PASSWD;
+    var cmd = 'p4 ' + args.join(' ');
+    exec(cmd, { cwd: P4_WORKDIR, timeout: 120000, env: childEnv }, function(err, stdout, stderr) {
+      if (err) {
+        resolve({ ok: false, error: err.message, output: (stderr || '').slice(0, 1000) });
+      } else {
+        resolve({ ok: true, output: (stdout || '') });
+      }
+    });
+  });
+}
+
+// 对指定文件列表运行 reconcile -e，使其在 P4 中标记为 opened for edit
+function p4ReconcileFiles(files) {
+  if (!checkConfig()) return Promise.resolve({ ok: true, skipped: true, output: '' });
+  if (!files || !files.length) return Promise.resolve({ ok: true, output: '' });
+  // Quote each path and pass as separate args
+  var quotedFiles = files.map(function(f) { return '"' + String(f).replace(/"/g, "'") + '"'; });
+  console.log('[p4ops] reconcile -e ' + files.length + ' file(s)');
+  return p4exec(buildArgs(['reconcile', '-e'].concat(quotedFiles)));
+}
+
+// files: 本地文件路径数组，仅提交这些文件（p4 submit -d "desc" file1 file2 ...）
+function p4Submit(description, files) {
+  if (!checkConfig()) return Promise.resolve({ ok: false, error: '未配置 P4PORT/P4USER/P4CLIENT' });
+  if (!description) return Promise.resolve({ ok: false, error: 'description is required' });
+  var safeDesc = String(description)
+    .replace(/[&|<>^]/g, '')
+    .replace(/"/g, "'")
+    .replace(/[\r\n]+/g, ' - ')
+    .trim()
+    .slice(0, 200);
+  var cmdParts = ['submit', '-d', '"' + safeDesc + '"'];
+  if (files && files.length) {
+    var quotedFiles = files.map(function(f) { return '"' + String(f).replace(/"/g, "'") + '"'; });
+    cmdParts = cmdParts.concat(quotedFiles);
+    console.log('[p4ops] submit -d "' + safeDesc + '" (' + files.length + ' 个文件)');
+  } else {
+    console.log('[p4ops] submit -d "' + safeDesc + '" (全部 opened)');
+  }
+  return p4exec(buildArgs(cmdParts)).then(function(result) {
+    if (result.ok) {
+      var m = (result.output || '').match(/Change\s+(\d+)\s+submitted/i);
+      result.changelistId = m ? m[1] : null;
+    }
+    return result;
+  });
+}
+
+module.exports = { p4ReconcileFiles, p4Submit, checkConfig };

package/lib/p4sync.js

@@ -0,0 +1,35 @@
+var { exec } = require('node:child_process');
+
+var P4PORT = process.env.P4PORT || '';
+var P4USER = process.env.P4USER || '';
+var P4CLIENT = process.env.P4CLIENT || '';
+var P4_WORKDIR = process.env.BACKTRACE_WORKDIR || process.cwd();
+
+async function runP4Sync() {
+  if (!P4PORT || !P4USER || !P4CLIENT) {
+    console.log('[p4sync] 未配置 P4PORT/P4USER/P4CLIENT，跳过同步');
+    return { ok: true, skipped: true };
+  }
+
+  var args = ['-p', P4PORT, '-u', P4USER, '-c', P4CLIENT, 'sync', '...'];
+  var cmd = 'p4 ' + args.join(' ');
+  console.log('[p4sync] 执行: ' + cmd + ' (cwd=' + P4_WORKDIR + ')');
+
+  return new Promise(function(resolve) {
+    var childEnv = Object.assign({}, process.env);
+    if (process.env.P4PASSWD) childEnv.P4PASSWD = process.env.P4PASSWD;
+    exec(cmd, { cwd: P4_WORKDIR, timeout: 120000, env: childEnv }, function(err, stdout, stderr) {
+      if (err) {
+        console.error('[p4sync] 同步失败:', err.message);
+        if (stderr) console.error('[p4sync] stderr:', stderr.slice(0, 500));
+        resolve({ ok: false, error: err.message });
+      } else {
+        console.log('[p4sync] 同步成功');
+        if (stdout) console.log('[p4sync] 输出:', stdout.slice(0, 500));
+        resolve({ ok: true });
+      }
+    });
+  });
+}
+
+module.exports = { runP4Sync };

package/lib/scheduler.js

@@ -1,11 +1,28 @@
 var fs = require('node:fs/promises');
+var path = require('node:path');
 var cron = require('node-cron');
 var { BacktraceCodexTool } = require('./backtrace/tool');
 var { sendFeishuCard } = require('./feishu');
 var { readFingerprintMeta, writeFingerprintMeta, FINGERPRINTS_ROOT } = require('../routes/backtrace-shared');
+var { runP4Sync } = require('./p4sync');
 
 var SCHEDULER_CRON = process.env.SCHEDULER_CRON || '*/5 * * * *';
 var FEISHU_WEBHOOK_URL = process.env.FEISHU_WEBHOOK_URL || '';
+var STATE_FILE = path.join(FINGERPRINTS_ROOT, '.scheduler-state.json');
+
+async function readSchedulerState() {
+  try {
+    var raw = await fs.readFile(STATE_FILE, 'utf8');
+    return JSON.parse(raw) || {};
+  } catch (e) {
+    return {};
+  }
+}
+
+async function writeSchedulerState(state) {
+  await fs.mkdir(FINGERPRINTS_ROOT, { recursive: true }).catch(function() {});
+  await fs.writeFile(STATE_FILE, JSON.stringify(state, null, 2), 'utf8');
+}
 
 // 从 cron 表达式推算间隔秒数，用于首次执行时确定查询起点。
 // 支持常见格式：*/N（每N分钟）、单个数字（每小时/天固定时刻）。
@@ -34,82 +51,111 @@ function cronToIntervalSeconds(cronExpr) {
   return 300;
 }
 
+async function listLocalFingerprintNames() {
+  var entries = await fs.readdir(FINGERPRINTS_ROOT, { withFileTypes: true }).catch(function() { return []; });
+  return entries
+    .filter(function(e) { return e.isDirectory() && !e.name.startsWith('.'); })
+    .map(function(e) { return e.name; });
+}
+
 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);
+  // 读取上次成功查询的截止时间，用于失败恢复
+  // - 上次成功：from = lastSuccessTo（连续覆盖）
+  // - 上次失败 / 首次：from = now - intervalSeconds（默认窗口）
+  var state = await readSchedulerState();
+  var defaultFrom = now - intervalSeconds;
+  var from = (typeof state.lastSuccessTo === 'number' && state.lastSuccessTo > 0)
+    ? state.lastSuccessTo
+    : defaultFrom;
+
+  // 防御性下限：不允许窗口跨度超过 24 小时，避免长时间故障后一次拉取过量数据
+  var MAX_LOOKBACK = 24 * 3600;
+  if (now - from > MAX_LOOKBACK) {
+    console.warn('[scheduler] 上次成功时间过早 (' + (now - from) + 's)，截断到 ' + MAX_LOOKBACK + 's');
+    from = now - MAX_LOOKBACK;
+  }
 
-  var tool = new BacktraceCodexTool();
+  console.log('[scheduler] 开始执行，时间范围 from=' + from + ' to=' + now + '（跨度 ' + (now - from) + 's）');
+
+  // 0. P4 同步：拉取最新代码，保证后续分析基于最新源码
+  await runP4Sync().catch(function(err) {
+    console.error('[scheduler] p4sync 异常:', err.message);
+  });
 
-  // 1. 查询远端新增 fingerprint
-  var remoteFingerprints = [];
+  // 1. 拉取远端前，先记录当前本地已有的 fingerprint 目录（用于区分"远端新增"与"本地补推"）
+  var existingLocal = new Set(await listLocalFingerprintNames());
+
+  // 2. 查询远端 fingerprint（tool.fingerprint 内部会把新结果写到本地目录）
+  var tool = new BacktraceCodexTool();
+  var remoteOk = false;
   try {
     var result = await tool.fingerprint({ from: String(from), to: String(now) });
-    remoteFingerprints = (result.items || []).map(function(item) {
+    var remoteFingerprints = (result.items || []).map(function(item) {
       return item.fingerprint || (item.values && item.values.fingerprint) || '';
     }).filter(Boolean);
     console.log('[scheduler] 远端查询到 ' + remoteFingerprints.length + ' 个 fingerprint');
+    remoteOk = true;
   } catch (err) {
-    console.error('[scheduler] 查询 fingerprint 失败:', err.message);
+    console.error('[scheduler] 查询 fingerprint 失败:', err.message + '（下次将从 from=' + from + ' 继续补查）');
+    // 远端失败不影响本地补推，继续扫描；不更新 lastSuccessTo
   }
 
-  // 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)));
+  // 远端查询成功才推进 lastSuccessTo，下次窗口从 now 起；失败则保留旧值
+  if (remoteOk) {
+    state.lastSuccessTo = now;
+    state.lastSuccessAt = new Date().toISOString();
+    await writeSchedulerState(state).catch(function(err) {
+      console.error('[scheduler] 写入 scheduler-state 失败:', err.message);
+    });
+  }
 
+  // 3. 扫描本地全部目录，找出尚未推送过（meta.feishuNotifiedAt 缺失）的
+  var allLocal = await listLocalFingerprintNames();
   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 });
+  for (var i = 0; i < allLocal.length; i++) {
+    var fpName = allLocal[i];
+    var localMeta = await readFingerprintMeta(fpName).catch(function() { return null; });
+    if (!localMeta || localMeta.feishuNotifiedAt) continue;
+    pendingItems.push({
+      fp: fpName,
+      meta: localMeta,
+      isNewRemote: !existingLocal.has(fpName),
+    });
   }
 
-  console.log('[scheduler] 待推送 fingerprint: ' + pendingItems.length + ' 个');
+  var newCount = pendingItems.filter(function(it) { return it.isNewRemote; }).length;
+  var localCount = pendingItems.length - newCount;
+  console.log('[scheduler] 待推送 ' + pendingItems.length + ' 个（远端新增 ' + newCount + '，本地补推 ' + localCount + '）');
 
-  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);
-        }
-      }
-    }
+  if (pendingItems.length === 0) return;
+
+  if (!FEISHU_WEBHOOK_URL) {
+    console.warn('[scheduler] FEISHU_WEBHOOK_URL 未配置，跳过推送');
+    return;
   }
 
-  // 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);
+  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 };
+    });
+
+    var tag = entry.isNewRemote ? '[远端新增]' : '[本地补推]';
+    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] ' + tag + ' 推送成功: ' + entry.fp);
+    } else {
+      console.error('[scheduler] ' + tag + ' 推送失败: ' + entry.fp, sendResult.body || sendResult.error);
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backtrace-console",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "CLI server manager for backtrace-console — run/start/stop the Express server.",
   "private": false,
   "files": [
@@ -22,6 +22,7 @@
     "server:status": "node ./bin/backtrace-server.js status"
   },
   "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.133",
     "@openai/codex-sdk": "^0.128.0",
     "cookie-parser": "~1.4.4",
     "debug": "~2.6.9",