npm - create-walle - Versions diffs - 0.9.30 → 0.9.32 - Mend

create-walle 0.9.30 → 0.9.32

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (112) hide show

package/template/claude-task-manager/api-reviews.js CHANGED Viewed

@@ -1,6 +1,7 @@
 'use strict';
 const path = require('path');
 const fs = require('fs');
+const os = require('os');
 const db = require('./db');
 const gitUtils = require('./git-utils');
 const documentReview = require('./lib/document-review');
@@ -23,6 +24,132 @@ function isValidProjectPath(p) {
     return true;
   } catch { return false; }
 }
+// Resolve `filePath` within `project` and enforce containment AFTER following
+// symlinks. A lexical `resolved.startsWith(root + sep)` check is not enough: a
+// symlink that lives inside the repo can point at /etc/passwd (or ~/.ssh) and the
+// lexical path still looks in-bounds. realpath canonicalizes the link target, so
+// containment is checked against where the file ACTUALLY is.
+// Returns the safe absolute path to read, or null if it escapes the project.
+// A path that doesn't exist yet (ENOENT) can't be a symlink, so the lexical check
+// already guarantees safety — return it so the caller can produce its own 404.
+// The repo's worktree roots, main-style checkouts first (work usually lands there), capped.
+function htmlWorktreeRoots(projectRoot, cap = 20) {
+  try {
+    const { execFileSync } = require('child_process');
+    const out = execFileSync('git', ['worktree', 'list', '--porcelain'],
+      { cwd: projectRoot, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+    const roots = [];
+    for (const line of out.split('\n')) {
+      if (line.startsWith('worktree ')) roots.push(line.slice('worktree '.length).trim());
+    }
+    const isWorktreeSubdir = (pth) => /\/\.(?:claude|walle)\/worktrees\/|\/\.worktrees\//.test(pth);
+    roots.sort((a, b) => (isWorktreeSubdir(a) ? 1 : 0) - (isWorktreeSubdir(b) ? 1 : 0));
+    return roots.slice(0, Math.max(1, cap));
+  } catch { return []; }
+}
+// Find an .html file (tracked + untracked) within a single worktree `root` by exact relative
+// path, suffix, or basename.
+function findHtmlInRoot(root, want, base) {
+  try {
+    const { execFileSync } = require('child_process');
+    const out = execFileSync('git', ['ls-files', '-z', '--cached', '--others', '--exclude-standard', '*.html', '*.htm'],
+      { cwd: root, encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 }).split('\0').filter(Boolean);
+    let hit = out.find(f => f === want || f.endsWith('/' + want));
+    if (!hit) hit = out.find(f => path.basename(f) === base);
+    return hit ? path.join(root, hit) : null;
+  } catch { return null; }
+}
+// Best-effort fallback when an html path doesn't resolve at the given root — e.g. a path
+// relative to the repo root while the session cwd is a subdir, OR a file that lives in a
+// SIBLING worktree of the same repo (work landed on main while the session runs in a feature
+// worktree). Searches the own worktree first, then the repo's others; returns a path under
+// the user's HOME or null.
+function findHtmlInRepo(root, relPath) {
+  const want = String(relPath || '').replace(/^\.?\//, '');
+  if (!want) return null;
+  const base = path.basename(want);
+  const home = process.env.HOME || '';
+  const underHome = (pth) => {
+    if (!home) return false;
+    const r = path.resolve(pth);
+    return r === home || r.startsWith(home + path.sep);
+  };
+  const own = findHtmlInRoot(root, want, base);
+  if (own && underHome(own)) return own;
+  let realRoot = '';
+  try { realRoot = fs.realpathSync(root); } catch { realRoot = path.resolve(root); }
+  for (const wt of htmlWorktreeRoots(root)) {
+    let realWt = '';
+    try { realWt = fs.realpathSync(wt); } catch { realWt = path.resolve(wt); }
+    if (realWt === realRoot) continue; // own worktree already searched
+    const hit = findHtmlInRoot(wt, want, base);
+    if (hit && underHome(hit)) return hit;
+  }
+  return null;
+}
+function htmlNotFoundPage(filePath) {
+  const safe = String(filePath || '').replace(/[&<>"]/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c]));
+  return `<!DOCTYPE html><html><head><meta charset="utf-8"><title>File not found</title>
+<style>body{font-family:-apple-system,system-ui,sans-serif;background:#1a1b26;color:#c0caf5;display:grid;place-items:center;height:100vh;margin:0}
+.box{text-align:center;max-width:34rem;padding:2rem}h1{font-size:1.1rem;color:#f7768e}code{background:rgba(122,162,247,.12);padding:.15rem .4rem;border-radius:4px;font-size:.85em;word-break:break-all}p{color:#8b94bd;line-height:1.6;font-size:.9rem}</style>
+</head><body><div class="box"><h1>File not found</h1>
+<p><code>${safe}</code> isn't in this checkout. It may live in a different worktree or branch than the one this session is running in.</p></div></body></html>`;
+}
+function resolveWithinProject(project, filePath) {
+  if (!project || typeof filePath !== 'string') return null;
+  const root = path.resolve(project);
+  const resolved = path.resolve(root, filePath);
+  if (resolved !== root && !resolved.startsWith(root + path.sep)) return null; // lexical ../ escape
+  let realRoot;
+  try { realRoot = fs.realpathSync(root); }
+  catch { return null; }
+  let realFile;
+  try { realFile = fs.realpathSync(resolved); }
+  catch (e) {
+    if (e && e.code === 'ENOENT') return resolved; // lexically in-bounds, not yet on disk
+    return null;
+  }
+  if (realFile !== realRoot && !realFile.startsWith(realRoot + path.sep)) return null; // symlink escape
+  return realFile;
+}
+// The per-session scratchpad lives OUTSIDE the project root AND outside HOME:
+//   <tmp>/claude-<uid>/<project-slug>/<session>/scratchpad/<file>.html
+// (e.g. <tmpdir>/claude-<uid>/.../scratchpad/plan.html). Agents author HTML there and
+// print the absolute path into session output; clicking it built a serve-html URL that
+// 403'd because resolveWithinProject (project- and HOME-scoped) rejected it. Serve these
+// too — same trust level as project HTML (same uid, mode-0700 temp dir), behind the same
+// .html + sandbox-CSP guards, with realpath containment to block a symlink escaping the
+// scratchpad. Returns the safe absolute path to read, or null.
+function scratchpadRoots() {
+  let uid = '';
+  try { if (typeof process.getuid === 'function') uid = String(process.getuid()); } catch {}
+  if (!uid) return [];
+  const roots = new Set();
+  // os.tmpdir() (launchd gives a per-user /var/folders/... TMPDIR) plus the /tmp aliases
+  // Claude Code actually uses; realpath collapses /tmp → /private/tmp on macOS and dedupes.
+  for (const base of [os.tmpdir(), '/tmp', '/private/tmp']) {
+    try { roots.add(fs.realpathSync(path.join(base, 'claude-' + uid))); } catch {}
+  }
+  return [...roots];
+}
+function resolveWithinScratchpad(filePath) {
+  if (typeof filePath !== 'string' || !path.isAbsolute(filePath)) return null;
+  const roots = scratchpadRoots();
+  if (!roots.length) return null;
+  let realFile;
+  try { realFile = fs.realpathSync(filePath); } // must exist; no pre-create 404 for scratchpad
+  catch { return null; }
+  for (const root of roots) {
+    if (realFile === root || realFile.startsWith(root + path.sep)) return realFile;
+  }
+  return null;
+}
 function jsonResponse(res, code, data) {
   const body = JSON.stringify(data);
   res.writeHead(code, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) });
@@ -234,6 +361,22 @@ function handleReviewApi(req, res, url) {
     return true;
   }
+  // POST /api/reviews/verify-commits — given a repo and a list of candidate SHAs
+  // (mined from session output), return only the ones that are real commits, with
+  // their short hash + subject. Lets the client linkify commit references safely.
+  if (p === '/api/reviews/verify-commits' && m === 'POST') {
+    readBody(req).then(body => {
+      const project = body && body.project;
+      const shas = (body && Array.isArray(body.shas)) ? body.shas.slice(0, 50) : [];
+      if (!project) return jsonResponse(res, 400, { error: 'project required' });
+      if (!isValidProjectPath(project)) return jsonResponse(res, 403, { error: 'Invalid project path' });
+      gitUtils.verifyCommits(project, shas)
+        .then(commits => jsonResponse(res, 200, { commits }))
+        .catch(e => jsonResponse(res, 500, { error: e.message }));
+    }).catch(e => jsonResponse(res, 400, { error: e.message }));
+    return true;
+  }
   // GET /api/reviews/diff-stat?project=...&base=...
   if (p === '/api/reviews/diff-stat' && m === 'GET') {
     const project = url.searchParams.get('project');
@@ -364,9 +507,9 @@ function handleReviewApi(req, res, url) {
     const ext = path.extname(filePath).toLowerCase();
     const imageExts = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.svg': 'image/svg+xml', '.webp': 'image/webp', '.ico': 'image/x-icon', '.bmp': 'image/bmp' };
     if (!imageExts[ext]) return jsonResponse(res, 400, { error: 'Only image files are supported' });
-    // Prevent path traversal
-    const resolved = path.resolve(project, filePath);
-    if (!resolved.startsWith(path.resolve(project) + path.sep)) return jsonResponse(res, 403, { error: 'Invalid file path' });
+    // Prevent path traversal (incl. symlinks escaping the project — see resolveWithinProject)
+    const resolved = resolveWithinProject(project, filePath);
+    if (!resolved) return jsonResponse(res, 403, { error: 'Invalid file path' });
     try {
       const data = fs.readFileSync(resolved);
       res.writeHead(200, { 'Content-Type': imageExts[ext], 'Content-Length': data.length, 'Cache-Control': 'no-cache' });
@@ -462,6 +605,108 @@ function handleReviewApi(req, res, url) {
     return jsonResponse(res, 200, { prompt });
   }
+  // GET /api/reviews/documents?project=... — list reviewable markdown/text files in a
+  // project (powers the Review Hub "Documents" discovery column). Tracked + untracked-
+  // not-ignored, bounded, sorted most-recently-modified first.
+  if (p === '/api/reviews/documents' && m === 'GET') {
+    const project = url.searchParams.get('project');
+    if (!project) return jsonResponse(res, 400, { error: 'project required' });
+    if (!isValidProjectPath(project)) return jsonResponse(res, 403, { error: 'Invalid project path' });
+    try {
+      const { execFileSync } = require('child_process');
+      const root = path.resolve(project);
+      const globs = ['*.md', '*.markdown', '*.mdown', '*.txt'];
+      // -z → NUL-separated so paths with spaces/specials survive (no core.quotePath issues).
+      const run = (args) => {
+        try {
+          return execFileSync('git', args, { cwd: root, encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 })
+            .split('\0').filter(Boolean);
+        } catch { return []; }
+      };
+      const set = new Set([
+        ...run(['ls-files', '-z', ...globs]),
+        ...run(['ls-files', '-z', '--others', '--exclude-standard', ...globs]),
+      ]);
+      let items = [...set].slice(0, 2000).map(rel => {
+        let mtime = 0;
+        try { mtime = fs.statSync(path.join(root, rel)).mtimeMs; } catch {}
+        return { path: rel, name: path.basename(rel), dir: path.dirname(rel), mtime };
+      });
+      items.sort((a, b) => b.mtime - a.mtime);
+      return jsonResponse(res, 200, { documents: items.slice(0, 300), total: set.size });
+    } catch (e) {
+      return jsonResponse(res, 500, { error: e.message });
+    }
+  }
+  // GET /api/reviews/serve-html?project=...&path=... — serve a project .html file so the
+  // file-router can open it in a new browser tab. Path-validated; no traversal outside project.
+  if (p === '/api/reviews/serve-html' && m === 'GET') {
+    const project = url.searchParams.get('project');
+    const filePath = url.searchParams.get('path');
+    if (!project || !filePath) return jsonResponse(res, 400, { error: 'project and path required' });
+    if (!isValidProjectPath(project)) return jsonResponse(res, 403, { error: 'Invalid project path' });
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext !== '.html' && ext !== '.htm') return jsonResponse(res, 400, { error: 'Only .html files are supported' });
+    let resolved = resolveWithinProject(project, filePath);
+    // The file may be agent-authored HTML in the session scratchpad (absolute /tmp path,
+    // outside the project and HOME). realpath-validated to the user's claude-<uid> temp dir.
+    if (!resolved) resolved = resolveWithinScratchpad(filePath);
+    if (!resolved) return jsonResponse(res, 403, { error: 'Invalid file path' });
+    // Fallback: the path may be relative to the repo root while the session cwd is a
+    // subdir/worktree — search the repo for the file before giving up.
+    if (!fs.existsSync(resolved)) {
+      const found = findHtmlInRepo(path.resolve(project), filePath);
+      if (found) resolved = found;
+    }
+    // Sandbox the served file: arbitrary repo HTML rendered on the CTM origin (which holds
+    // the auth cookie). A bare `sandbox` blocks scripting AND assigns an opaque origin, so it
+    // can't run JS, read CTM storage, or make cookie-authed calls — inline CSS/images still render.
+    const htmlHeaders = (len) => ({
+      'Content-Type': 'text/html; charset=utf-8',
+      'Content-Length': len,
+      'Cache-Control': 'no-cache',
+      'X-Content-Type-Options': 'nosniff',
+      'Content-Security-Policy': 'sandbox',
+    });
+    let data;
+    try { data = fs.readFileSync(resolved); }
+    catch {
+      // Friendly in-tab page instead of a scary "unreachable file" / bare text 404.
+      const body = Buffer.from(htmlNotFoundPage(filePath));
+      res.writeHead(404, htmlHeaders(body.length));
+      res.end(body);
+      return true;
+    }
+    res.writeHead(200, htmlHeaders(data.length));
+    res.end(data);
+    return true;
+  }
+  // POST /api/reviews/reveal {project, path} — reveal a project file in Finder (macOS
+  // `open -R`). Path-validated; best-effort (the file-router menu's "Reveal" action).
+  if (p === '/api/reviews/reveal' && m === 'POST') {
+    readBody(req).then(body => {
+      const project = String(body.project || '');
+      const filePath = String(body.path || '');
+      if (!project || !filePath) return jsonResponse(res, 400, { error: 'project and path required' });
+      if (!isValidProjectPath(project)) return jsonResponse(res, 403, { error: 'Invalid project path' });
+      const resolved = resolveWithinProject(project, filePath);
+      if (!resolved) return jsonResponse(res, 403, { error: 'Invalid file path' });
+      if (!fs.existsSync(resolved)) return jsonResponse(res, 404, { error: 'File not found' });
+      try {
+        const { execFile } = require('child_process');
+        const cmd = process.platform === 'darwin' ? 'open' : 'xdg-open';
+        const args = process.platform === 'darwin' ? ['-R', resolved] : [path.dirname(resolved)];
+        execFile(cmd, args, () => {});
+        jsonResponse(res, 200, { ok: true });
+      } catch (e) {
+        jsonResponse(res, 500, { error: e.message });
+      }
+    }).catch(e => jsonResponse(res, 400, { error: e.message }));
+    return true;
+  }
   return false; // Not handled
 }
@@ -508,4 +753,7 @@ module.exports = {
   _sanitizeReviewCommentInput: sanitizeReviewCommentInput,
   _sanitizeReviewCommentUpdate: sanitizeReviewCommentUpdate,
   _documentReview: documentReview,
+  _resolveWithinProject: resolveWithinProject,
+  _resolveWithinScratchpad: resolveWithinScratchpad,
+  _findHtmlInRepo: findHtmlInRepo,
 };