backtrace-console 0.0.1

package/routes/backtrace.js

@@ -0,0 +1,864 @@
+var express = require('express');
+var fs = require('node:fs/promises');
+var path = require('node:path');
+var router = express.Router();
+var BacktraceCodexToolModule = require('../lib/BacktraceCodexTool');
+var BacktraceCodexTool = BacktraceCodexToolModule.BacktraceCodexTool;
+var DEFAULT_WORKDIR = BacktraceCodexToolModule.DEFAULT_WORKDIR;
+var DEFAULT_PROXY = BacktraceCodexToolModule.DEFAULT_PROXY;
+var DEFAULT_QUERY_URL = BacktraceCodexToolModule.DEFAULT_QUERY_URL;
+var BacktraceRepairModule = require('../lib/backtrace/repair');
+var generateRepairPlanShared = BacktraceRepairModule.generateRepairPlan;
+var applyRepairPlanShared = BacktraceRepairModule.applyRepairPlan;
+var resolveCodexProxyShared = BacktraceRepairModule.resolveCodexProxy;
+
+var ROOT_DIR = process.cwd();
+var FINGERPRINTS_ROOT = path.join(ROOT_DIR, 'fingerprints');
+var BACKTRACE_USERNAME = process.env.BACKTRACE_USERNAME || '';
+var BACKTRACE_PASSWORD = process.env.BACKTRACE_PASSWORD || '';
+var REPAIR_STATUS_FILE = '.repair-status.json';
+
+function formatRepairVersion(date) {
+  var year = String(date.getFullYear());
+  var month = String(date.getMonth() + 1).padStart(2, '0');
+  var day = String(date.getDate()).padStart(2, '0');
+  var hour = String(date.getHours()).padStart(2, '0');
+  var minute = String(date.getMinutes()).padStart(2, '0');
+  var second = String(date.getSeconds()).padStart(2, '0');
+  return year + month + day + '-' + hour + minute + second;
+}
+
+function getFingerprintPathFromReportPath(relativeReportPath) {
+  var normalized = String(relativeReportPath || '').replace(/[\\/]+/g, '/').trim();
+  if (!normalized) {
+    throw new Error('Invalid report path');
+  }
+
+  var parts = normalized.split('/').filter(Boolean);
+  var reportsIndex = parts.lastIndexOf('reports');
+  if (reportsIndex > 0) {
+    return parts.slice(0, reportsIndex).join(path.sep);
+  }
+
+  if (parts.length >= 2) {
+    return parts.slice(0, -1).join(path.sep);
+  }
+
+  return parts[0];
+}
+
+function getRepairVersionRelativeDir(relativeReportPath, repairVersion) {
+  return path.join(getFingerprintPathFromReportPath(relativeReportPath), 'repair', repairVersion);
+}
+
+function getRepairVersionFromRepairPlanPath(repairPlanPath) {
+  var normalized = String(repairPlanPath || '').replace(/[\\/]+/g, '/').trim();
+  if (!normalized) {
+    return '';
+  }
+  var parts = normalized.split('/').filter(Boolean);
+  var repairIndex = parts.lastIndexOf('repair');
+  if (repairIndex >= 0 && parts.length > repairIndex + 1) {
+    return parts[repairIndex + 1];
+  }
+  return '';
+}
+
+async function resolveNewRepairVersion(relativeReportPath) {
+  var baseVersion = formatRepairVersion(new Date());
+  var repairRootRelative = path.join(getFingerprintPathFromReportPath(relativeReportPath), 'repair');
+  var repairRootAbsolute = toSafeAbsolute(FINGERPRINTS_ROOT, repairRootRelative);
+  var suffix = 0;
+  while (true) {
+    var repairVersion = suffix === 0 ? baseVersion : (baseVersion + '-' + String(suffix).padStart(2, '0'));
+    var candidateDir = path.join(repairRootAbsolute, repairVersion);
+    if (!(await pathExists(candidateDir))) {
+      return repairVersion;
+    }
+    suffix += 1;
+  }
+}
+
+async function resolveRepairVersionForApply(relativeReportPath, repairVersion, repairPlanPath) {
+  var normalized = String(repairVersion || '').trim();
+  if (normalized) {
+    return normalized;
+  }
+  var planVersion = getRepairVersionFromRepairPlanPath(repairPlanPath);
+  if (planVersion) {
+    return planVersion;
+  }
+  var repairRootRelative = path.join(getFingerprintPathFromReportPath(relativeReportPath), 'repair');
+  var repairRootAbsolute = toSafeAbsolute(FINGERPRINTS_ROOT, repairRootRelative);
+  var entries = await fs.readdir(repairRootAbsolute, { withFileTypes: true }).catch(function() { return []; });
+  var versions = entries.filter(function(entry) { return entry.isDirectory(); }).map(function(entry) { return entry.name; }).sort().reverse();
+  if (versions.length > 0) {
+    return versions[0];
+  }
+  return formatRepairVersion(new Date());
+}
+
+async function ensureRepairVersionDir(relativeReportPath, repairVersion) {
+  var relativeDir = getRepairVersionRelativeDir(relativeReportPath, repairVersion);
+  var absoluteDir = toSafeAbsolute(FINGERPRINTS_ROOT, relativeDir);
+  await fs.mkdir(absoluteDir, { recursive: true });
+  return { relativeDir: relativeDir, absoluteDir: absoluteDir };
+}
+
+async function writeRepairArtifact(relativeReportPath, repairVersion, fileName, text) {
+  var versionDir = await ensureRepairVersionDir(relativeReportPath, repairVersion);
+  var relativePath = path.join(versionDir.relativeDir, fileName);
+  var absolutePath = path.join(versionDir.absoluteDir, fileName);
+  await fs.writeFile(absolutePath, String(text || ''), 'utf8');
+  return { repairVersion: repairVersion, relativeDir: versionDir.relativeDir, relativePath: relativePath, absolutePath: absolutePath };
+}
+
+function collectModifiedSourceCandidates(text) {
+  var matches = String(text || '').match(/(?:[A-Za-z]:)?[A-Za-z0-9_./\\-]+\.(?:js|jsx|ts|tsx|json|css|scss|less|html|vue|java|kt|go|py|rb|php|cs|cpp|c|h|hpp|m|mm|swift|xml|yml|yaml)/g) || [];
+  return Array.from(new Set(matches.map(function(item) {
+    return String(item || '').replace(/\\/g, '/').replace(/^\.\//, '').trim();
+  }).filter(Boolean)));
+}
+
+async function archiveModifiedSources(repairVersionRelativeDir, text) {
+  var candidates = collectModifiedSourceCandidates(text);
+  var archived = [];
+  for (var i = 0; i < candidates.length; i += 1) {
+    var candidate = candidates[i];
+    var workspaceAbsolute = path.resolve(ROOT_DIR, candidate);
+    if (workspaceAbsolute !== ROOT_DIR && !workspaceAbsolute.startsWith(ROOT_DIR + path.sep)) {
+      continue;
+    }
+    var stats = await fs.stat(workspaceAbsolute).catch(function() { return null; });
+    if (!stats || !stats.isFile()) {
+      continue;
+    }
+    var sourceRelativePath = path.relative(ROOT_DIR, workspaceAbsolute);
+    if (!sourceRelativePath || sourceRelativePath.startsWith('fingerprints' + path.sep)) {
+      continue;
+    }
+    var targetRelativePath = path.join(repairVersionRelativeDir, 'sources', sourceRelativePath);
+    var targetAbsolutePath = toSafeAbsolute(FINGERPRINTS_ROOT, targetRelativePath);
+    await fs.mkdir(path.dirname(targetAbsolutePath), { recursive: true });
+    var fileContent = await fs.readFile(workspaceAbsolute);
+    await fs.writeFile(targetAbsolutePath, fileContent);
+    archived.push(targetRelativePath);
+  }
+  return archived;
+}
+
+function buildFingerprintStatus(hasReports, hasCompletedRepair) {
+  if (!hasReports) {
+    return '未生成报告';
+  }
+  return hasCompletedRepair ? '已完成' : '未修复状态';
+}
+
+async function readRepairStatus(relativeFingerprintPath) {
+  var statusPath = toSafeAbsolute(FINGERPRINTS_ROOT, path.join(relativeFingerprintPath, 'reports', REPAIR_STATUS_FILE));
+  var raw = await fs.readFile(statusPath, 'utf8').catch(function() { return ''; });
+  if (!raw) {
+    return null;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    return null;
+  }
+}
+
+async function writeRepairStatus(relativeReportPath, payload) {
+  var reportsRelativeDir = path.dirname(relativeReportPath);
+  var statusPath = toSafeAbsolute(FINGERPRINTS_ROOT, path.join(reportsRelativeDir, REPAIR_STATUS_FILE));
+  await fs.writeFile(statusPath, JSON.stringify(payload, null, 2), 'utf8');
+  return path.relative(FINGERPRINTS_ROOT, statusPath);
+}
+
+function toSafeAbsolute(rootDir, relativePath) {
+  var safeRelative = String(relativePath || '').replace(/[\\/]+/g, path.sep);
+  var targetPath = path.resolve(rootDir, safeRelative);
+  if (targetPath !== rootDir && !targetPath.startsWith(rootDir + path.sep)) {
+    throw new Error('Invalid path');
+  }
+  return targetPath;
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+function compareBatchNameDescending(a, b) {
+  return b.name.localeCompare(a.name);
+}
+
+function compareFingerprintByFetchedAtDescending(a, b) {
+  var timeDiff = Number(b.fetchedAtTs || 0) - Number(a.fetchedAtTs || 0);
+  if (timeDiff !== 0) {
+    return timeDiff;
+  }
+  return compareBatchNameDescending(a, b);
+}
+
+async function listImmediateDirectories(rootDir, relativeDir) {
+  var absoluteDir = toSafeAbsolute(rootDir, relativeDir || '');
+  if (!(await pathExists(absoluteDir))) {
+    return [];
+  }
+
+  var entries = await fs.readdir(absoluteDir, { withFileTypes: true });
+  return entries
+    .filter(function(entry) { return entry.isDirectory(); })
+    .map(function(entry) {
+      return {
+        name: entry.name,
+        path: relativeDir ? path.join(relativeDir, entry.name) : entry.name,
+      };
+    });
+}
+
+async function listImmediateFiles(rootDir, relativeDir) {
+  var absoluteDir = toSafeAbsolute(rootDir, relativeDir || '');
+  if (!(await pathExists(absoluteDir))) {
+    return [];
+  }
+
+  var entries = await fs.readdir(absoluteDir, { withFileTypes: true });
+  return entries
+    .filter(function(entry) { return entry.isFile(); })
+    .map(function(entry) {
+      var childRelative = relativeDir ? path.join(relativeDir, entry.name) : entry.name;
+      return {
+        name: entry.name,
+        path: childRelative,
+        ext: path.extname(entry.name).toLowerCase(),
+      };
+    })
+    .sort(function(a, b) { return a.name.localeCompare(b.name); });
+}
+
+async function readFingerprintFetchedMeta(relativeFingerprintPath) {
+  var absolutePath = toSafeAbsolute(FINGERPRINTS_ROOT, relativeFingerprintPath);
+  var stats = await fs.stat(absolutePath);
+  var fetchedAtDate = stats.birthtimeMs ? new Date(stats.birthtimeMs) : (stats.ctimeMs ? new Date(stats.ctimeMs) : new Date(stats.mtimeMs));
+  return {
+    fetchedAt: fetchedAtDate.toISOString(),
+    fetchedAtTs: fetchedAtDate.getTime(),
+  };
+}
+
+async function listTopLevelMergedDirectories() {
+  var fingerprintDirs = await listImmediateDirectories(FINGERPRINTS_ROOT, '');
+  var items = await Promise.all(fingerprintDirs.map(async function(item) {
+    var logDirs = await listImmediateDirectories(FINGERPRINTS_ROOT, path.join(item.path, 'logs'));
+    var reportFiles = await listImmediateFiles(FINGERPRINTS_ROOT, path.join(item.path, 'reports'));
+    var repairStatus = await readRepairStatus(item.path);
+    var fetchedMeta = await readFingerprintFetchedMeta(item.path);
+    var hasReports = reportFiles.length > 0;
+    var hasCompletedRepair = !!(repairStatus && repairStatus.completed);
+    return {
+      name: item.name,
+      path: item.path,
+      hasLogs: logDirs.length > 0,
+      hasReports: hasReports,
+      hasCompletedRepair: hasCompletedRepair,
+      status: buildFingerprintStatus(hasReports, hasCompletedRepair),
+      fetchedAt: fetchedMeta.fetchedAt,
+      fetchedAtTs: fetchedMeta.fetchedAtTs,
+    };
+  }));
+
+  return items.sort(compareFingerprintByFetchedAtDescending);
+}
+
+function buildLoginUrl(queryUrl) {
+  var url = new URL(queryUrl || DEFAULT_QUERY_URL);
+  url.pathname = '/api/login';
+  url.search = '';
+  return url.toString();
+}
+
+async function loginBacktraceSession(queryUrl) {
+  if (!BACKTRACE_USERNAME || !BACKTRACE_PASSWORD) {
+    throw new Error('BACKTRACE_USERNAME and BACKTRACE_PASSWORD are required');
+  }
+
+  var body = new URLSearchParams();
+  body.set('username', BACKTRACE_USERNAME);
+  body.set('password', BACKTRACE_PASSWORD);
+
+  var response = await fetch(buildLoginUrl(queryUrl), {
+    method: 'POST',
+    headers: { 'content-type': 'application/x-www-form-urlencoded' },
+    body: body.toString(),
+  });
+
+  var payload = await response.json().catch(function() { return null; });
+  if (!response.ok || !payload || !payload.token) {
+    throw new Error('Backtrace login failed');
+  }
+
+  return payload.token;
+}
+
+async function requestBacktraceQuery(queryUrl, sessionToken, body) {
+  var response = await fetch(queryUrl, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      Cookie: 'token=' + sessionToken,
+    },
+    body: JSON.stringify(body),
+  });
+
+  var payload = await response.json().catch(function() { return null; });
+  if (!response.ok || !payload) {
+    throw new Error('Backtrace query request failed');
+  }
+
+  return payload;
+}
+
+function toHexObjectId(value) {
+  if (typeof value === 'string' && /^[0-9a-f]+$/i.test(value)) {
+    return value.toLowerCase();
+  }
+
+  var numeric = Number(value);
+  if (!Number.isFinite(numeric)) {
+    return String(value);
+  }
+
+  return numeric.toString(16);
+}
+
+function extractGroupFingerprints(payload) {
+  var values = payload && payload.response && Array.isArray(payload.response.values) ? payload.response.values : [];
+  return values.map(function(entry) {
+    return {
+      fingerprint: Array.isArray(entry) ? entry[0] : '',
+      count: Array.isArray(entry) ? entry[entry.length - 1] : 0,
+    };
+  }).filter(function(item) { return item.fingerprint; });
+}
+
+function extractObjectIds(objects) {
+  if (!Array.isArray(objects) || objects.length === 0) {
+    return [];
+  }
+
+  var firstGroup = objects[0];
+  var rows = Array.isArray(firstGroup) ? firstGroup[1] : [];
+  if (!Array.isArray(rows)) {
+    return [];
+  }
+
+  return rows
+    .map(function(row) { return Array.isArray(row) ? row[0] : null; })
+    .filter(function(value) { return value !== null && value !== undefined; });
+}
+
+async function readFilePreview(rootDir, relativePath) {
+  var targetPath = toSafeAbsolute(rootDir, relativePath);
+  var content = await fs.readFile(targetPath, 'utf8');
+  return {
+    path: relativePath,
+    absolutePath: targetPath,
+    content: content,
+  };
+}
+
+async function getCodex(proxyUrl) {
+  var mod = await import('@openai/codex-sdk');
+  var env = Object.assign({}, process.env, {
+    HTTP_PROXY: proxyUrl,
+    HTTPS_PROXY: proxyUrl,
+    ALL_PROXY: proxyUrl,
+  });
+  return new mod.Codex({ env: env });
+}
+
+function resolveCodexProxy(proxyValue) {
+  return String(proxyValue || process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.ALL_PROXY || DEFAULT_PROXY || '').trim();
+}
+
+async function withHeartbeat(scope, stage, context, task) {
+  var startedAt = Date.now();
+  console.log(scope, stage + ' started', context);
+  var timer = setInterval(function() {
+    console.log(scope, stage + ' waiting', Object.assign({}, context, { elapsedMs: Date.now() - startedAt }));
+  }, 5000);
+  if (typeof timer.unref === 'function') {
+    timer.unref();
+  }
+  try {
+    var result = await task();
+    console.log(scope, stage + ' completed', Object.assign({}, context, { elapsedMs: Date.now() - startedAt }));
+    return result;
+  } catch (error) {
+    console.error(scope, stage + ' failed', Object.assign({}, context, {
+      elapsedMs: Date.now() - startedAt,
+      error: error instanceof Error ? error.message : String(error),
+    }));
+    throw error;
+  } finally {
+    clearInterval(timer);
+  }
+}
+
+function truncateConsoleText(value, maxLength) {
+  var text = String(value || '').replace(/\r\n/g, '\n');
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return text.slice(0, maxLength) + '\n...[truncated]';
+}
+
+function extractCodexEventText(event) {
+  if (!event || typeof event !== 'object') {
+    return '';
+  }
+  if (typeof event.text === 'string' && event.text.trim()) {
+    return event.text;
+  }
+  if (typeof event.delta === 'string' && event.delta.trim()) {
+    return event.delta;
+  }
+  if (event.item && typeof event.item.text === 'string' && event.item.text.trim()) {
+    return event.item.text;
+  }
+  if (event.item && typeof event.item.delta === 'string' && event.item.delta.trim()) {
+    return event.item.delta;
+  }
+  if (event.message && typeof event.message === 'string' && event.message.trim()) {
+    return event.message;
+  }
+  return '';
+}
+
+function buildCodexEventMeta(event) {
+  if (!event || typeof event !== 'object') {
+    return {};
+  }
+  var meta = {};
+  if (event.type) {
+    meta.type = event.type;
+  }
+  if (event.thread_id) {
+    meta.threadId = event.thread_id;
+  }
+  if (event.item && event.item.type) {
+    meta.itemType = event.item.type;
+  }
+  if (event.item && event.item.id) {
+    meta.itemId = event.item.id;
+  }
+  if (event.usage) {
+    meta.usage = event.usage;
+  }
+  if (event.error && event.error.message) {
+    meta.error = event.error.message;
+  }
+  return meta;
+}
+
+function logCodexEvent(scope, stage, context, event) {
+  var meta = Object.assign({}, context, buildCodexEventMeta(event));
+  console.log(scope, stage + ' event', meta);
+  var text = extractCodexEventText(event);
+  if (text) {
+    console.log(scope, stage + ' output:\n' + truncateConsoleText(text, 4000));
+  }
+}
+
+async function runCodexTurnWithStreaming(thread, prompt, scope, stage, context) {
+  var startedAt = Date.now();
+  var lastEventAt = startedAt;
+  var finalResponse = '';
+  var usage = null;
+  console.log(scope, stage + ' started', context);
+  var timer = setInterval(function() {
+    console.log(scope, stage + ' waiting', Object.assign({}, context, {
+      elapsedMs: Date.now() - startedAt,
+      idleMs: Date.now() - lastEventAt,
+    }));
+  }, 5000);
+  if (typeof timer.unref === 'function') {
+    timer.unref();
+  }
+  try {
+    var stream = await thread.runStreamed(prompt);
+    for await (var event of stream.events) {
+      lastEventAt = Date.now();
+      logCodexEvent(scope, stage, context, event);
+      if (event.type === 'item.completed' && event.item && event.item.type === 'agent_message') {
+        finalResponse = event.item.text || finalResponse;
+      } else if (event.type === 'turn.completed') {
+        usage = event.usage || null;
+      } else if (event.type === 'turn.failed') {
+        throw new Error(event.error && event.error.message ? event.error.message : 'Codex turn failed');
+      }
+    }
+    console.log(scope, stage + ' completed', Object.assign({}, context, {
+      elapsedMs: Date.now() - startedAt,
+      usage: usage,
+      responseLength: finalResponse.length,
+    }));
+    return {
+      finalResponse: finalResponse,
+      usage: usage,
+    };
+  } catch (error) {
+    console.error(scope, stage + ' failed', Object.assign({}, context, {
+      elapsedMs: Date.now() - startedAt,
+      error: error instanceof Error ? error.message : String(error),
+    }));
+    throw error;
+  } finally {
+    clearInterval(timer);
+  }
+}
+
+async function runRepairPlan(reportText, reportPath, options) {
+  var proxy = resolveCodexProxy(options.proxy);
+  var logScope = '[backtrace-route][fix-plan]';
+  console.log(logScope, 'creating codex client for generate', { reportPath: reportPath, proxy: proxy });
+  var codex = await withHeartbeat(logScope, 'generate:create-client', { reportPath: reportPath, proxy: proxy }, function() {
+    return getCodex(proxy);
+  });
+  console.log(logScope, 'codex client ready for generate', { reportPath: reportPath, proxy: proxy });
+  var thread = codex.startThread({
+    workingDirectory: options.workdir,
+    skipGitRepoCheck: true,
+    sandboxMode: 'read-only',
+    approvalPolicy: 'never',
+    modelReasoningEffort: 'high',
+  });
+
+  var prompt = [
+    '你是一名资深工程师，现在处于计划模式，只输出修复方案，不执行任何代码修改。',
+    '请根据下面这份崩溃分析报告，生成一个明确的修复方案。',
+    '输出内容请包含以下标题：',
+    '1. 修复目标',
+    '2. 需要修改的文件',
+    '3. 每个文件的具体修改方案',
+    '4. 风险与回归点',
+    '5. 验证方法',
+    '如果需要修改多个文件，请直接列出文件路径。',
+    '对于每个需要修改的文件，必须明确写出：文件路径、文件名、预计修改的起止行号或相邻定位点、变更类型（新增/删除/修改）。',
+    '对于每个变更点，必须给出具体代码内容，分别写明原内容和新内容；如果是新增内容，直接给出新增代码；如果是删除内容，直接给出删除代码。',
+    '如果无法精确确认行号，至少给出函数名、类名、代码片段等可定位信息，并说明是插入到哪里。',
+    '请尽量使用代码块展示代码内容，代码块前先写清楚文件路径、行号范围和变更类型。',
+    '不要执行修改，也不要省略文件路径、文件名、行号信息和具体代码内容。',
+    '',
+    '报告路径：' + reportPath,
+    '',
+    reportText,
+  ].join('\n');
+
+  console.log(logScope, 'starting thread.run for generate', { reportPath: reportPath, threadId: thread.id });
+  var turn = await runCodexTurnWithStreaming(thread, prompt, logScope, 'generate:run-prompt', { reportPath: reportPath, threadId: thread.id });
+  console.log(logScope, 'thread.run finished for generate', { reportPath: reportPath, threadId: thread.id, responseLength: (turn.finalResponse || '').length });
+  return {
+    threadId: thread.id,
+    planText: turn.finalResponse || 'Codex 未返回修复方案。',
+  };
+}
+
+async function applyRepairPlan(reportText, planText, reportPath, options) {
+  var proxy = resolveCodexProxy(options.proxy);
+  var logScope = '[backtrace-route][fix-plan]';
+  console.log(logScope, 'creating codex client for apply', { reportPath: reportPath, proxy: proxy });
+  var codex = await withHeartbeat(logScope, 'apply:create-client', { reportPath: reportPath, proxy: proxy }, function() {
+    return getCodex(proxy);
+  });
+  console.log(logScope, 'codex client ready for apply', { reportPath: reportPath, proxy: proxy });
+  var thread = codex.startThread({
+    workingDirectory: options.workdir,
+    skipGitRepoCheck: true,
+    sandboxMode: 'workspace-write',
+    approvalPolicy: 'never',
+    modelReasoningEffort: 'high',
+  });
+
+  var prompt = [
+    '你是一名资深工程师，现在根据下面已经确认的修复方案，直接在工作目录中实施代码修改。',
+    '请实际修改文件，不要只给建议。',
+    '修改完成后，说明你改了哪些文件、每个文件做了什么修改，以及你进行了哪些验证。',
+    '最后请单独列出所有实际修改过的源码文件路径，每行一个，尽量使用相对工作目录的路径。',
+    '',
+    '分析报告路径：' + reportPath,
+    '',
+    '原始分析报告：',
+    reportText,
+    '',
+    '已确认的修复方案：',
+    planText,
+  ].join('\n');
+
+  console.log(logScope, 'starting thread.run for apply', { reportPath: reportPath, threadId: thread.id });
+  var turn = await runCodexTurnWithStreaming(thread, prompt, logScope, 'apply:run-prompt', { reportPath: reportPath, threadId: thread.id });
+  console.log(logScope, 'thread.run finished for apply', { reportPath: reportPath, threadId: thread.id, responseLength: (turn.finalResponse || '').length });
+  return {
+    threadId: thread.id,
+    resultText: turn.finalResponse || 'Codex 未返回应用结果。',
+  };
+}
+
+router.post('/query/fingerprints', async function(req, res) {
+  var body = req.body || {};
+  var queryUrl = body.queryUrl || DEFAULT_QUERY_URL;
+  var from = String(body.from || '1');
+  var to = String(body.to || Math.floor(Date.now() / 1000));
+  var offset = Number(body.offset || 0);
+  var limit = Number(body.limit || 10);
+
+  try {
+    var token = await loginBacktraceSession(queryUrl);
+    var queryBody = {
+      group: ['fingerprint'],
+      offset: offset,
+      limit: limit,
+      filter: [
+        {
+          timestamp: [
+            ['at-most', String(to)],
+            ['at-least', String(from)],
+          ],
+        },
+      ],
+    };
+
+    var payload = await requestBacktraceQuery(queryUrl, token, queryBody);
+    return res.json({
+      ok: true,
+      totalRows: payload && payload._ && payload._.runtime && payload._.runtime.filter ? payload._.runtime.filter.rows : 0,
+      totalGroups: payload && payload.response && payload.response.cardinalities && payload.response.cardinalities.pagination ? payload.response.cardinalities.pagination.groups : 0,
+      fingerprints: extractGroupFingerprints(payload),
+      raw: payload,
+    });
+  } catch (error) {
+    return res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+router.post('/query/objects', async function(req, res) {
+  var body = req.body || {};
+  var queryUrl = body.queryUrl || DEFAULT_QUERY_URL;
+  var fingerprint = String(body.fingerprint || '').trim();
+  var from = String(body.from || '1');
+  var to = String(body.to || Math.floor(Date.now() / 1000));
+  var offset = Number(body.offset || 0);
+  var limit = Number(body.limit || 10);
+
+  if (!fingerprint) {
+    return res.status(400).json({ ok: false, error: 'fingerprint is required' });
+  }
+
+  try {
+    var token = await loginBacktraceSession(queryUrl);
+    var queryBody = {
+      select: ['fingerprint'],
+      offset: offset,
+      limit: limit,
+      filter: [
+        {
+          fingerprint: [
+            ['contains', fingerprint],
+          ],
+          timestamp: [
+            ['at-most', String(to)],
+            ['at-least', String(from)],
+          ],
+        },
+      ],
+    };
+
+    var payload = await requestBacktraceQuery(queryUrl, token, queryBody);
+    var decimalIds = extractObjectIds(payload && payload.response ? payload.response.objects : []);
+    return res.json({
+      ok: true,
+      totalRows: payload && payload._ && payload._.runtime && payload._.runtime.filter ? payload._.runtime.filter.rows : 0,
+      fingerprint: fingerprint,
+      objectIds: decimalIds.map(function(value) {
+        return { decimal: value, hex: toHexObjectId(value) };
+      }),
+      raw: payload,
+    });
+  } catch (error) {
+    return res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+router.get('/files/index', async function(req, res) {
+  try {
+    var directories = await listTopLevelMergedDirectories();
+    return res.json({ ok: true, directories: directories });
+  } catch (error) {
+    return res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+router.get('/files/list', async function(req, res) {
+  var topPath = String(req.query.path || '');
+  var logDir = String(req.query.logDir || '');
+
+  try {
+    var logDirectories = (await listImmediateDirectories(FINGERPRINTS_ROOT, path.join(topPath, 'logs'))).sort(function(a, b) { return a.name.localeCompare(b.name); });
+    var selectedLogDir = logDir || (logDirectories[0] ? logDirectories[0].name : '');
+    var logFiles = selectedLogDir ? await listImmediateFiles(FINGERPRINTS_ROOT, path.join(topPath, 'logs', selectedLogDir)) : [];
+    var reportFiles = await listImmediateFiles(FINGERPRINTS_ROOT, path.join(topPath, 'reports'));
+    var repairStatus = await readRepairStatus(topPath);
+    var hasCompletedRepair = !!(repairStatus && repairStatus.completed);
+    return res.json({
+      ok: true,
+      path: topPath,
+      logDirectories: logDirectories,
+      selectedLogDir: selectedLogDir,
+      logFiles: logFiles,
+      reportFiles: reportFiles,
+      reportStatus: buildFingerprintStatus(reportFiles.length > 0, hasCompletedRepair),
+      hasCompletedRepair: hasCompletedRepair,
+    });
+  } catch (error) {
+    return res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+router.get('/files/content', async function(req, res) {
+  var kind = req.query.kind;
+  var relativePath = req.query.path;
+  var rootDir = kind === 'report' || kind === 'logs' ? FINGERPRINTS_ROOT : '';
+
+  if (!rootDir || !relativePath) {
+    return res.status(400).json({ ok: false, error: 'kind and path are required' });
+  }
+
+  try {
+    var file = await readFilePreview(rootDir, relativePath);
+    return res.json({ ok: true, kind: kind, file: file });
+  } catch (error) {
+    return res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+router.get('/files/download', async function(req, res) {
+  var kind = req.query.kind;
+  var relativePath = req.query.path;
+  var rootDir = kind === 'report' || kind === 'logs' ? FINGERPRINTS_ROOT : '';
+
+  if (!rootDir || !relativePath) {
+    return res.status(400).json({ ok: false, error: 'kind and path are required' });
+  }
+
+  try {
+    var targetPath = toSafeAbsolute(rootDir, relativePath);
+    return res.download(targetPath, path.basename(targetPath));
+  } catch (error) {
+    return res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+router.post('/fix-plan/generate', async function(req, res) {
+  var body = req.body || {};
+  var reportPath = body.reportPath;
+  console.log('[backtrace-route][fix-plan] generate requested', { reportPath: reportPath });
+  if (!reportPath) {
+    return res.status(400).json({ ok: false, error: 'reportPath is required' });
+  }
+
+  try {
+    console.log('[backtrace-route][fix-plan] starting codex plan generation', {
+      reportPath: reportPath,
+      proxy: resolveCodexProxyShared(body.proxy),
+    });
+    var result = await generateRepairPlanShared({
+      reportPath: reportPath,
+    }, {
+      rootDir: ROOT_DIR,
+      fingerprintsRoot: FINGERPRINTS_ROOT,
+      workdir: body.workdir || DEFAULT_WORKDIR,
+      proxy: resolveCodexProxyShared(body.proxy),
+    });
+    console.log('[backtrace-route][fix-plan] codex plan generation completed', { reportPath: reportPath, repairVersion: result.repairVersion, threadId: result.threadId, repairPlanPath: result.repairPlanPath });
+    return res.json(result);
+  } catch (error) {
+    console.error('[backtrace-route][fix-plan] generate failed', { reportPath: reportPath, error: error instanceof Error ? error.message : String(error) });
+    return res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+router.post('/fix-plan/apply', async function(req, res) {
+  var body = req.body || {};
+  var reportPath = body.reportPath;
+  var planText = body.planText;
+  if (!reportPath || !planText) {
+    return res.status(400).json({ ok: false, error: 'reportPath and planText are required' });
+  }
+
+  try {
+    console.log('[backtrace-route][fix-plan] starting codex apply generation', {
+      reportPath: reportPath,
+      repairVersion: body.repairVersion,
+      proxy: resolveCodexProxyShared(body.proxy),
+    });
+    var result = await applyRepairPlanShared({
+      reportPath: reportPath,
+      planText: planText,
+      repairVersion: body.repairVersion,
+      repairPlanPath: body.repairPlanPath,
+    }, {
+      rootDir: ROOT_DIR,
+      fingerprintsRoot: FINGERPRINTS_ROOT,
+      workdir: body.workdir || DEFAULT_WORKDIR,
+      proxy: resolveCodexProxyShared(body.proxy),
+    });
+    return res.json(result);
+  } catch (error) {
+    return res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+router.post('/run', async function(req, res) {
+  var body = req.body || {};
+  var command = body.command || 'collect-all';
+  var tool = new BacktraceCodexTool();
+
+  try {
+    var result = await tool.run(command, body);
+    return res.json({ ok: true, command: command, result: result });
+  } catch (error) {
+    return res.status(500).json({ ok: false, command: command, error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+router.get('/list', async function(req, res) {
+  var tool = new BacktraceCodexTool();
+  var overrides = {
+    from: req.query.from,
+    to: req.query.to,
+    limit: req.query.limit,
+    offset: req.query.offset,
+    select: req.query.select,
+  };
+
+  try {
+    var result = await tool.list(overrides);
+    return res.json({ ok: true, command: 'list', result: result });
+  } catch (error) {
+    return res.status(500).json({ ok: false, command: 'list', error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+module.exports = router;
+
+
+
+
+
+
+