cc-viewer 1.9.14 → 1.9.16

package/server/routes/files-content.js

@@ -1,26 +1,36 @@
 // Read-oriented file-access routes (moved verbatim from server.js handleRequest).
-import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync, realpathSync, createReadStream } from 'node:fs';
-import { join, basename, dirname, resolve, sep } from 'node:path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync, realpathSync, createReadStream, readdirSync } from 'node:fs';
+import { join, basename, dirname, resolve, relative, sep } from 'node:path';
+import { homedir } from 'node:os';
 import { isReadAllowed, reasonToStatus } from '../lib/file-access-policy.js';
-import { ERROR_STATUS_MAP } from '../lib/file-api.js';
-import { viewRootOrReply } from '../lib/view-root.js';
+import { ERROR_STATUS_MAP, isPathContained } from '../lib/file-api.js';
+import { listSkills } from '../lib/skills-api.js';
+import { viewRootOrReply, resolveViewRoot } from '../lib/view-root.js';
+import { findSdkSessionByInstance } from '../lib/sdk-session-index.js';
+import { projectKeyForCwd } from '../lib/system-prompt-snapshots.js';
 import { loadWorkspaces } from '../workspace-registry.js';
 import { listLivePtys } from '../pty-manager.js';
 import { reportSwallowed } from '../lib/error-report.js';
 import { discoverClaudeMdCandidates, readCandidateById } from '../lib/claude-md-discovery.js';
 import { getClaudeConfigDir } from '../../findcc.js';
 import { _projectName } from '../interceptor.js';
+import { isAdminReq } from '../lib/is-admin.js';
+import { isSameOriginBrowserRequest } from '../lib/same-origin.js';
 
-// Multi-project (2026-10): project-scoped READ routes resolve the viewed
-// project via the shared viewRootOrReply (?project=). WRITE routes keep the
-// bound root. SYNCHRONOUS: these handlers were sync before multi-project, and
+// Multi-project file operations use the same viewed root for reads and writes.
+// Every file-browser mutation enforces realpath containment in that root;
+// explicit editor sessions retain their existing allowlisted external paths.
 // their tests (and the dispatcher's sync-call convention) assert on res
 // immediately after the call — the override must not async-ify them.
-function _viewRootOrReply(req, res, parsedUrl) {
+// Both reads and writes resolve the viewed project. Absolute editor paths are
+// still governed by the allowlist; browser writes stay within the selected root.
+function _viewRootOrReply(req, res, parsedUrl, bodyProject, bodyInstance) {
   return viewRootOrReply(req, res, parsedUrl, {
     boundCwd: process.env.CCV_PROJECT_DIR || process.cwd(),
     loadWorkspaces,
     listLivePtys,
+    bodyProject,
+    bodyInstance,
   });
 }
 
@@ -167,6 +177,37 @@ function projectMemory(req, res, parsedUrl) {
   projectMemoryEntry(req, res, parsedUrl, respondJson);
 }
 
+// The SDK context snapshot prices MEMORY.md itself, not every linked detail file.
+// Supplement only the index's existing single-segment .md links with a transparent
+// content-length estimate; never allocate the SDK total across unrelated files.
+export function estimateLinkedMemoryTokens(content, dir) {
+  const estimates = {};
+  const MAX_BYTES = 512 * 1024;
+  const MAX_LINKS = 100;
+  if (typeof content !== 'string' || typeof dir !== 'string') return estimates;
+  const links = new Set();
+  for (const match of content.matchAll(/\]\(\s*([^)\s]+\.md)(?:[?#][^)\s]*)?(?:\s+"[^"]*")?\s*\)/gi)) {
+    let name;
+    try { name = decodeURIComponent(match[1].split('#')[0].split('?')[0]); } catch { continue; }
+    if (!name || name.includes('/') || name.includes('\\') || name.includes('\0') || name.startsWith('.')) continue;
+    links.add(name);
+    if (links.size >= MAX_LINKS) break;
+  }
+  let realDir;
+  try { realDir = realpathSync(dir); } catch { return estimates; }
+  const prefix = realDir.endsWith(sep) ? realDir : realDir + sep;
+  for (const name of links) {
+    try {
+      const realFile = realpathSync(join(realDir, name));
+      const stat = statSync(realFile);
+      if (!realFile.startsWith(prefix) || !stat.isFile() || stat.size > MAX_BYTES) continue;
+      if (!isReadAllowed(realFile).ok) continue;
+      estimates[name] = { tokens: Math.ceil(stat.size / 4), source: 'file-content-estimate' };
+    } catch { /* Missing/unreadable links remain without an estimate. */ }
+  }
+  return estimates;
+}
+
 // The entry wraps BOTH the view-root resolution and the read in the endpoint's
 // single error surface (the searchParams-throw defense test asserts a 500 from
 // THIS catch, regardless of which stage throws).
@@ -202,7 +243,9 @@ function projectMemoryWithRoot(req, res, parsedUrl, respondJson, cwd) {
       if (!st.isFile()) return respondJson(400, { error: 'Not a file' });
       if (st.size > MAX_BYTES) return respondJson(413, { error: 'File too large' });
       const content = readFileSync(policy.real, 'utf-8');
-      return respondJson(200, { exists: true, dir, indexPath, content });
+      // Only SDK mode consumes these estimates. PTY keeps the original cheap index read.
+      const memoryTokenEstimates = process.env.CCV_SDK_MODE === '1' ? estimateLinkedMemoryTokens(content, dir) : undefined;
+      return respondJson(200, { exists: true, dir, indexPath, content, memoryTokenEstimates });
     }
 
     // 明细文件: 仅接受单段 basename + .md 后缀
@@ -231,7 +274,7 @@ function projectMemoryWithRoot(req, res, parsedUrl, respondJson, cwd) {
     if (!st.isFile()) return respondJson(400, { error: 'Not a file' });
     if (st.size > MAX_BYTES) return respondJson(413, { error: 'File too large' });
     const content = readFileSync(realFile, 'utf-8');
-    return respondJson(200, { name: fileParam, path: realFile, content });
+    return respondJson(200, { name: fileParam, path: realFile, content, tokens: Math.ceil(Buffer.byteLength(content, 'utf8') / 4), tokenSource: 'file-content-estimate' });
   } catch (err) {
     // 与 /api/file-content 一致：已知 errno（ENOENT/EACCES 等）走 ERROR_STATUS_MAP 映射；
     // 500 时不回显 err.message —— 可能含 ~/.claude/projects/<encoded>/memory/ 路径片段。
@@ -311,13 +354,51 @@ function fileRaw(req, res, parsedUrl) {
   const url = parsedUrl.pathname;
   const method = req.method;
   let reqPath;
-  if (url.startsWith('/api/file-raw/')) {
+  let scopedProject = '';
+  let scopedInstance = '';
+  if (url.startsWith('/api/file-raw/view/')) {
+    const parts = url.slice('/api/file-raw/view/'.length).split('/');
+    let project = '';
+    let instance = '';
+    try {
+      project = decodeURIComponent(parts[0] || '');
+      instance = decodeURIComponent(parts[1] || '');
+      reqPath = decodeURIComponent(parts.slice(2).join('/'));
+    } catch {
+      res.writeHead(400, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Invalid path' }));
+      return;
+    }
+    scopedProject = project;
+    scopedInstance = instance;
+  } else if (url.startsWith('/api/file-raw/')) {
     const tail = parsedUrl.pathname.slice('/api/file-raw/'.length);
     try { reqPath = decodeURIComponent(tail); } catch { reqPath = tail; }
   } else {
     reqPath = parsedUrl.searchParams.get('path');
   }
-  const cwd = _viewRootOrReply(req, res, parsedUrl);
+  let resolvedView = null;
+  if (scopedProject) {
+    resolvedView = resolveViewRoot({
+      projectParam: scopedProject,
+      instanceParam: scopedInstance,
+      boundCwd: process.env.CCV_PROJECT_DIR || process.cwd(),
+      loadWorkspaces,
+      listLivePtys,
+    });
+    // The path already pins its project. A stale/mismatched instance must not
+    // silently redirect it to the bound project or a different workspace.
+    const instanceRecord = scopedInstance ? findSdkSessionByInstance(scopedInstance) : null;
+    const instanceMatches = !scopedInstance || (instanceRecord
+      && (instanceRecord.projectName === scopedProject
+        || projectKeyForCwd(instanceRecord.cwd) === scopedProject));
+    if (!resolvedView.ok || (scopedInstance && !instanceMatches)) {
+      res.writeHead(resolvedView.ok ? 400 : resolvedView.status, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: resolvedView.ok ? 'Project scope mismatch' : resolvedView.error }));
+      return;
+    }
+  }
+  const cwd = resolvedView?.root || _viewRootOrReply(req, res, parsedUrl);
   if (!cwd) return;
   fileRawWithRoot(req, res, parsedUrl, reqPath, cwd, method);
 }
@@ -460,7 +541,11 @@ function fileDownloadWithRoot(req, res, parsedUrl, reqPath, cwd) {
   }
 }
 
-function fileContentPost(req, res) {
+function fileContentPost(req, res, parsedUrl, isLocal) {
+  // The shared read root keeps its raw cwd for projectMemory's store-key
+  // encoding. Normalize only this mutation's containment comparisons.
+  let writeRoot;
+  const isInsideWriteRoot = (path) => isPathContained(path, writeRoot);
   const MAX_BODY = 5 * 1024 * 1024; // 5MB，与 GET 路由限制对齐
   let body = '';
   let overflow = false;
@@ -475,8 +560,10 @@ function fileContentPost(req, res) {
       return;
     }
     try {
-      const { path: reqPath, content } = JSON.parse(body);
-      const cwd = process.env.CCV_PROJECT_DIR || process.cwd();
+      const { path: reqPath, content, editorSession } = JSON.parse(body);
+      const cwd = _viewRootOrReply(req, res, parsedUrl);
+      if (!cwd) return;
+      try { writeRoot = realpathSync(cwd); } catch { writeRoot = cwd; }
       if (!reqPath) {
         res.writeHead(400, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: 'Invalid path' }));
@@ -489,7 +576,6 @@ function fileContentPost(req, res) {
       }
       const isAbs = /^([a-zA-Z]:[\\/]|[\\/])/.test(reqPath);
       const absPath = isAbs ? reqPath : resolve(cwd, reqPath);
-
       // 写路径同样走 policy(收敛 editorSession 后门):允许覆盖现有文件;
       // 新文件场景递归向上找最近存在的祖先目录,只要它在 allowlist 内即放行。
       // (旧实现只查 immediate parent,父目录也不存在时误拒嵌套新建。)
@@ -525,6 +611,20 @@ function fileContentPost(req, res) {
           res.end(JSON.stringify(body));
           return;
         }
+        // Check containment before creating any missing parent directories.
+        // Explicit $EDITOR sessions retain their allowlisted external paths.
+        // editorSession is client-claimed — require admin to honor it, otherwise
+        // any caller could use it as a write-root bypass (see /api/target-files).
+        if (editorSession && !isAdminReq(req, isLocal)) {
+          res.writeHead(403, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Forbidden', reason: 'editor-session-requires-admin' }));
+          return;
+        }
+        if (!editorSession && !isInsideWriteRoot(ancestorPolicy.real)) {
+          res.writeHead(403, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Forbidden', reason: 'outside-view-root' }));
+          return;
+        }
         // 在祖先 real 路径下重建目标。Denylist 已在祖先 prefix 层生效,
         // 这里相信 allowlist 祖先的合法性(项目目录 / ~/.claude/cc-viewer 等)。
         targetReal = join(ancestorPolicy.real, ...descent);
@@ -539,6 +639,16 @@ function fileContentPost(req, res) {
         return;
       }
 
+      if (editorSession && !isAdminReq(req, isLocal)) {
+        res.writeHead(403, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Forbidden', reason: 'editor-session-requires-admin' }));
+        return;
+      }
+      if (!editorSession && existsSync(targetReal) && !isInsideWriteRoot(targetReal)) {
+        res.writeHead(403, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Forbidden', reason: 'outside-view-root' }));
+        return;
+      }
       writeFileSync(targetReal, content, 'utf-8');
       const stat = statSync(targetReal);
       res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -552,6 +662,231 @@ function fileContentPost(req, res) {
   });
 }
 
+function targetError(status, message) {
+  return Object.assign(new Error(message), { status });
+}
+
+// Map fs errno to a sensible HTTP status: missing → 404, permission → 403,
+// symlink loop → 400 (treat as malformed), anything else → 404 (don't leak).
+function errnoToStatus(err) {
+  const code = err?.code;
+  if (code === 'EACCES' || code === 'EPERM') return 403;
+  if (code === 'ELOOP') return 400;
+  return 404;
+}
+
+function realDirectory(path, label) {
+  let real;
+  try { real = realpathSync(path); } catch (err) { throw targetError(errnoToStatus(err), `${label} not found`); }
+  let st;
+  try { st = statSync(real); } catch (err) { throw targetError(errnoToStatus(err), `${label} not found`); }
+  if (!st.isDirectory()) throw targetError(400, `${label} is not a directory`);
+  return real;
+}
+
+function checkedDirectory(path, label) {
+  const real = realDirectory(path, label);
+  const policy = isReadAllowed(real);
+  if (!policy.ok) throw targetError(reasonToStatus(policy.reason), `${label} not readable`);
+  return policy.real;
+}
+
+function insidePath(path, root) {
+  return path === root || path.startsWith(root + sep);
+}
+
+function targetNavigation(targetReal, cwd) {
+  const projectReal = realDirectory(cwd, 'Project');
+  if (insidePath(targetReal, projectReal)) return { rootReal: projectReal, rootKind: 'project' };
+  // $HOME becomes the navigation root for home-resident targets (user skills,
+  // plugins, the global CLAUDE.md). Entries outside the allowlist (e.g. ~/.ssh,
+  // ~/.aws) are filtered per-entry by isReadAllowed, and sensitive paths inside
+  // ~/.claude are covered by file-access-policy's denylist. The /api/target-files
+  // handler additionally gates this endpoint behind isAdminReq + same-origin so
+  // a cross-site page cannot enumerate the user's home tree.
+  const homeReal = realDirectory(homedir(), 'Home');
+  if (insidePath(targetReal, homeReal)) {
+    checkedDirectory(targetReal, 'Directory');
+    return { rootReal: homeReal, rootKind: 'home' };
+  }
+  const configReal = realDirectory(getClaudeConfigDir(), 'Claude config');
+  if (insidePath(targetReal, configReal)) {
+    checkedDirectory(targetReal, 'Directory');
+    return { rootReal: realDirectory(dirname(configReal), 'Config root'), rootKind: 'config' };
+  }
+  // Allowlist fallback: targets that live inside another allowlisted root
+  // (registered workspaces, /tmp/cc-viewer-uploads, etc.) are reachable via
+  // /api/claude-md's discovery (which uses isReadAllowed), so we must not
+  // 403 them here. Use the target's own directory as the navigation root —
+  // no parent browsing, but at least the entry the user clicked actually opens.
+  const policy = isReadAllowed(targetReal);
+  if (!policy.ok) throw targetError(reasonToStatus(policy.reason), 'Target not readable');
+  return { rootReal: realDirectory(targetReal, 'Target'), rootKind: 'target' };
+}
+
+function targetScope(targetReal, cwd) {
+  const navigation = targetNavigation(targetReal, cwd);
+  return { ...navigation, targetPath: relative(navigation.rootReal, targetReal).split(sep).join('/') };
+}
+
+function targetRelPath(raw) {
+  if (raw == null) return null;
+  if (raw === '') return [];
+  if (typeof raw !== 'string' || raw.length > 2048 || raw.includes('\0') || raw.includes('\\')
+    || raw.startsWith('/') || /^[a-zA-Z]:/.test(raw)) {
+    throw targetError(400, 'Invalid path');
+  }
+  const segments = raw.split('/');
+  if (segments.some(segment => !segment || segment === '.' || segment === '..')) {
+    throw targetError(400, 'Invalid path');
+  }
+  // Hard cap on navigation depth: each segment triggers at least one
+  // synchronous readdir + per-entry realpath/stat in `ancestors`, and a 2KB
+  // free-form path could otherwise fan out into hundreds of syscalls per
+  // request. 32 is far deeper than any realistic skill / CLAUDE.md location.
+  if (segments.length > 32) throw targetError(400, 'Path too deep');
+  return segments;
+}
+
+function resolveTargetRoot(parsedUrl, cwd) {
+  const kind = parsedUrl.searchParams.get('kind');
+  if (kind === 'claude-md') {
+    const id = parsedUrl.searchParams.get('id') || '';
+    if (!/^[0-9a-f]{12}$/i.test(id)) throw targetError(400, 'Invalid id');
+    const candidate = discoverClaudeMdCandidates({
+      cwd,
+      claudeConfigDir: getClaudeConfigDir(),
+      isReadAllowedFn: isReadAllowed,
+    }).find(entry => entry.id === id);
+    if (!candidate || basename(candidate.realPath) !== 'CLAUDE.md') throw targetError(404, 'Target not found');
+    return { ...targetScope(realDirectory(dirname(candidate.realPath), 'Directory'), cwd), targetKind: 'claude-md' };
+  }
+  if (kind !== 'skill') throw targetError(400, 'Invalid target kind');
+  const source = parsedUrl.searchParams.get('source');
+  const targetPath = parsedUrl.searchParams.get('targetPath');
+  if (!['user', 'project', 'plugin'].includes(source)) throw targetError(400, 'Invalid skill source');
+  if (typeof targetPath !== 'string' || !targetPath || targetPath.length > 4096 || targetPath.includes('\0')) {
+    throw targetError(400, 'Invalid skill path');
+  }
+  const skill = listSkills({ projectDir: cwd })
+    .find(entry => entry.source === source && entry.path === targetPath);
+  if (!skill) throw targetError(404, 'Target not found');
+  const rootReal = realDirectory(skill.path, 'Directory');
+  const scope = targetScope(rootReal, cwd);
+  const anchor = source === 'project'
+    ? scope.rootReal
+    : dirname(dirname(skill.path));
+  const anchorReal = realDirectory(anchor, 'Skill root');
+  if (!insidePath(rootReal, anchorReal)) throw targetError(403, 'Target outside skill root');
+  // Plugin root must follow the configured Claude config dir, not the default
+  // homedir()/.claude — otherwise plugin skills break under CLAUDE_CONFIG_DIR.
+  if (source === 'plugin' && !insidePath(rootReal, realDirectory(join(getClaudeConfigDir(), 'plugins'), 'Plugin root'))) {
+    throw targetError(403, 'Target outside plugin root');
+  }
+  return { ...scope, targetKind: 'skill' };
+}
+
+function listTargetDirectory(rootReal, segments, deps, requireReadable = true) {
+  const dirReal = requireReadable
+    ? checkedDirectory(segments.length ? join(rootReal, ...segments) : rootReal, 'Directory')
+    : realDirectory(segments.length ? join(rootReal, ...segments) : rootReal, 'Directory');
+  if (!isPathContained(dirReal, rootReal)) throw targetError(403, 'Path outside target');
+  const ignored = deps?.IGNORED_PATTERNS || new Set();
+  const entries = [];
+  let dirents;
+  try {
+    dirents = readdirSync(dirReal, { withFileTypes: true });
+  } catch (err) {
+    // EACCES → 403 (permission), ENOENT/ENOTDIR → 404 (race with rename/delete),
+    // anything else falls back to 404 so we don't leak internal state via 500.
+    throw targetError(errnoToStatus(err), 'Directory not readable');
+  }
+  // Hard cap on returned entries: this is a synchronous loop with realpath +
+  // stat + isReadAllowed per entry, and the endpoint fans out via `ancestors`,
+  // so an unbounded listing of a huge dir (e.g. ~/.claude/projects/<hash>/)
+  // would block the event loop and return a giant JSON payload. 5000 is well
+  // past any realistic skill/CLAUDE.md folder.
+  const MAX_ENTRIES = 5000;
+  for (const entry of dirents) {
+    if (entries.length >= MAX_ENTRIES) break;
+    if (ignored.has(entry.name)) continue;
+    const fullPath = join(dirReal, entry.name);
+    let real;
+    try { real = realpathSync(fullPath); } catch (err) { reportSwallowed('targetFiles.entry.realpath', err); continue; }
+    if (!insidePath(real, rootReal)) continue;
+    const policy = isReadAllowed(real);
+    if (!policy.ok) continue;
+    let st;
+    try { st = statSync(policy.real); } catch (err) { reportSwallowed('targetFiles.entry.stat', err); continue; }
+    if (!st.isDirectory() && !st.isFile()) continue;
+    entries.push({ name: entry.name, type: st.isDirectory() ? 'directory' : 'file', absPath: policy.real });
+  }
+  entries.sort((a, b) => a.type !== b.type
+    ? (a.type === 'directory' ? -1 : 1)
+    : a.name.localeCompare(b.name));
+  return entries;
+}
+
+function targetFiles(req, res, parsedUrl, isLocal, deps) {
+  try {
+    // /api/target-files exposes directory listings under the user's home and
+    // ~/.claude (which contains transcripts, prompt history, env snapshots).
+    // Combined with the global `Access-Control-Allow-Origin: *` and loopback's
+    // no-auth path, a bare GET would let any web page enumerate the user's
+    // ~/.claude tree. Require admin AND a same-origin browser request.
+    if (!isAdminReq(req, isLocal) || !isSameOriginBrowserRequest(req, parsedUrl)) {
+      res.writeHead(403, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'forbidden' }));
+      return;
+    }
+    const cwd = _viewRootOrReply(req, res, parsedUrl);
+    if (!cwd) return;
+    const scope = resolveTargetRoot(parsedUrl, cwd);
+    const rawPath = parsedUrl.searchParams.get('path');
+    const requestedSegments = targetRelPath(rawPath);
+    const segments = requestedSegments === null ? scope.targetPath.split('/').filter(Boolean) : requestedSegments;
+    const entries = listTargetDirectory(scope.rootReal, segments, deps, segments.length > 0 || scope.rootKind !== 'home');
+    const rootEntries = requestedSegments === null && segments.length > 0
+      ? listTargetDirectory(scope.rootReal, [], deps, scope.rootKind === 'project')
+      : entries;
+    const targetEntries = requestedSegments === null
+      ? entries.filter(entry => insidePath(entry.absPath, join(scope.rootReal, ...segments)))
+      : entries;
+    const targetSegments = scope.targetPath ? scope.targetPath.split('/') : [];
+    const ancestors = [];
+    // Ancestors are the chain from the navigation root down to the directory
+    // being listed. When the caller passed no `path` that's the chain leading
+    // to the target itself; when they passed `path`, the chain is the requested
+    // segments. We deliberately DO NOT use path.relative(targetPath, rawPath)
+    // here — that helper happily produces "../.." for sibling branches, which
+    // would pollute the cache with pseudo-paths and re-list directories the
+    // user never navigated into.
+    const chainSegments = requestedSegments === null ? targetSegments : segments;
+    // Request-scoped memo: targetFiles lists the same directory multiple times
+    // (entries + ancestors chain often share prefixes), so we cache by dir key
+    // to avoid duplicate readdirSync storms on large directories.
+    const listMemo = new Map();
+    const listOnce = (segs, requireReadable) => {
+      const key = segs.join('/') + (requireReadable ? '|r' : '|n');
+      if (!listMemo.has(key)) listMemo.set(key, listTargetDirectory(scope.rootReal, segs, deps, requireReadable));
+      return listMemo.get(key);
+    };
+    const ancestorCount = Math.max(0, chainSegments.length - (requestedSegments === null ? 0 : 1));
+    for (let i = 0; i <= ancestorCount; i++) {
+      const path = chainSegments.slice(0, i).join('/');
+      ancestors.push({ path, entries: listOnce(path ? path.split('/') : [], false) });
+    }
+    const { rootReal, ...response } = scope;
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ ...response, targetPath: segments.join('/'), entries: rootEntries, targetEntries, ancestors }));
+  } catch (err) {
+    const status = err.status || ERROR_STATUS_MAP[err.code] || 500;
+    if (status === 500) console.error('[api/target-files]', err);
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: status === 500 ? 'Internal error' : err.message }));
+  }
+}
+
 export const filesContentRoutes = [
   { method: 'GET', match: 'exact', path: '/api/plan-file', handler: planFile },
   { method: 'GET', match: 'exact', path: '/api/file-content', handler: fileContentGet },
@@ -560,4 +895,5 @@ export const filesContentRoutes = [
   { predicate: (url, method) => (url === '/api/file-raw' || url.startsWith('/api/file-raw/')) && (method === 'GET' || method === 'HEAD'), handler: fileRaw },
   { predicate: (url, method) => url === '/api/download-file' && (method === 'GET' || method === 'HEAD'), handler: fileDownload },
   { method: 'POST', match: 'exact', path: '/api/file-content', handler: fileContentPost },
+  { method: 'GET', match: 'exact', path: '/api/target-files', handler: targetFiles },
 ];