claude-code-kanban 2.0.1 → 2.1.0-rc.2

package/public/sw.js

@@ -1,5 +1,5 @@
-const CACHE_NAME = 'cc-kanban-v1';
-const PRECACHE_URLS = ['/'];
+const CACHE_NAME = 'cc-kanban-v2';
+const PRECACHE_URLS = ['/', '/style.css', '/app.js'];
 
 let cachePromise = null;
 function getCache() {
@@ -9,7 +9,8 @@ function getCache() {
 
 function cacheResponse(request, response) {
   if (response.ok) {
-    getCache().then(cache => cache.put(request, response.clone()));
+    const clone = response.clone();
+    getCache().then(cache => cache.put(request, clone));
   }
   return response;
 }

package/server.js

@@ -51,10 +51,11 @@ const PROJECTS_DIR = path.join(CLAUDE_DIR, 'projects');
 const TEAMS_DIR = path.join(CLAUDE_DIR, 'teams');
 const PLANS_DIR = path.join(CLAUDE_DIR, 'plans');
 const AGENT_ACTIVITY_DIR = path.join(CLAUDE_DIR, 'agent-activity');
+const CONTEXT_STATUS_DIR = path.join(CLAUDE_DIR, 'context-status');
 
 const PERMISSION_TTL_MS = 1800000;
 const AGENT_TTL_MS = 3600000;
-const AGENT_STALE_MS = 300000;
+const AGENT_STALE_MS = 900000;
 
 const WAITING_RESOLVE_GRACE_MS = 15000;
 
@@ -73,8 +74,18 @@ function checkWaitingForUser(agentDir, logMtime) {
   return null;
 }
 
+function isGhostAgent(agent) {
+  if (agent.startedAt !== agent.updatedAt || agent.lastMessage) return false;
+  return (Date.now() - new Date(agent.startedAt).getTime()) >= AGENT_STALE_MS;
+}
+
+function getContextStatus(sessionId, meta) {
+  return contextStatusCache.get(sessionId) || (meta?.teamLeaderId ? contextStatusCache.get(meta.teamLeaderId) : null) || null;
+}
+
 function isAgentFresh(agent) {
   if (!agent.updatedAt) return true;
+  if (isGhostAgent(agent)) return false;
   return (Date.now() - new Date(agent.updatedAt).getTime()) < AGENT_TTL_MS;
 }
 
@@ -98,7 +109,6 @@ function checkAgentStatus(agentDir, stale, logMtime) {
         const agent = JSON.parse(readFileSync(path.join(agentDir, file), 'utf8'));
         if (isAgentFresh(agent)) {
           if (agent.status === 'active') { result.hasActive = true; result.hasRunning = true; }
-          else if (agent.status === 'idle') { result.hasActive = true; }
         }
         if (result.hasRunning && result.hasActive) break;
       } catch (e) { /* skip invalid */ }
@@ -171,6 +181,7 @@ const MAX_CACHE_ENTRIES = 200;
 const progressMapCache = new Map();
 const compactSummaryCache = new Map();
 const taskCountsCache = new Map();
+const contextStatusCache = new Map();
 
 function evictStaleCache(cache) {
   if (cache.size <= MAX_CACHE_ENTRIES) return;
@@ -200,7 +211,8 @@ function getTaskCounts(sessionPath) {
     } catch (e) { /* skip invalid */ }
   }
 
-  const result = { taskCount: taskFiles.length, completed, inProgress, pending, newestTaskMtime };
+  const taskCount = completed + inProgress + pending;
+  const result = { taskCount, completed, inProgress, pending, newestTaskMtime };
   taskCountsCache.set(sessionPath, result);
   return result;
 }
@@ -387,6 +399,9 @@ app.get('/api/sessions', async (req, res) => {
     const limitParam = req.query.limit || '20';
     const limit = limitParam === 'all' ? null : parseInt(limitParam, 10);
 
+    const pinnedParam = req.query.pinned;
+    const pinnedIds = pinnedParam ? new Set(pinnedParam.split(',').filter(Boolean)) : new Set();
+
     const metadata = loadSessionMetadata();
     const sessionsMap = new Map();
 
@@ -416,12 +431,12 @@ app.get('/api/sessions', async (req, res) => {
           }
 
           const isTeam = isTeamSession(entry.name);
-          const memberCount = isTeam ? (loadTeamConfig(entry.name)?.members?.length || 0) : 0;
+          const teamConfig = isTeam ? loadTeamConfig(entry.name) : null;
+          const memberCount = teamConfig?.members?.length || 0;
           const planInfo = getPlanInfo(meta.slug);
 
           const resolvedAgentDir = (() => {
-            const tc = loadTeamConfig(entry.name);
-            const rid = (tc && tc.leadSessionId) ? tc.leadSessionId : entry.name;
+            const rid = teamConfig?.leadSessionId || entry.name;
             return path.join(AGENT_ACTIVITY_DIR, rid);
           })();
           const agentStatus = checkAgentStatus(resolvedAgentDir, stale, logMtime);
@@ -450,6 +465,7 @@ app.get('/api/sessions', async (req, res) => {
             jsonlPath: meta.jsonlPath || null,
             tasksDir: sessionPath,
             projectDir: meta.jsonlPath ? path.dirname(meta.jsonlPath) : null,
+            contextStatus: getContextStatus(entry.name, meta),
             ...planInfo
           });
         }
@@ -495,6 +511,7 @@ app.get('/api/sessions', async (req, res) => {
           jsonlPath: meta.jsonlPath || null,
           tasksDir: null,
           projectDir: meta.jsonlPath ? path.dirname(meta.jsonlPath) : null,
+          contextStatus: getContextStatus(sessionId, meta),
           ...planInfo
         });
       }
@@ -572,9 +589,16 @@ app.get('/api/sessions', async (req, res) => {
       }
     }
 
+    // Backfill contextStatus for already-built sessions that are pinned
+    for (const pid of pinnedIds) {
+      const s = sessionsMap.get(pid);
+      if (s && !s.contextStatus) {
+        const meta = metadata[pid];
+        s.contextStatus = getContextStatus(pid, meta);
+      }
+    }
+
     // Ensure pinned sessions are in the map even if they weren't discovered
-    const pinnedParam = req.query.pinned;
-    const pinnedIds = pinnedParam ? new Set(pinnedParam.split(',').filter(Boolean)) : new Set();
     for (const pid of pinnedIds) {
       if (sessionsMap.has(pid)) continue;
       const meta = metadata[pid];
@@ -604,6 +628,7 @@ app.get('/api/sessions', async (req, res) => {
         jsonlPath: meta.jsonlPath || null,
         tasksDir: null,
         projectDir: meta.jsonlPath ? path.dirname(meta.jsonlPath) : null,
+        contextStatus: getContextStatus(pid, meta),
         ...getPlanInfo(meta.slug)
       });
     }
@@ -774,6 +799,7 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
     for (const file of files) {
       try {
         const agent = JSON.parse(readFileSync(path.join(agentDir, file), 'utf8'));
+        if (isGhostAgent(agent)) continue;
         const agentStale = !sessionStale && agent.updatedAt && (Date.now() - new Date(agent.updatedAt).getTime()) > AGENT_STALE_MS;
         if (!isAgentFresh(agent) || sessionStale || agentStale) {
           if (agent.status === 'active' || agent.status === 'idle') {
@@ -811,7 +837,7 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
 
 app.post('/api/sessions/:sessionId/agents/:agentId/stop', (req, res) => {
   const sessionId = resolveSessionId(req.params.sessionId);
-  const agentId = path.basename(req.params.agentId).replace(/[^a-zA-Z0-9_-]/g, '');
+  const agentId = sanitizeAgentId(req.params.agentId);
   const agentFile = path.join(AGENT_ACTIVITY_DIR, sessionId, agentId + '.json');
   if (!existsSync(agentFile)) return res.status(404).json({ error: 'Agent not found' });
   try {
@@ -828,6 +854,83 @@ app.post('/api/sessions/:sessionId/agents/:agentId/stop', (req, res) => {
   }
 });
 
+function sanitizeAgentId(raw) {
+  return path.basename(raw).replace(/[^a-zA-Z0-9_-]/g, '');
+}
+
+function subagentJsonlPath(meta, agentId) {
+  return path.join(
+    path.dirname(meta.jsonlPath),
+    path.basename(meta.jsonlPath, '.jsonl'),
+    'subagents',
+    'agent-' + agentId + '.jsonl'
+  );
+}
+
+app.get('/api/sessions/:sessionId/agents/:agentId/messages', (req, res) => {
+  const sessionId = resolveSessionId(req.params.sessionId);
+  const agentId = sanitizeAgentId(req.params.agentId);
+  const limit = Math.min(parseInt(req.query.limit, 10) || 50, 100);
+  const metadata = loadSessionMetadata();
+  const meta = metadata[sessionId];
+  if (!meta?.jsonlPath) return res.json({ messages: [], agentId });
+  const subagentJsonl = subagentJsonlPath(meta, agentId);
+  if (!existsSync(subagentJsonl)) return res.json({ messages: [], agentId });
+  const messages = readRecentMessages(subagentJsonl, limit);
+  res.json({ messages, agentId });
+});
+
+app.get('/api/sessions/:sessionId/agents/:agentId/messages/stream', (req, res) => {
+  const sessionId = resolveSessionId(req.params.sessionId);
+  const agentId = sanitizeAgentId(req.params.agentId);
+  const metadata = loadSessionMetadata();
+  const meta = metadata[sessionId];
+  if (!meta?.jsonlPath) {
+    res.status(404).json({ error: 'Session not found' });
+    return;
+  }
+  const subagentJsonl = subagentJsonlPath(meta, agentId);
+
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive'
+  });
+  res.write('\n');
+
+  let lastSize = existsSync(subagentJsonl) ? statSync(subagentJsonl).size : 0;
+
+  const watcher = chokidar.watch(subagentJsonl, {
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 }
+  });
+
+  let closed = false;
+  const cleanup = () => { if (!closed) { closed = true; watcher.close(); } };
+
+  function emitMessages() {
+    const messages = readRecentMessages(subagentJsonl, 50);
+    lastSize = statSync(subagentJsonl).size;
+    res.write(`event: agent-log-update\ndata: ${JSON.stringify({ messages, agentId })}\n\n`);
+  }
+
+  watcher.on('change', () => {
+    try {
+      if (statSync(subagentJsonl).size <= lastSize) return;
+      emitMessages();
+    } catch (_) {}
+  });
+
+  watcher.on('add', () => {
+    try { emitMessages(); } catch (_) {}
+  });
+
+  req.on('close', cleanup);
+  res.on('close', cleanup);
+  res.on('error', cleanup);
+});
+
 app.get('/api/sessions/:sessionId/messages', (req, res) => {
   const limit = Math.min(parseInt(req.query.limit, 10) || 10, 50);
   const metadata = loadSessionMetadata();
@@ -1052,6 +1155,10 @@ function broadcast(data) {
   }
 }
 
+app.get('/api/context-status', (req, res) => {
+  res.json(Object.fromEntries(contextStatusCache));
+});
+
 app.use('/api', (req, res) => {
   res.status(404).json({ error: 'Not found' });
 });
@@ -1181,6 +1288,48 @@ agentActivityWatcher.on('all', (event, filePath) => {
   }
 });
 
+// Watch context-status directory for statusline updates
+const contextStatusWatcher = chokidar.watch(CONTEXT_STATUS_DIR, {
+  persistent: true,
+  ignoreInitial: false,
+  depth: 0
+});
+
+contextStatusWatcher.on('all', (event, filePath) => {
+  if (!filePath.endsWith('.json')) return;
+  const sessionId = path.basename(filePath, '.json');
+  if (event === 'add' || event === 'change') {
+    try {
+      const data = JSON.parse(readFileSync(filePath, 'utf8'));
+      contextStatusCache.set(sessionId, data);
+      evictStaleCache(contextStatusCache);
+    } catch (e) { /* ignore malformed */ }
+    broadcast({ type: 'context-update', sessionId });
+  } else if (event === 'unlink') {
+    contextStatusCache.delete(sessionId);
+    broadcast({ type: 'context-update', sessionId });
+  }
+});
+
+const CTX_CLEANUP_MAX_AGE_MS = 2 * 60 * 60 * 1000;
+async function cleanupContextStatus() {
+  try {
+    const entries = await fs.readdir(CONTEXT_STATUS_DIR);
+    const now = Date.now();
+    for (const f of entries) {
+      if (!f.endsWith('.json')) continue;
+      try {
+        const fp = path.join(CONTEXT_STATUS_DIR, f);
+        const st = statSync(fp);
+        if (now - st.mtimeMs > CTX_CLEANUP_MAX_AGE_MS) {
+          await fs.unlink(fp);
+          contextStatusCache.delete(path.basename(f, '.json'));
+        }
+      } catch (e) { /* ignore */ }
+    }
+  } 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;
@@ -1205,7 +1354,9 @@ async function cleanupAgentActivity() {
 }
 
 cleanupAgentActivity();
+cleanupContextStatus();
 setInterval(cleanupAgentActivity, CLEANUP_INTERVAL_MS);
+setInterval(cleanupContextStatus, 30 * 60 * 1000);
 
 const server = app.listen(PORT, () => {
     const actualPort = server.address().port;