claude-code-kanban 4.0.0 → 4.2.0

package/server.js

@@ -8,7 +8,7 @@ const readline = require('readline');
 const chokidar = require('chokidar');
 const os = require('os');
 const crypto = require('crypto');
-const { spawn } = require('child_process');
+const { spawn, spawnSync } = require('child_process');
 
 const {
   readRecentMessages: _readRecentMessagesUncached,
@@ -20,7 +20,10 @@ const {
   findTerminatedTeammates,
   extractPromptFromTranscript,
   extractModelFromTranscript,
-  readFullToolResult
+  readFullToolResult,
+  readUserImage,
+  updateLoopInfo,
+  buildLoopInfoFromState
 } = require('./lib/parsers');
 
 if (process.argv.includes("--install") || process.argv.includes("--uninstall")) {
@@ -95,12 +98,16 @@ function writePins(pins) {
   }
 }
 
-const PERMISSION_TTL_MS = 1800000;
-const AGENT_TTL_MS = 3600000;
-const AGENT_STALE_MS = 900000;
-const SESSION_STALE_MS = 300000;
-
-const WAITING_RESOLVE_GRACE_MS = 15000;
+// #region TIMINGS
+const PERMISSION_TTL_MS = 30 * 60 * 1000;
+const AGENT_TTL_MS = 60 * 60 * 1000;
+const AGENT_STALE_MS = 30 * 60 * 1000; // safety net for crashed sessions
+const SESSION_STALE_MS = 5 * 60 * 1000;
+const WAITING_RESOLVE_GRACE_MS = 15 * 1000;
+const CTX_CLEANUP_MAX_AGE_MS = 2 * 60 * 60 * 1000;
+const CLEANUP_MAX_AGE_MS = 2 * 24 * 60 * 60 * 1000;
+const CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
+// #endregion
 
 function readAgentJsonl(filePath) {
   const raw = readFileSync(filePath, 'utf8');
@@ -152,6 +159,45 @@ function isAgentFresh(agent) {
   return (Date.now() - new Date(ts).getTime()) < AGENT_TTL_MS;
 }
 
+// Claude Code records gitBranch from the launch-time repo and never updates it
+// when cwd shifts (Bash `cd`, submodule, sibling repo). Resolve on-demand from
+// the live cwd instead. Cached per-cwd with a short TTL so a list refresh
+// across N sessions sharing one cwd spawns git at most once per TTL window.
+const gitBranchCache = new Map();
+const GIT_BRANCH_TTL_MS = 30000;
+const GIT_BRANCH_CACHE_MAX = 500;
+function getGitBranch(cwd) {
+  if (!cwd) return null;
+  const now = Date.now();
+  const cached = gitBranchCache.get(cwd);
+  if (cached && now - cached.ts < GIT_BRANCH_TTL_MS) return cached.branch;
+  let branch = null;
+  try {
+    const r = spawnSync('git', ['-C', cwd, 'rev-parse', '--abbrev-ref', 'HEAD'], {
+      encoding: 'utf8', timeout: 500, windowsHide: true
+    });
+    if (r.status === 0) {
+      const out = (r.stdout || '').trim();
+      if (out && out !== 'HEAD') branch = out;
+    }
+  } catch (_) {}
+  gitBranchCache.set(cwd, { branch, ts: now });
+  if (gitBranchCache.size > GIT_BRANCH_CACHE_MAX) {
+    const firstKey = gitBranchCache.keys().next().value;
+    gitBranchCache.delete(firstKey);
+  }
+  return branch;
+}
+
+// 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) {
+  if (meta.cwd && meta.project && meta.cwd !== meta.project) {
+    return getGitBranch(meta.cwd) || meta.gitBranch || null;
+  }
+  return meta.gitBranch || null;
+}
+
 function getSessionLogStat(meta) {
   if (!meta.jsonlPath) return { mtime: null, hasMessages: false };
   try {
@@ -216,6 +262,11 @@ const clients = new Set();
 let sessionMetadataCache = {};
 let lastMetadataRefresh = 0;
 const METADATA_CACHE_TTL = 10000; // 10 seconds
+// Watcher-driven invalidation. `change` events (append to existing jsonl) only
+// dirty the one path so we can do a targeted refresh; `add` / `unlink` events
+// are structural and force a full rescan.
+const dirtyMetadataPaths = new Set();
+let metadataNeedsFullScan = true;
 
 const SAFE_ID_RE = /^[a-zA-Z0-9_-]+$/;
 function isSafeId(id) {
@@ -381,10 +432,50 @@ function readRecentMessages(jsonlPath, limit = 10) {
 /**
  * Scan all project directories to find session JSONL files and extract slugs
  */
+// Returns false when sessionId is unknown — caller must promote to full scan.
+function refreshSessionMetadataPath(jsonlPath) {
+  const sessionId = path.basename(jsonlPath, '.jsonl');
+  if (!isSafeId(sessionId)) return false;
+  const existing = sessionMetadataCache[sessionId];
+  if (!existing) return false;
+  let info;
+  try {
+    info = readSessionInfoFromJsonl(jsonlPath);
+  } catch (_) {
+    return false;
+  }
+  // Shadow JSONLs (continued from a worktree) hold only custom-title / agent-
+  // name records — no projectPath. Don't let a shadow clobber the real entry.
+  const shadow = existing.project && !info.projectPath;
+  if (shadow) {
+    if (!existing.slug && info.slug) existing.slug = info.slug;
+    if (!existing.customTitle && info.customTitle) existing.customTitle = info.customTitle;
+    return true;
+  }
+  if (info.slug) existing.slug = info.slug;
+  if (info.cwd) existing.cwd = info.cwd;
+  if (info.gitBranch) existing.gitBranch = info.gitBranch;
+  if (info.customTitle) existing.customTitle = info.customTitle;
+  return true;
+}
+
 function loadSessionMetadata() {
   const now = Date.now();
-  if (now - lastMetadataRefresh < METADATA_CACHE_TTL) {
-    return sessionMetadataCache;
+
+  if (!metadataNeedsFullScan && now - lastMetadataRefresh < METADATA_CACHE_TTL) {
+    if (dirtyMetadataPaths.size > 0) {
+      for (const p of dirtyMetadataPaths) {
+        if (!refreshSessionMetadataPath(p)) {
+          // Unknown sessionId — structural change snuck in. Promote to full.
+          metadataNeedsFullScan = true;
+          break;
+        }
+      }
+      dirtyMetadataPaths.clear();
+      if (!metadataNeedsFullScan) return sessionMetadataCache;
+    } else {
+      return sessionMetadataCache;
+    }
   }
 
   const metadata = {};
@@ -515,6 +606,8 @@ function loadSessionMetadata() {
 
   sessionMetadataCache = metadata;
   lastMetadataRefresh = now;
+  metadataNeedsFullScan = false;
+  dirtyMetadataPaths.clear();
   return metadata;
 }
 
@@ -531,6 +624,51 @@ function getPlanInfo(slug) {
   }
 }
 
+// Hide wakeups whose fire time is more than this far in the past — long /loop
+// sessions otherwise produce dozens of stale entries that drown the badge.
+const WAKEUP_FIRED_GRACE_MS = 5 * 60 * 1000;
+
+function isWakeupActive(w, now = Date.now()) {
+  if (!w || !w.timestamp || w.delaySeconds == null) return true;
+  const fireMs = new Date(w.timestamp).getTime() + w.delaySeconds * 1000;
+  return (now - fireMs) <= WAKEUP_FIRED_GRACE_MS;
+}
+
+function filterActiveLoopInfo(info) {
+  const now = Date.now();
+  return {
+    wakeups: info.wakeups.filter(w => isWakeupActive(w, now)),
+    crons: info.crons
+  };
+}
+
+// Per-path incremental scan state. Populated lazily on first access and
+// updated in place; the projectsWatcher event handler keeps entries warm so
+// the request path does O(1) work in steady state.
+const loopInfoStateByPath = new Map();
+
+function refreshLoopInfoState(jsonlPath) {
+  if (!jsonlPath) return null;
+  const prev = loopInfoStateByPath.get(jsonlPath);
+  const next = updateLoopInfo(jsonlPath, prev);
+  if (next) loopInfoStateByPath.set(jsonlPath, next);
+  return next;
+}
+
+function getLoopInfoSummary(meta) {
+  const empty = { wakeupCount: 0, cronCount: 0, latest: null };
+  if (!meta?.jsonlPath) return empty;
+  try {
+    const state = refreshLoopInfoState(meta.jsonlPath);
+    const filtered = filterActiveLoopInfo(buildLoopInfoFromState(state));
+    return {
+      wakeupCount: filtered.wakeups.length,
+      cronCount: filtered.crons.length,
+      latest: filtered.wakeups[filtered.wakeups.length - 1] || filtered.crons[filtered.crons.length - 1] || null
+    };
+  } catch (_) { return empty; }
+}
+
 function getSessionDisplayName(sessionId, meta) {
   if (meta?.customTitle) return meta.customTitle;
   if (meta?.slug) return meta.slug;
@@ -548,7 +686,7 @@ function buildSessionObject(id, meta, overrides = {}) {
     project: meta.project || null,
     cwd: meta.cwd || null,
     description: meta.description || null,
-    gitBranch: meta.gitBranch || null,
+    gitBranch: resolveSessionGitBranch(meta),
     customTitle: meta.customTitle || null,
     taskCount: 0,
     completed: 0,
@@ -568,6 +706,7 @@ function buildSessionObject(id, meta, overrides = {}) {
     projectDir: meta.jsonlPath ? path.dirname(meta.jsonlPath) : null,
     contextStatus: getContextStatus(id, meta),
     ...getPlanInfo(meta.slug),
+    loopInfo: getLoopInfoSummary(meta),
     ...overrides,
     // Remove internal-only field
     _logStat: undefined,
@@ -969,6 +1108,23 @@ app.get('/api/sessions/:sessionId/plan', async (req, res) => {
   }
 });
 
+app.get('/api/sessions/:sessionId/loop', (req, res) => {
+  try {
+    const metadata = loadSessionMetadata();
+    const meta = metadata[req.params.sessionId];
+    if (!meta?.jsonlPath) return res.json({ wakeups: [], crons: [] });
+    const state = refreshLoopInfoState(meta.jsonlPath);
+    const filtered = filterActiveLoopInfo(buildLoopInfoFromState(state));
+    res.json({
+      wakeups: [...filtered.wakeups].reverse(),
+      crons: [...filtered.crons].reverse()
+    });
+  } catch (error) {
+    console.error('Error reading loop info:', error);
+    res.status(500).json({ error: 'Failed to read loop info' });
+  }
+});
+
 function openInEditor(...targets) {
   const editor = process.env.EDITOR || 'code';
   spawn(editor, ['-n', ...targets], { shell: true, stdio: 'ignore', detached: true }).unref();
@@ -1218,6 +1374,20 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
   }
 });
 
+function clearWaitingFile(sessionId) {
+  try { unlinkSync(path.join(AGENT_ACTIVITY_DIR, sessionId, '_waiting.json')); }
+  catch (e) { if (e.code !== 'ENOENT') throw e; }
+}
+
+app.post('/api/sessions/:sessionId/waiting/discard', (req, res) => {
+  try {
+    clearWaitingFile(resolveSessionId(req.params.sessionId));
+    res.json({ ok: true });
+  } catch (e) {
+    res.status(500).json({ error: 'Failed to discard waiting' });
+  }
+});
+
 app.post('/api/sessions/:sessionId/agents/:agentId/stop', (req, res) => {
   const sessionId = resolveSessionId(req.params.sessionId);
   const agentId = sanitizeAgentId(req.params.agentId);
@@ -1229,9 +1399,7 @@ app.post('/api/sessions/:sessionId/agents/:agentId/stop', (req, res) => {
     agent.stoppedAt = new Date().toISOString();
     const stopEvt = { agentId, type: agent.type, event: 'user-stop', status: 'stopped', stoppedAt: agent.stoppedAt, updatedAt: agent.stoppedAt };
     writeFileSync(agentFile, readFileSync(agentFile, 'utf8') + JSON.stringify(stopEvt) + '\n', 'utf8'); // sync — response depends on write
-    // Also remove waiting state if present
-    const waitingFile = path.join(AGENT_ACTIVITY_DIR, sessionId, '_waiting.json');
-    if (existsSync(waitingFile)) unlinkSync(waitingFile);
+    clearWaitingFile(sessionId);
     res.json({ ok: true });
   } catch (e) {
     res.status(500).json({ error: 'Failed to stop agent' });
@@ -1252,30 +1420,122 @@ function subagentJsonlPath(meta, agentId) {
 }
 
 // Claude Code can scatter a session's records across multiple project dirs
-// (e.g. main repo + worktree), so the subagent JSONL may live under a
-// different project dir than meta.jsonlPath. Fall back to scanning when the
-// derived path is missing.
+// (e.g. main repo + worktree) and across sibling sessionId dirs when a
+// session is forked/resumed — the subagent JSONL stays under the original
+// parent sessionId. Fall back to scanning when the derived path is missing.
 const subagentPathCache = new Map();
+function findSubagentJsonlInProject(projPath, sessionId, agentId) {
+  const sameSid = path.join(projPath, sessionId, 'subagents', 'agent-' + agentId + '.jsonl');
+  if (existsSync(sameSid)) return sameSid;
+  let sessions;
+  try { sessions = readdirSync(projPath, { withFileTypes: true }); } catch { return null; }
+  for (const sess of sessions) {
+    if (!sess.isDirectory() || sess.name === sessionId) continue;
+    const candidate = path.join(projPath, sess.name, 'subagents', 'agent-' + agentId + '.jsonl');
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
 function resolveSubagentJsonl(meta, sessionId, agentId) {
   const primary = subagentJsonlPath(meta, agentId);
   if (existsSync(primary)) return primary;
   const key = sessionId + '/' + agentId;
-  if (subagentPathCache.has(key)) return subagentPathCache.get(key) || primary;
+  const cached = subagentPathCache.get(key);
+  if (cached) return cached;
   let found = null;
-  try {
-    for (const entry of readdirSync(PROJECTS_DIR, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue;
-      const candidate = path.join(
-        PROJECTS_DIR, entry.name, sessionId,
-        'subagents', 'agent-' + agentId + '.jsonl'
-      );
-      if (existsSync(candidate)) { found = candidate; break; }
-    }
-  } catch (_) { /* projects dir missing */ }
-  subagentPathCache.set(key, found);
+  const parent = lookupParentSession(sessionId);
+  if (parent.parentSessionId && parent.parentJsonlPath) {
+    const projDir = path.dirname(parent.parentJsonlPath);
+    const candidate = path.join(projDir, parent.parentSessionId, 'subagents', 'agent-' + agentId + '.jsonl');
+    if (existsSync(candidate)) found = candidate;
+  }
+  if (!found) {
+    try {
+      for (const proj of readdirSync(PROJECTS_DIR, { withFileTypes: true })) {
+        if (!proj.isDirectory()) continue;
+        found = findSubagentJsonlInProject(path.join(PROJECTS_DIR, proj.name), sessionId, agentId);
+        if (found) break;
+      }
+    } catch (_) { /* projects dir missing */ }
+  }
+  if (found) subagentPathCache.set(key, found);
   return found || primary;
 }
 
+// Claude Code marks fork lineage in two ways:
+//   1. `logicalParentUuid` on a system record (when present) points to a uuid
+//      in the parent session's JSONL.
+//   2. When absent, the fork copies the parent's early records verbatim, so
+//      the earliest `uuid` in this session also exists (same uuid+timestamp)
+//      in the parent's JSONL.
+// We try (1) first, then fall back to (2).
+const parentSessionCache = new Map();
+// Both anchor signals live in the first few records (system marker on top,
+// fork-copy starts at line 0), so cap the scan instead of reading the whole file.
+const FORK_ANCHOR_SCAN_LINES = 10;
+function findForkAnchorUuid(jsonlPath) {
+  let text;
+  try { text = readFileSync(jsonlPath, 'utf8'); } catch { return null; }
+  let firstUuid = null;
+  let scanned = 0;
+  for (const l of text.split('\n')) {
+    if (!l) continue;
+    if (scanned++ >= FORK_ANCHOR_SCAN_LINES) break;
+    try {
+      const d = JSON.parse(l);
+      if (d.logicalParentUuid) return d.logicalParentUuid;
+      if (!firstUuid && d.uuid) firstUuid = d.uuid;
+    } catch { /* skip malformed */ }
+  }
+  return firstUuid;
+}
+function findSessionContainingUuid(projectDir, targetUuid, excludeJsonlPath) {
+  let files;
+  try { files = readdirSync(projectDir); } catch { return null; }
+  const candidates = [];
+  for (const f of files) {
+    if (!f.endsWith('.jsonl')) continue;
+    const fp = path.join(projectDir, f);
+    if (fp === excludeJsonlPath) continue;
+    let text;
+    try { text = readFileSync(fp, 'utf8'); } catch { continue; }
+    if (!text.includes(targetUuid)) continue;
+    for (const l of text.split('\n')) {
+      if (!l || !l.includes(targetUuid)) continue;
+      try {
+        const d = JSON.parse(l);
+        if (d.uuid === targetUuid && d.sessionId) {
+          let mtime = 0;
+          try { mtime = statSync(fp).mtimeMs; } catch { /* ignore */ }
+          candidates.push({ parentSessionId: d.sessionId, parentJsonlPath: fp, mtime });
+          break;
+        }
+      } catch { /* skip */ }
+    }
+  }
+  if (!candidates.length) return null;
+  candidates.sort((a, b) => a.mtime - b.mtime);
+  const { parentSessionId, parentJsonlPath } = candidates[0];
+  return { parentSessionId, parentJsonlPath };
+}
+function lookupParentSession(sessionId) {
+  if (parentSessionCache.has(sessionId)) return parentSessionCache.get(sessionId);
+  const meta = loadSessionMetadata()[sessionId];
+  const result = { parentSessionId: null, parentJsonlPath: null };
+  if (meta?.jsonlPath) {
+    const anchorUuid = findForkAnchorUuid(meta.jsonlPath);
+    if (anchorUuid) {
+      const hit = findSessionContainingUuid(path.dirname(meta.jsonlPath), anchorUuid, meta.jsonlPath);
+      if (hit) Object.assign(result, hit);
+    }
+  }
+  if (result.parentSessionId) parentSessionCache.set(sessionId, result);
+  return result;
+}
+app.get('/api/sessions/:sessionId/parent', (req, res) => {
+  res.json(lookupParentSession(resolveSessionId(req.params.sessionId)));
+});
+
 app.get('/api/sessions/:sessionId/agents/:agentId/messages', (req, res) => {
   const sessionId = resolveSessionId(req.params.sessionId);
   const agentId = sanitizeAgentId(req.params.agentId);
@@ -1418,6 +1678,19 @@ app.get('/api/sessions/:sessionId/tool-result/:toolUseId', (req, res) => {
   res.json({ toolUseId: req.params.toolUseId, content });
 });
 
+app.get('/api/sessions/:sessionId/user-image/:msgUuid/:blockIndex', (req, res) => {
+  const metadata = loadSessionMetadata();
+  const meta = metadata[req.params.sessionId];
+  const jsonlPath = meta?.jsonlPath;
+  if (!jsonlPath) return res.status(404).end();
+  const img = readUserImage(jsonlPath, req.params.msgUuid, req.params.blockIndex);
+  if (!img) return res.status(404).end();
+  const buf = Buffer.from(img.data, 'base64');
+  res.setHeader('Content-Type', img.mediaType);
+  res.setHeader('Cache-Control', 'no-store');
+  res.end(buf);
+});
+
 app.get('/api/version', (req, res) => {
   const pkg = require('./package.json');
   res.json({ version: pkg.version });
@@ -1818,13 +2091,27 @@ console.log(`Watching for team changes in: ${TEAMS_DIR}`);
 const projectsWatcher = chokidar.watch(PROJECTS_DIR, {
   persistent: true,
   ignoreInitial: true,
-  depth: 2
+  depth: 2,
+  awaitWriteFinish: { stabilityThreshold: 150, pollInterval: 50 }
 });
 
 projectsWatcher.on('all', (event, filePath) => {
-  if ((event === 'add' || event === 'change' || event === 'unlink') && filePath.endsWith('.jsonl')) {
-    // Invalidate cache on any change
-    lastMetadataRefresh = 0;
+  if (event !== 'add' && event !== 'change' && event !== 'unlink') return;
+  if (filePath.endsWith('.jsonl')) {
+    if (event === 'unlink') {
+      loopInfoStateByPath.delete(filePath);
+    } else {
+      // Warm the incremental scan state so the next request does no IO.
+      try { refreshLoopInfoState(filePath); } catch (_) {}
+    }
+    // add/unlink reshape the session set — promote to full rescan.
+    if (event === 'change') dirtyMetadataPaths.add(filePath);
+    else metadataNeedsFullScan = true;
+    broadcast({ type: 'metadata-update' });
+  } else if (path.basename(filePath) === 'sessions-index.json') {
+    // Index holds description / created / customTitle that the targeted
+    // refresh doesn't touch — promote to full rescan.
+    metadataNeedsFullScan = true;
     broadcast({ type: 'metadata-update' });
   }
 });
@@ -1837,7 +2124,9 @@ const plansWatcher = chokidar.watch(PLANS_DIR, {
 
 plansWatcher.on('all', (event, filePath) => {
   if ((event === 'add' || event === 'change' || event === 'unlink') && filePath.endsWith('.md')) {
-    lastMetadataRefresh = 0;
+    // Plan files don't affect cached session metadata — getPlanInfo is called
+    // fresh from buildSessionObject on every list build. The broadcast alone
+    // is enough to trigger a client refetch.
     broadcast({ type: 'metadata-update' });
     if (event === 'change') {
       const slug = path.basename(filePath, '.md');
@@ -1920,7 +2209,6 @@ contextStatusWatcher.on('all', (event, filePath) => {
   }
 });
 
-const CTX_CLEANUP_MAX_AGE_MS = 2 * 60 * 60 * 1000;
 async function cleanupContextStatus() {
   try {
     const entries = await fs.readdir(CONTEXT_STATUS_DIR);
@@ -1939,10 +2227,6 @@ async function cleanupContextStatus() {
   } catch (e) { /* dir may not exist */ }
 }
 
-// Cleanup agent-activity folders older than 2 days
-const CLEANUP_MAX_AGE_MS = 2 * 24 * 60 * 60 * 1000;
-const CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
-
 async function cleanupAgentActivity() {
   try {
     const entries = await fs.readdir(AGENT_ACTIVITY_DIR, { withFileTypes: true });