backtrace-console 0.0.1 → 0.0.2

package/routes/backtrace-chat.js

@@ -0,0 +1,389 @@
+var express = require('express');
+var fs = require('node:fs/promises');
+var path = require('node:path');
+var os = require('node:os');
+var shared = require('./backtrace-shared');
+
+var router = express.Router();
+
+async function getChatSessionIds(relativeFingerprintPath) {
+  var entries = await shared.listImmediateFiles(shared.FINGERPRINTS_ROOT, path.join(relativeFingerprintPath, 'messages'));
+  return entries.filter(function(entry) { return entry.ext === '.json'; })
+    .map(function(entry) { return path.basename(entry.name, '.json'); })
+    .sort(function(a, b) { return b.localeCompare(a); });
+}
+
+function buildContextMessage(meta) {
+  var errorMessage = meta && meta.errorMessage ? meta.errorMessage : '-';
+  var classifiers = meta && meta.classifiers ? meta.classifiers : '-';
+  return '你是一个非常专业并资深的C++开发工程师和UE工程师。当前崩溃的关键信息如下：\n'
+    + 'Error Message: ' + errorMessage + '\n'
+    + 'Classifiers: ' + classifiers + '\n\n'
+    + '请结合这些上下文，帮助用户定位问题并给出修复建议。';
+}
+
+async function readChatSession(relativeFingerprintPath, sessionId) {
+  var relativePath = path.join(relativeFingerprintPath, 'messages', sessionId + '.json');
+  var absolutePath = shared.toSafeAbsolute(shared.FINGERPRINTS_ROOT, relativePath);
+  var raw = await fs.readFile(absolutePath, 'utf8').catch(function(error) {
+    if (error && error.code === 'ENOENT') return '';
+    throw error;
+  });
+  return raw ? JSON.parse(raw) : null;
+}
+
+async function writeChatSession(relativeFingerprintPath, session) {
+  var messagesDir = shared.toSafeAbsolute(shared.FINGERPRINTS_ROOT, path.join(relativeFingerprintPath, 'messages'));
+  var absolutePath = shared.toSafeAbsolute(shared.FINGERPRINTS_ROOT, path.join(relativeFingerprintPath, 'messages', session.sessionId + '.json'));
+  await fs.mkdir(messagesDir, { recursive: true });
+  await fs.writeFile(absolutePath, JSON.stringify(session, null, 2), 'utf8');
+  return absolutePath;
+}
+
+async function listChatSessions(relativeFingerprintPath) {
+  var sessionIds = await getChatSessionIds(relativeFingerprintPath);
+  var sessions = [];
+  for (var i = 0; i < sessionIds.length; i += 1) {
+    var session = await readChatSession(relativeFingerprintPath, sessionIds[i]);
+    if (!session) continue;
+    sessions.push({
+      sessionId: session.sessionId,
+      threadId: session.threadId || null,
+      title: session.title || session.sessionId,
+      createdAt: session.createdAt || null,
+      updatedAt: session.updatedAt || session.createdAt || null,
+      messageCount: Array.isArray(session.messages) ? session.messages.length : 0,
+    });
+  }
+  return sessions;
+}
+
+async function createChatSession(relativeFingerprintPath) {
+  var meta = await shared.readFingerprintMeta(relativeFingerprintPath);
+  if (!meta) throw new Error('fingerprint not found');
+  var now = new Date();
+  var sessionId = shared.formatChatSessionId(now);
+  var session = {
+    sessionId: sessionId,
+    fingerprint: relativeFingerprintPath,
+    threadId: null,
+    createdAt: now.toISOString(),
+    updatedAt: now.toISOString(),
+    title: '新对话 ' + sessionId,
+    messages: [{ kind: 'context', role: 'system', text: buildContextMessage(meta), createdAt: now.toISOString() }],
+  };
+  await writeChatSession(relativeFingerprintPath, session);
+  return session;
+}
+
+async function appendChatSessionEvent(relativeFingerprintPath, sessionId, event) {
+  var session = await readChatSession(relativeFingerprintPath, sessionId);
+  if (!session) throw new Error('chat session not found');
+  if (!Array.isArray(session.messages)) session.messages = [];
+  session.messages.push(event);
+  session.updatedAt = new Date().toISOString();
+  if ((!session.title || session.title.indexOf('新对话') === 0) && event.role === 'user' && event.text) {
+    session.title = String(event.text).slice(0, 80);
+  }
+  await writeChatSession(relativeFingerprintPath, session);
+  return session;
+}
+
+async function updateChatSessionThread(relativeFingerprintPath, sessionId, threadId) {
+  var session = await readChatSession(relativeFingerprintPath, sessionId);
+  if (!session) throw new Error('chat session not found');
+  session.threadId = typeof threadId === 'string' ? threadId : null;
+  session.updatedAt = new Date().toISOString();
+  await writeChatSession(relativeFingerprintPath, session);
+  return session;
+}
+
+async function upsertAgentDraftMessage(relativeFingerprintPath, sessionId, draftId, text, extraMeta) {
+  var session = await readChatSession(relativeFingerprintPath, sessionId);
+  if (!session) throw new Error('chat session not found');
+  if (!Array.isArray(session.messages)) session.messages = [];
+  var now = new Date().toISOString();
+  var draft = session.messages.find(function(message) {
+    return message && message.kind === 'agent_draft' && message.meta && message.meta.draftId === draftId;
+  });
+  if (!draft) {
+    draft = { kind: 'agent_draft', role: 'agent', text: '', createdAt: now, updatedAt: now, meta: { draftId: draftId, status: 'streaming' } };
+    session.messages.push(draft);
+  }
+  draft.text = String(text || '');
+  draft.updatedAt = now;
+  draft.meta = Object.assign({}, draft.meta || {}, extraMeta || {}, { draftId: draftId, status: 'streaming' });
+  session.updatedAt = now;
+  await writeChatSession(relativeFingerprintPath, session);
+  return session;
+}
+
+async function finalizeAgentDraftMessage(relativeFingerprintPath, sessionId, draftId, text) {
+  var session = await readChatSession(relativeFingerprintPath, sessionId);
+  if (!session) throw new Error('chat session not found');
+  if (!Array.isArray(session.messages)) session.messages = [];
+  var now = new Date().toISOString();
+  var draft = session.messages.find(function(message) {
+    return message && message.kind === 'agent_draft' && message.meta && message.meta.draftId === draftId;
+  });
+  if (!draft) {
+    draft = { createdAt: now, meta: { draftId: draftId } };
+    session.messages.push(draft);
+  }
+  draft.kind = 'message';
+  draft.role = 'agent';
+  draft.text = String(text || '');
+  draft.updatedAt = now;
+  draft.meta = Object.assign({}, draft.meta || {}, { draftId: draftId, status: 'completed' });
+  session.updatedAt = now;
+  await writeChatSession(relativeFingerprintPath, session);
+  return session;
+}
+
+function buildCodexEventMeta(event) {
+  var meta = {};
+  if (!event || typeof event !== 'object') return 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 extractCodexToolArgs(event) {
+  if (!event || !event.item) return null;
+  return event.item.arguments || event.item.input || event.item.args || null;
+}
+
+function extractCodexToolResult(event) {
+  if (!event || !event.item) return '';
+  return event.item.result || event.item.output || event.item.text || '';
+}
+
+function extractCodexEventText(event) {
+  if (!event || typeof event !== 'object') return '';
+  return event.text || event.delta || (event.item && (event.item.text || event.item.delta)) || event.message || '';
+}
+
+function formatToolCompletedResult(toolName, args, result, eventMeta) {
+  var text = result;
+  if (text && typeof text === 'string' && text.trim() && text.trim() !== toolName) return text;
+  var parts = [];
+  if (args) parts.push('args: ' + (typeof args === 'string' ? args : JSON.stringify(args, null, 2)));
+  if (eventMeta && eventMeta.error) parts.push('error: ' + eventMeta.error);
+  return parts.length > 0 ? parts.join('\n\n') : (text || toolName);
+}
+
+router.get('/chat-sessions', async function(req, res) {
+  var fingerprint = String(req.query.fingerprint || '').trim();
+  if (!fingerprint) return res.status(400).json({ ok: false, error: 'fingerprint is required' });
+  try {
+    var relativeFingerprintPath = shared.normalizeFingerprintPath(fingerprint);
+    var meta = await shared.readFingerprintMeta(relativeFingerprintPath);
+    if (!meta) return res.status(404).json({ ok: false, error: 'fingerprint not found' });
+    var sessions = await listChatSessions(relativeFingerprintPath);
+    var activeSessionId = meta.activeSessionId || null;
+    if (activeSessionId && !sessions.some(function(session) { return session.sessionId === activeSessionId; })) {
+      activeSessionId = null;
+    }
+    return res.json({ ok: true, fingerprint: fingerprint, activeSessionId: activeSessionId, sessions: sessions });
+  } catch (error) {
+    return res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+router.get('/chat-session', async function(req, res) {
+  var fingerprint = String(req.query.fingerprint || '').trim();
+  var sessionId = String(req.query.sessionId || '').trim();
+  if (!fingerprint || !sessionId) return res.status(400).json({ ok: false, error: 'fingerprint and sessionId are required' });
+  try {
+    var session = await readChatSession(shared.normalizeFingerprintPath(fingerprint), sessionId);
+    if (!session) return res.status(404).json({ ok: false, error: 'chat session not found' });
+    return res.json({ ok: true, fingerprint: fingerprint, session: session });
+  } catch (error) {
+    return res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+router.post('/chat-session/create', async function(req, res) {
+  var fingerprint = String((req.body || {}).fingerprint || '').trim();
+  if (!fingerprint) return res.status(400).json({ ok: false, error: 'fingerprint is required' });
+  try {
+    var relativeFingerprintPath = shared.normalizeFingerprintPath(fingerprint);
+    var session = await createChatSession(relativeFingerprintPath);
+    var meta = await shared.readFingerprintMeta(relativeFingerprintPath);
+    meta.activeSessionId = session.sessionId;
+    meta.threadId = null;
+    await shared.writeFingerprintMeta(relativeFingerprintPath, meta);
+    return res.json({ ok: true, fingerprint: fingerprint, session: session });
+  } catch (error) {
+    return res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+router.post('/chat', async function(req, res) {
+  var body = req.body || {};
+  var prompt = body.prompt;
+  var threadId = body.threadId;
+  var fingerprint = String(body.fingerprint || '').trim();
+  var sessionId = String(body.sessionId || '').trim();
+  var images = Array.isArray(body.images) ? body.images : [];
+  var relativeFingerprintPath = '';
+  var draftId = '';
+  var finalResponse = '';
+  var tempImagePaths = [];
+  if (!prompt) return res.status(400).json({ ok: false, error: 'prompt is required' });
+  if (!fingerprint || !sessionId) return res.status(400).json({ ok: false, error: 'fingerprint and sessionId are required' });
+  try {
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.write('event: ping\ndata: \n\n');
+
+    relativeFingerprintPath = shared.normalizeFingerprintPath(fingerprint);
+    var existingMeta = await shared.readFingerprintMeta(relativeFingerprintPath);
+    if (!existingMeta) throw new Error('fingerprint not found');
+    var session = await readChatSession(relativeFingerprintPath, sessionId);
+    if (!session) throw new Error('chat session not found');
+    threadId = threadId || session.threadId || existingMeta.threadId;
+
+    await appendChatSessionEvent(relativeFingerprintPath, sessionId, {
+      kind: 'message',
+      role: 'user',
+      text: body.userMessage || prompt,
+      createdAt: new Date().toISOString(),
+      meta: images.length > 0 ? { imageCount: images.length } : null,
+    });
+
+    // 处理图片：base64 解码写到临时文件
+    for (var i = 0; i < images.length; i++) {
+      var img = images[i];
+      if (!img.data || !img.mimeType) continue;
+      var ext = img.mimeType.split('/')[1] || 'png';
+      var tempPath = path.join(os.tmpdir(), 'codex-image-' + Date.now() + '-' + i + '.' + ext);
+      var buffer = Buffer.from(img.data, 'base64');
+      await fs.writeFile(tempPath, buffer);
+      tempImagePaths.push(tempPath);
+    }
+
+    var workdir = body.workdir || shared.DEFAULT_WORKDIR;
+    var proxy = shared.resolveCodexProxy(body.proxy);
+    var mod = await import('@openai/codex-sdk');
+    var codex = new mod.Codex({ env: Object.assign({}, process.env, { HTTP_PROXY: proxy, HTTPS_PROXY: proxy, ALL_PROXY: proxy }) });
+    var thread = threadId ? codex.resumeThread(threadId, {
+      workingDirectory: workdir,
+      skipGitRepoCheck: true,
+      sandboxMode: 'workspace-write',
+      approvalPolicy: 'never',
+      modelReasoningEffort: 'high',
+    }) : codex.startThread({
+      workingDirectory: workdir,
+      skipGitRepoCheck: true,
+      sandboxMode: 'workspace-write',
+      approvalPolicy: 'never',
+      modelReasoningEffort: 'high',
+    });
+
+    // 构造 UserInput[]：文本 + 图片
+    var userInput = [{ type: 'text', text: shared.buildCodexChatPrompt(prompt, { workdir: workdir }) }];
+    for (var j = 0; j < tempImagePaths.length; j++) {
+      userInput.push({ type: 'local_image', path: tempImagePaths[j] });
+    }
+
+    var stream = await thread.runStreamed(userInput);
+    finalResponse = '';
+    var lastSentText = '';
+    var toolBuffers = {};
+    draftId = 'draft-' + Date.now() + '-' + Math.random().toString(16).slice(2, 10);
+    var lastDraftWriteAt = 0;
+    await upsertAgentDraftMessage(relativeFingerprintPath, sessionId, draftId, '', { threadId: thread.id });
+
+    function writeSse(payload) {
+      res.write('data: ' + JSON.stringify(payload) + '\n\n');
+    }
+    async function persistDraft(force) {
+      var now = Date.now();
+      if (!force && now - lastDraftWriteAt < 600) return;
+      lastDraftWriteAt = now;
+      await upsertAgentDraftMessage(relativeFingerprintPath, sessionId, draftId, finalResponse, { threadId: thread.id });
+    }
+    function writeSseText(nextText, replace) {
+      if (typeof nextText !== 'string') return;
+      if (!replace && nextText.startsWith(lastSentText)) {
+        var deltaText = nextText.substring(lastSentText.length);
+        if (!deltaText) return;
+        lastSentText = nextText;
+        writeSse({ kind: 'agent_text', text: deltaText, replace: false });
+        return;
+      }
+      lastSentText = nextText;
+      writeSse({ kind: 'agent_text', text: nextText, replace: true });
+    }
+
+    for await (var event of stream.events) {
+      var eventMeta = buildCodexEventMeta(event);
+      if (event.type === 'item.stream.delta' || event.type === 'text.delta' || event.type === 'turn.stream.delta') {
+        var delta = event.delta || (event.item && event.item.delta);
+        if (typeof delta === 'string') {
+          finalResponse += delta;
+          writeSseText(finalResponse, false);
+          await persistDraft(false);
+        }
+      } else if (event.type === 'item.completed' && event.item && event.item.type === 'agent_message' && event.item.text) {
+        finalResponse = event.item.text;
+        writeSseText(finalResponse, false);
+        await persistDraft(true);
+      } else if (event.type === 'turn.failed') {
+        throw new Error(event.error && event.error.message ? event.error.message : 'Codex turn failed');
+      }
+
+      if (event.item && event.item.type && event.item.type !== 'agent_message' && event.item.type !== 'user_message') {
+        var toolId = event.item.id || eventMeta.itemId || ('tool-' + Date.now());
+        var toolText = extractCodexEventText(event);
+        if (!toolBuffers[toolId]) {
+          toolBuffers[toolId] = { itemType: event.item.type, text: '', args: extractCodexToolArgs(event), result: extractCodexToolResult(event) };
+          await appendChatSessionEvent(relativeFingerprintPath, sessionId, { kind: 'tool_call_started', role: 'tool', text: event.item.type, createdAt: new Date().toISOString(), meta: Object.assign({ args: toolBuffers[toolId].args }, eventMeta) });
+          writeSse({ kind: 'tool_call_started', toolId: toolId, toolName: event.item.type, args: toolBuffers[toolId].args, text: event.item.type, meta: eventMeta });
+        }
+        if (extractCodexToolResult(event)) toolBuffers[toolId].result = extractCodexToolResult(event);
+        if (toolText) {
+          toolBuffers[toolId].text += toolText;
+          if (!toolBuffers[toolId].result) toolBuffers[toolId].result = toolBuffers[toolId].text;
+          await appendChatSessionEvent(relativeFingerprintPath, sessionId, { kind: 'tool_call_output', role: 'tool', text: toolText, createdAt: new Date().toISOString(), meta: Object.assign({ toolId: toolId }, eventMeta) });
+          writeSse({ kind: 'tool_call_output', toolId: toolId, toolName: event.item.type, output: toolBuffers[toolId].text, text: toolText, meta: eventMeta });
+        }
+        if (event.type === 'item.completed') {
+          var completedResult = formatToolCompletedResult(event.item.type, toolBuffers[toolId].args, toolBuffers[toolId].result || toolBuffers[toolId].text, eventMeta);
+          await appendChatSessionEvent(relativeFingerprintPath, sessionId, { kind: 'tool_call_completed', role: 'tool', text: completedResult, createdAt: new Date().toISOString(), meta: Object.assign({ toolId: toolId }, eventMeta) });
+          writeSse({ kind: 'tool_call_completed', toolId: toolId, toolName: event.item.type, result: completedResult, text: completedResult, meta: eventMeta });
+        }
+      }
+    }
+
+    await finalizeAgentDraftMessage(relativeFingerprintPath, sessionId, draftId, finalResponse);
+    await updateChatSessionThread(relativeFingerprintPath, sessionId, thread.id);
+    existingMeta.threadId = thread.id;
+    existingMeta.activeSessionId = sessionId;
+    await shared.writeFingerprintMeta(relativeFingerprintPath, existingMeta);
+    writeSse({ kind: 'done', threadId: thread.id, sessionId: sessionId });
+    res.end();
+  } catch (error) {
+    if (relativeFingerprintPath && sessionId && draftId) {
+      await upsertAgentDraftMessage(relativeFingerprintPath, sessionId, draftId, finalResponse, {
+        status: 'interrupted',
+        error: error instanceof Error ? error.message : String(error),
+      }).catch(function() {});
+    }
+    res.write('event: error\ndata: ' + JSON.stringify({ error: error instanceof Error ? error.message : String(error) }) + '\n\n');
+    res.end();
+  } finally {
+    // 清理临时图片文件
+    for (var k = 0; k < tempImagePaths.length; k++) {
+      fs.unlink(tempImagePaths[k]).catch(function() {});
+    }
+  }
+});
+
+module.exports = router;

package/routes/backtrace-files.js

@@ -0,0 +1,88 @@
+var express = require('express');
+var path = require('node:path');
+var shared = require('./backtrace-shared');
+
+var router = express.Router();
+
+router.get('/files/index', async function(req, res) {
+  try {
+    var directories = await shared.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 shared.listImmediateDirectories(shared.FINGERPRINTS_ROOT, path.join(topPath, 'logs'));
+    var selectedLogDir = logDir || (logDirectories[0] ? logDirectories[0].name : '');
+    var logFiles = selectedLogDir ? await shared.listImmediateFiles(shared.FINGERPRINTS_ROOT, path.join(topPath, 'logs', selectedLogDir)) : [];
+    var reportFiles = await shared.listImmediateFiles(shared.FINGERPRINTS_ROOT, path.join(topPath, 'reports'));
+    var repairStatus = await shared.readRepairStatus(topPath);
+    var hasCompletedRepair = !!(repairStatus && repairStatus.completed);
+    return res.json({
+      ok: true,
+      path: topPath,
+      selectedLogDir: selectedLogDir,
+      logDirectories: logDirectories,
+      logFiles: logFiles,
+      reportFiles: reportFiles,
+      reportStatus: shared.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' ? shared.FINGERPRINTS_ROOT : '';
+  if (!rootDir || !relativePath) {
+    return res.status(400).json({ ok: false, error: 'kind and path are required' });
+  }
+  try {
+    var targetPath = shared.toSafeAbsolute(rootDir, relativePath);
+    var content = await require('node:fs/promises').readFile(targetPath, 'utf8');
+    return res.json({ ok: true, kind: kind, path: relativePath, content: content });
+  } catch (error) {
+    return res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+router.get('/files/download', function(req, res) {
+  var kind = req.query.kind;
+  var relativePath = req.query.path;
+  var rootDir = kind === 'report' || kind === 'logs' ? shared.FINGERPRINTS_ROOT : '';
+  if (!rootDir || !relativePath) {
+    return res.status(400).json({ ok: false, error: 'kind and path are required' });
+  }
+  try {
+    var targetPath = shared.toSafeAbsolute(rootDir, relativePath);
+    return res.download(targetPath);
+  } catch (error) {
+    return res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+router.get('/files/view', function(req, res) {
+  var kind = req.query.kind;
+  var relativePath = req.query.path;
+  var rootDir = kind === 'report' || kind === 'logs' ? shared.FINGERPRINTS_ROOT : '';
+  if (!rootDir || !relativePath) {
+    return res.status(400).json({ ok: false, error: 'kind and path are required' });
+  }
+  try {
+    var targetPath = shared.toSafeAbsolute(rootDir, relativePath);
+    res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+    return res.sendFile(targetPath);
+  } catch (error) {
+    return res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+module.exports = router;

package/routes/backtrace-fix-plan.js

@@ -0,0 +1,53 @@
+var express = require('express');
+var RepairModule = require('../lib/backtrace/repair');
+var shared = require('./backtrace-shared');
+
+var router = express.Router();
+
+router.post('/fix-plan/generate', async function(req, res) {
+  var body = req.body || {};
+  var reportPath = body.reportPath;
+  if (!reportPath) {
+    return res.status(400).json({ ok: false, error: 'reportPath is required' });
+  }
+  try {
+    var result = await RepairModule.generateRepairPlan({
+      reportPath: reportPath,
+    }, {
+      rootDir: shared.ROOT_DIR,
+      fingerprintsRoot: shared.FINGERPRINTS_ROOT,
+      workdir: body.workdir || shared.DEFAULT_WORKDIR,
+      proxy: shared.resolveCodexProxy(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('/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 {
+    var result = await RepairModule.applyRepairPlan({
+      reportPath: reportPath,
+      planText: planText,
+      repairVersion: body.repairVersion,
+      repairPlanPath: body.repairPlanPath,
+    }, {
+      rootDir: shared.ROOT_DIR,
+      fingerprintsRoot: shared.FINGERPRINTS_ROOT,
+      workdir: body.workdir || shared.DEFAULT_WORKDIR,
+      proxy: shared.resolveCodexProxy(body.proxy),
+    });
+    return res.json(result);
+  } catch (error) {
+    return res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+module.exports = router;

package/routes/backtrace-run.js

@@ -0,0 +1,128 @@
+var express = require('express');
+var fs = require('node:fs/promises');
+var path = require('node:path');
+var BacktraceCodexTool = require('../lib/BacktraceCodexTool').BacktraceCodexTool;
+var { BacktraceSession, downloadItemLogs, fetchAttachmentList } = require('../lib/backtrace/query');
+var { createOptions } = require('../lib/backtrace/options');
+var shared = require('./backtrace-shared');
+
+var router = express.Router();
+
+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('/fingerprint', async function(req, res) {
+  var fingerprint = String(req.query.fingerprint || '').trim();
+  if (!fingerprint) {
+    return res.status(400).json({ ok: false, error: 'fingerprint is required' });
+  }
+  try {
+    var relativeFingerprintPath = shared.normalizeFingerprintPath(fingerprint);
+    var result = await shared.readFingerprintMeta(relativeFingerprintPath);
+    if (!result) {
+      return res.status(404).json({ ok: false, error: 'fingerprint not found' });
+    }
+    var reports = await shared.listFingerprintReports(relativeFingerprintPath);
+    result.reportFiles = reports;
+    result.defaultReportPath = reports.length > 0 ? reports[0].path : '';
+    return res.json({ ok: true, command: 'fingerprint', result: result });
+  } catch (error) {
+    return res.status(500).json({ ok: false, command: 'fingerprint', 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) });
+  }
+});
+
+router.post('/download-object', async function(req, res) {
+  var body = req.body || {};
+  var fp = String(body.fingerprint || '').trim();
+  var objectIdHex = String(body.objectIdHex || '').trim();
+  if (!fp || !objectIdHex) {
+    return res.status(400).json({ ok: false, error: 'fingerprint and objectIdHex are required' });
+  }
+  try {
+    var options = createOptions({ command: 'collect-all', fingerprint: fp });
+    var session = new BacktraceSession(options);
+    await session.login();
+    var item = { objectIdHex: objectIdHex, objectIdDecimal: '', fingerprint: fp, values: { fingerprint: fp } };
+    var result = await downloadItemLogs(session, item, options);
+    return res.json({ ok: true, fingerprint: fp, objectIdHex: objectIdHex, downloadedFiles: result.downloadedFiles, targetDir: result.targetDir });
+  } catch (error) {
+    return res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+router.post('/query-object-attachments', async function(req, res) {
+  var body = req.body || {};
+  var fp = String(body.fingerprint || '').trim();
+  var objectIdHex = String(body.objectIdHex || '').trim();
+  if (!fp || !objectIdHex) {
+    return res.status(400).json({ ok: false, error: 'fingerprint and objectIdHex are required' });
+  }
+  try {
+    var options = createOptions({ command: 'collect-all', fingerprint: fp });
+    var session = new BacktraceSession(options);
+    await session.login();
+
+    // 查询远端附件列表
+    var attachmentResult = await fetchAttachmentList(session, options.queryUrl, objectIdHex);
+    var remoteAttachments = (attachmentResult && attachmentResult.attachments) ? attachmentResult.attachments : [];
+
+    // 读取本地已下载文件
+    var objDir = path.join(shared.FINGERPRINTS_ROOT, fp, 'logs', objectIdHex);
+    var localFiles = await fs.readdir(objDir).catch(function() { return []; });
+    var localFileSet = new Set(localFiles);
+
+    // 合并：逐文件检查本地是否已下载
+    var attachments = remoteAttachments.map(function(att) {
+      return {
+        id: att.id || '',
+        name: att.name || '',
+        size: att.size || 0,
+        content_type: att.content_type || '',
+        downloaded: localFileSet.has(att.name),
+      };
+    });
+
+    // 读取现有 object-meta.json，合并写回
+    var metaPath = path.join(objDir, 'object-meta.json');
+    var existingRaw = await fs.readFile(metaPath, 'utf8').catch(function() { return ''; });
+    var existing = {};
+    if (existingRaw) {
+      try { existing = JSON.parse(existingRaw); } catch (_) { existing = {}; }
+    }
+    var updated = Object.assign({}, existing, { attachments: attachments });
+    await fs.mkdir(objDir, { recursive: true });
+    await fs.writeFile(metaPath, JSON.stringify(updated, null, 2), 'utf8');
+
+    return res.json({ ok: true, fingerprint: fp, objectIdHex: objectIdHex, attachments: attachments });
+  } catch (error) {
+    return res.status(500).json({ ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
+module.exports = router;