claude-code-kanban 4.24.0 → 4.26.0

package/server.js

@@ -21,6 +21,7 @@ const {
   readSessionInfoFromJsonl,
   buildSessionDigest,
   readCompactSummaries,
+  readArtifactLinks,
   extractPromptFromTranscript,
   extractModelFromTranscript,
   extractStructuredResultFromTranscript,
@@ -33,7 +34,8 @@ const {
   buildLoopInfoFromState
 } = require('./lib/parsers');
 const { inlineHtmlAssets } = require('./lib/inline-assets');
-const { buildDecision, decisionFileName, isDecisionFile, waitSecondsFrom, isLapsed } = require('./lib/approvals');
+const { buildDecision, decisionFileName, isDecisionFile, approvalsFrom, boardRefusal } = require('./lib/approvals');
+const { getClaudeDir, getArgValue, storageNamespace } = require('./lib/claude-dir');
 
 if (process.argv.includes("--install") || process.argv.includes("--uninstall")) {
   const { runInstall, runUninstall } = require("./install");
@@ -56,30 +58,8 @@ app.use(net.hostGuard);
 app.use(net.frameGuard);
 app.use(net.originGuard);
 
-// Parse --dir flag for custom Claude directory
-function getClaudeDir() {
-  const dirIndex = process.argv.findIndex(arg => arg.startsWith('--dir'));
-  if (dirIndex !== -1) {
-    const arg = process.argv[dirIndex];
-    if (arg.includes('=')) {
-      const dir = arg.split('=')[1];
-      return dir.startsWith('~') ? dir.replace('~', os.homedir()) : dir;
-    } else if (process.argv[dirIndex + 1]) {
-      const dir = process.argv[dirIndex + 1];
-      return dir.startsWith('~') ? dir.replace('~', os.homedir()) : dir;
-    }
-  }
-  return process.env.CLAUDE_CONFIG_DIR || process.env.CLAUDE_DIR || path.join(os.homedir(), '.claude');
-}
-
 function getArgUrl(argName, envName) {
-  const idx = process.argv.findIndex(arg => arg.startsWith(`--${argName}`));
-  if (idx !== -1) {
-    const arg = process.argv[idx];
-    if (arg.includes('=')) return arg.split('=').slice(1).join('=');
-    if (process.argv[idx + 1]) return process.argv[idx + 1];
-  }
-  return process.env[envName] || null;
+  return getArgValue(argName) || process.env[envName] || null;
 }
 
 const MARKETPLACE_URL = getArgUrl('marketplace-url', 'MARKETPLACE_URL');
@@ -126,12 +106,33 @@ function writePins(pins) {
   writeJsonAtomic(PINS_FILE, pins);
 }
 
-// Port discovery for out-of-process helpers (the postman monitor). The pid rides along
-// so a reader can tell a live server from a file left behind by a crashed one.
+// Port discovery for out-of-process helpers (the postman monitor, approval-gate.sh).
+// The pid rides along so a reader can tell a live server from a file left behind by
+// a crashed one.
 function writeServerInfo(port) {
   writeJsonAtomic(SERVER_INFO_FILE, { port, pid: process.pid });
 }
 
+// A beacon that outlives its server disarms UI approvals silently: approval-gate.sh
+// probes the port, finds it closed and never waits. The hub spawns every sub-app on
+// an ephemeral port, so a stale beacon never comes back on its own — drop ours on
+// the way out. Only when the file is still ours: a newer server on the same config
+// dir has already claimed it.
+function removeServerInfo() {
+  try {
+    const info = JSON.parse(readFileSync(SERVER_INFO_FILE, 'utf8'));
+    if (info.pid === process.pid) unlinkSync(SERVER_INFO_FILE);
+  } catch (_) { /* gone, unreadable, or not ours */ }
+}
+
+process.on('exit', removeServerInfo);
+for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+  process.on(sig, () => {
+    removeServerInfo();
+    process.exit(0);
+  });
+}
+
 // #endregion
 
 // #region TIMINGS
@@ -176,23 +177,30 @@ function persistAgent(dir, agent) {
   fs.appendFile(file, `${JSON.stringify({ ...agent, event: 'server-update' })}\n`, 'utf8').catch(() => {});
 }
 
-// Lapse math lives in lib/approvals (kept in sync with the gate's own parse);
-// this only reads the config, cached so the polled session list doesn't re-read
-// it per hit (marker stays visible for the badge until TTL).
-const APPROVALS_CONFIG_FILE = path.join(CCK_DIR, 'approvals.json');
-let approvalsWaitCache = { ts: 0, ms: 30 * 1000 };
-function approvalsWaitMs() {
-  if (Date.now() - approvalsWaitCache.ts < 10 * 1000) return approvalsWaitCache.ms;
-  let cfg = null;
-  try {
-    cfg = JSON.parse(readFileSync(APPROVALS_CONFIG_FILE, 'utf8'));
-  } catch { /* missing config — gate default */ }
-  approvalsWaitCache = { ts: Date.now(), ms: waitSecondsFrom(cfg) * 1000 };
-  return approvalsWaitCache.ms;
+// <CCK_DIR>/config.json — cck's own settings, per Claude config dir.
+// Normalization lives in lib/approvals (kept in sync with the gate's own parse).
+const CCK_CONFIG_FILE = path.join(CCK_DIR, 'config.json');
+const LEGACY_APPROVALS_FILE = path.join(CCK_DIR, 'approvals.json');
+const cckConfigCache = new Map();
+function approvalsConfig() {
+  return cachedByMtime(cckConfigCache, 'approvals', CCK_CONFIG_FILE,
+    () => approvalsFrom(JSON.parse(readFileSync(CCK_CONFIG_FILE, 'utf8'))), approvalsFrom(null));
 }
 
-function isWaitingLapsed(data) {
-  return isLapsed(data.timestamp, approvalsWaitMs());
+// approvals.json predates config.json (and was opt-in). Fold it into
+// config.json once so an existing opt-in keeps its tuning, then drop it.
+function migrateLegacyApprovalsConfig() {
+  if (!existsSync(LEGACY_APPROVALS_FILE)) return;
+  try {
+    const legacy = JSON.parse(readFileSync(LEGACY_APPROVALS_FILE, 'utf8'));
+    let cfg = {};
+    try { cfg = JSON.parse(readFileSync(CCK_CONFIG_FILE, 'utf8')) || {}; } catch { /* absent */ }
+    if (!cfg.approvals) writeJsonAtomic(CCK_CONFIG_FILE, { ...cfg, approvals: legacy });
+    unlinkSync(LEGACY_APPROVALS_FILE);
+    cckConfigCache.clear();
+  } catch (e) {
+    console.error(`[cck] could not migrate ${LEGACY_APPROVALS_FILE}: ${e.message}`);
+  }
 }
 
 function checkWaitingForUser(agentDir, logMtime) {
@@ -204,7 +212,9 @@ function checkWaitingForUser(agentDir, logMtime) {
       if (age >= PERMISSION_TTL_MS) return null;
       // After grace period, check if session resumed activity (user already responded)
       if (logMtime && age >= WAITING_RESOLVE_GRACE_MS && logMtime > waitTime + WAITING_RESOLVE_GRACE_MS) return null;
-      if (isWaitingLapsed(data)) return { ...data, lapsed: true };
+      // Opted out reads the same as lapsed to the board: the ask is only
+      // answerable in the terminal, so no buttons.
+      if (boardRefusal(data, approvalsConfig())) return { ...data, lapsed: true };
       return data;
     }
   } catch { /* skip — missing or invalid */ }
@@ -267,6 +277,34 @@ function getGitBranch(cwd) {
   return branch;
 }
 
+// A linked worktree's `.git` is a file holding `gitdir: <main>/.git/worktrees/<name>`, so the
+// main checkout is readable without spawning git. Path shape alone would not do: only some
+// worktrees live under `<repo>/.claude/worktrees/`, the rest sit beside the repo.
+// Cached without a TTL, misses included: a directory cannot turn from an ordinary checkout into
+// a linked worktree without being recreated, and a recreated path is a new cache key.
+const worktreeCache = new Map();
+const WORKTREE_CACHE_MAX = 500;
+const GITDIR_WORKTREE_RE = /^gitdir:\s*(.*)[/\\]\.git[/\\]worktrees[/\\]([^/\\]+)[/\\]?$/;
+
+function resolveWorktree(dir) {
+  if (!dir) return null;
+  if (worktreeCache.has(dir)) return worktreeCache.get(dir);
+
+  let worktree = null;
+  try {
+    // An ordinary checkout's `.git` is a directory, so the read throws EISDIR — that is the
+    // answer, and it costs one syscall instead of a stat followed by a read.
+    const m = GITDIR_WORKTREE_RE.exec(readFileSync(path.join(dir, '.git'), 'utf8').trim());
+    if (m) worktree = { repo: m[1], name: m[2] };
+  } catch (_) {}
+
+  worktreeCache.set(dir, worktree);
+  if (worktreeCache.size > WORKTREE_CACHE_MAX) {
+    worktreeCache.delete(worktreeCache.keys().next().value);
+  }
+  return worktree;
+}
+
 // Only spawn git when cwd has diverged from the launch project — that's the
 // only case the JSONL value is wrong. Saves N spawns on a typical list build.
 function resolveSessionGitBranch(meta) {
@@ -516,6 +554,18 @@ app.get('/hub-config', (_req, res) => {
   res.json({ enabled: !!process.env.CLAUDE_HUB, url: process.env.HUB_URL || null });
 });
 
+// app.js reads localStorage synchronously at startup, before any fetch could deliver the
+// namespace, so it is injected into the page instead of served from /hub-config.
+const STORAGE_NS = storageNamespace(CLAUDE_DIR);
+const NS_DECL = 'window.__STORAGE_NS__ = null;';
+const RAW_INDEX = readFileSync(path.join(__dirname, 'public', 'index.html'), 'utf8');
+if (!RAW_INDEX.includes(NS_DECL)) throw new Error(`public/index.html is missing "${NS_DECL}"`);
+const INDEX_HTML = RAW_INDEX.replace(NS_DECL, `window.__STORAGE_NS__ = ${JSON.stringify(STORAGE_NS)};`);
+app.get(['/', '/index.html'], (_req, res) => {
+  res.setHeader('Cache-Control', 'no-cache');
+  res.type('html').send(INDEX_HTML);
+});
+
 // Serve static files
 app.get('/sw.js', (_req, res) => {
   res.setHeader('Cache-Control', 'no-cache');
@@ -1024,12 +1074,30 @@ function getSessionDisplayName(_sessionId, meta) {
   return null;
 }
 
+// The harness spells a project path into a temp/log dir name by replacing every
+// non-alphanumeric character with a dash, drive colon and separators included.
+function encodeProjectDirName(p) {
+  return p.replace(/[^a-zA-Z0-9]/g, '-');
+}
+
 // Derived by convention, not looked up: the harness creates the dir lazily, so a
 // stat here would report "missing" for every session that has not written a temp
 // file yet — and it would put IO on the session-list hot path. Pure string join.
 function getScratchpadDir(id, meta) {
   if (!meta.jsonlPath) return null;
-  return path.join(SCRATCHPAD_ROOT, path.basename(path.dirname(meta.jsonlPath)), id, 'scratchpad');
+  const byProject = path.join(SCRATCHPAD_ROOT, path.basename(path.dirname(meta.jsonlPath)), id, 'scratchpad');
+
+  // A session launched with `claude -w` starts in the main checkout and enters the
+  // worktree afterwards, so the harness keys its scratchpad on the repo while the
+  // transcript ends up filed under the worktree. Neither the project nor any `cwd`
+  // in the log records that, so the two candidates are told apart by which one the
+  // harness actually created. Probed only for worktree sessions, and only until one
+  // of them exists — before that there is nothing to disambiguate and `byProject`,
+  // right for a session started inside the worktree, stands.
+  const wt = resolveWorktree(meta.project);
+  if (!wt || existsSync(byProject)) return byProject;
+  const byRepo = path.join(SCRATCHPAD_ROOT, encodeProjectDirName(wt.repo), id, 'scratchpad');
+  return existsSync(byRepo) ? byRepo : byProject;
 }
 
 function buildSessionObject(id, meta, overrides = {}) {
@@ -1044,6 +1112,7 @@ function buildSessionObject(id, meta, overrides = {}) {
     cwd: meta.cwd || null,
     description: meta.description || null,
     gitBranch: resolveSessionGitBranch(meta),
+    worktree: resolveWorktree(meta.project),
     customTitle: meta.customTitle || null,
     goal: meta.goal || null,
     taskCount: 0,
@@ -1583,6 +1652,32 @@ app.get('/api/sessions/:sessionId/loop', (req, res) => {
   }
 });
 
+// Cold path — a full transcript scan, so the result is held until the file grows.
+// The zen panel asks again on every re-render, which then costs one stat.
+const artifactsByPath = new Map();
+
+function getArtifactLinks(jsonlPath) {
+  let stat;
+  try { stat = statSync(jsonlPath); } catch (_) { return []; }
+  const hit = artifactsByPath.get(jsonlPath);
+  if (hit && hit.mtimeMs === stat.mtimeMs && hit.size === stat.size) return hit.artifacts;
+  const artifacts = readArtifactLinks(jsonlPath);
+  artifactsByPath.set(jsonlPath, { mtimeMs: stat.mtimeMs, size: stat.size, artifacts });
+  return artifacts;
+}
+
+app.get('/api/sessions/:sessionId/artifacts', (req, res) => {
+  try {
+    const metadata = loadSessionMetadata();
+    const meta = metadata[req.params.sessionId] || metadata[resolveSessionId(req.params.sessionId)];
+    if (!meta?.jsonlPath) return res.json({ artifacts: [] });
+    res.json({ artifacts: getArtifactLinks(meta.jsonlPath) });
+  } catch (error) {
+    console.error('Error reading artifacts:', error);
+    res.status(500).json({ error: 'Failed to read artifacts' });
+  }
+});
+
 // API: List workflow scripts for a session. Parses each script's meta for the
 // canonical name + description (cold path — only when the workflow modal opens).
 app.get('/api/sessions/:sessionId/workflows', async (req, res) => {
@@ -2170,9 +2265,8 @@ app.post('/api/sessions/:sessionId/waiting/respond', (req, res) => {
   catch { /* missing or invalid → buildDecision reports 410 */ }
   // The gate stopped polling after waitSeconds — an orphaned decision file would
   // sit unconsumed while the card pretends the click worked.
-  if (marker && isWaitingLapsed(marker)) {
-    return res.status(410).json({ error: 'Ask lapsed — answer it in the terminal' });
-  }
+  const refusal = marker && boardRefusal(marker, approvalsConfig());
+  if (refusal) return res.status(refusal.status).json({ error: refusal.error });
   const result = buildDecision(marker, req.body || {});
   if (result.error) return res.status(result.status).json({ error: result.error });
   try {
@@ -3463,6 +3557,7 @@ async function prewarmCaches() {
     // The port is configurable and falls back to a random one when taken, so the postman
     // monitor cannot assume it -- publish the live one where it can read it.
     writeServerInfo(actualPort);
+    migrateLegacyApprovalsConfig();
     const warning = net.exposureWarning();
     if (warning) console.log(warning);