claude-code-kanban 4.31.1 → 5.1.0

package/server.js

@@ -27,7 +27,7 @@ const {
   readScratchpadCreations,
   extractPromptFromTranscript,
   extractModelFromTranscript,
-  extractStructuredResultFromTranscript,
+  extractAgentResultFromTranscript,
   extractTranscriptStats,
   readFullToolResult,
   readUserImage,
@@ -63,7 +63,7 @@ if (process.argv.includes("--install") || process.argv.includes("--uninstall"))
 function startServer() {
 
 const app = express();
-const PORT = process.env.PORT || 3541;
+const PORT = parseInt(getArgValue('port') || process.env.PORT || '3541', 10);
 
 // Mounted before express.json() so a rejected request never buffers a body, and
 // before the /api catch-all so no route escapes the check.
@@ -94,6 +94,7 @@ const LINKED_DOCS_FILE = path.join(CCK_DIR, 'linked-docs.json');
 const SERVER_INFO_FILE = path.join(CCK_DIR, 'server.json');
 const TERMINAL_TOKENS_DIR = path.join(CCK_DIR, 'terminal-tokens');
 const SESSION_CACHE_FILE = path.join(CCK_DIR, 'session-cache.json');
+const TERMINALS_FILE = path.join(CCK_DIR, 'terminals.json');
 // os.tmpdir() can be an 8.3 short path on Windows; transcripts record the long form.
 const TEMP_ROOT = (() => {
   try { return realpathSync.native(os.tmpdir()); } catch { return os.tmpdir(); }
@@ -214,7 +215,7 @@ function readAgentJsonl(filePath) {
 }
 
 // Agent-activity record files in a session dir, excluding the `_`-prefixed sidecars
-// (_waiting.json, _name-*). Returns [] if the dir is missing/unreadable.
+// (_waiting.json, _stop.json, _name-*). Returns [] if the dir is missing/unreadable.
 function listAgentFiles(agentDir) {
   try {
     return readdirSync(agentDir).filter((f) => f.endsWith('.jsonl') && !f.startsWith('_'));
@@ -374,13 +375,18 @@ function getSessionLogStat(meta) {
 }
 
 function checkAgentStatus(agentDir, stale, logMtime, isTeam) {
-  const result = { hasActive: false, hasRunning: false, waitingForUser: null };
-  if (!existsSync(agentDir)) return result;
-  result.waitingForUser = checkWaitingForUser(agentDir, logMtime);
+  const result = { hasActive: false, hasRunning: false, waitingForUser: null, unread: false };
+  let names;
+  try { names = readdirSync(agentDir); } catch { return result; }
+  if (names.includes('_waiting.json')) result.waitingForUser = checkWaitingForUser(agentDir, logMtime);
   if (result.waitingForUser) result.hasActive = true;
-  if (stale && !isTeam) return result;
+  const stopped = names.includes('_stop.json');
+  if (stale && !isTeam) {
+    result.unread = stopped;
+    return result;
+  }
   try {
-    for (const file of readdirSync(agentDir).filter(f => f.endsWith('.jsonl') && !f.startsWith('_'))) {
+    for (const file of names.filter(f => f.endsWith('.jsonl') && !f.startsWith('_'))) {
       try {
         const agent = readAgentJsonl(path.join(agentDir, file));
         // Idle agents never mark a session active (an idle teammate lingers and
@@ -393,6 +399,7 @@ function checkAgentStatus(agentDir, stale, logMtime, isTeam) {
       } catch { /* skip invalid */ }
     }
   } catch { /* ignore */ }
+  result.unread = stopped && !result.hasRunning;
   return result;
 }
 
@@ -481,7 +488,7 @@ function loadLiveSessions(fresh = false) {
         try {
           const s = JSON.parse(readFileSync(path.join(SESSIONS_DIR, file), 'utf8'));
           if (s?.sessionId && s.kind === 'interactive') {
-            sessions.push({ sessionId: s.sessionId, pid: s.pid || null, cwd: s.cwd || null, startedAt: s.startedAt || 0, status: s.status || null });
+            sessions.push({ sessionId: s.sessionId, pid: s.pid || null, cwd: s.cwd || null, startedAt: s.startedAt || 0, status: s.status || null, name: s.name || null });
           }
         } catch (_) { /* skip invalid */ }
       }
@@ -502,6 +509,12 @@ function isRegistryIdle(sessionId) {
   return live?.status === 'idle';
 }
 
+// The registry name is the address SendMessage and ListAgents use.
+function getPeerName(sessionId) {
+  const live = loadLiveSessions().find((s) => s.sessionId === sessionId && s.name && s.pid && isPidAlive(s.pid));
+  return live?.name ?? null;
+}
+
 // A registry file outlives a crashed claude, so the pid is probed rather than trusted.
 function isSessionProcessAlive(sessionId, exceptPid = null) {
   return loadLiveSessions().some((s) => {
@@ -614,9 +627,8 @@ app.use(express.json());
 
 // #region STATIC
 
-app.get('/hub-config', (_req, res) => {
-  res.json({ enabled: !!process.env.CLAUDE_HUB, url: process.env.HUB_URL || null });
-});
+// Under a hub, the hub hands over its SDK. Alone, public/vendor/claude-hub-sdk.js is a stub.
+if (process.env.HUB_SDK_SERVER) require(process.env.HUB_SDK_SERVER).mount(app);
 
 // 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.
@@ -1152,6 +1164,7 @@ function buildSessionObject(id, meta, overrides = {}) {
   return {
     id,
     name: getSessionDisplayName(id, meta),
+    peerName: getPeerName(id),
     slug: meta.slug || null,
     project: meta.project || null,
     cwd: meta.cwd || null,
@@ -1171,6 +1184,7 @@ function buildSessionObject(id, meta, overrides = {}) {
     hasActiveAgents: false,
     hasRunningAgents: false,
     hasWaitingForUser: false,
+    unread: false,
     hasRecentLog: hasRecentLogActivity(id, logAge),
     hasRecentActivity: hasVisibleLogActivity(id, logAge),
     jsonlPath: meta.jsonlPath || null,
@@ -1268,6 +1282,7 @@ app.get('/api/sessions', async (req, res) => {
             hasActiveAgents: agentStatus.hasActive,
             hasRunningAgents: agentStatus.hasRunning,
             hasWaitingForUser: !!agentStatus.waitingForUser,
+            unread: agentStatus.unread,
             tasksDir: sessionPath,
             ...planInfo
           }));
@@ -1316,6 +1331,7 @@ app.get('/api/sessions', async (req, res) => {
               hasActiveAgents: agentStatus.hasActive,
               hasRunningAgents: agentStatus.hasRunning,
               hasWaitingForUser: !!agentStatus.waitingForUser,
+              unread: agentStatus.unread,
               tasksDir: customTaskDir,
               sharedTaskList: taskListName,
             }));
@@ -1354,6 +1370,7 @@ app.get('/api/sessions', async (req, res) => {
           hasActiveAgents: metaAgentStatus.hasActive,
           hasRunningAgents: metaAgentStatus.hasRunning,
           hasWaitingForUser: !!metaAgentStatus.waitingForUser,
+          unread: metaAgentStatus.unread,
         }));
       }
     }
@@ -1425,6 +1442,7 @@ app.get('/api/sessions', async (req, res) => {
                 hasActiveAgents: agentStatus.hasActive,
                 hasRunningAgents: agentStatus.hasRunning,
                 hasWaitingForUser: !!agentStatus.waitingForUser,
+                unread: agentStatus.unread,
               });
               attachTeamTasks(card, teamTaskDir, dir.name, counts);
               sessionsMap.set(leaderId, card);
@@ -1562,7 +1580,7 @@ app.get('/api/sessions', async (req, res) => {
     if (recentHours > 0) {
       const cutoff = Date.now() - recentHours * 3600 * 1000;
       const activity = projectActivity();
-      sessions = sessions.filter(s => (activity.get(s.project) || 0) > cutoff || includeIds.has(s.id));
+      sessions = sessions.filter(s => (activity.get(s.project) || 0) > cutoff || pinnedIds.has(s.id));
     }
 
     const paged = limit !== null && limit > 0;
@@ -2338,6 +2356,10 @@ app.get('/api/teams/:name', (req, res) => {
 });
 
 // API: Get agents for a session
+// The resultUnavailable latch is persisted on the agent record. Bump this when
+// extractAgentResultFromTranscript finds more, so agents latched earlier rescan once.
+const RESULT_SCAN = 2;
+
 app.get('/api/sessions/:sessionId/agents', (req, res) => {
   const sessionId = resolveSessionId(req.params.sessionId);
   const agentDir = path.join(AGENT_ACTIVITY_DIR, sessionId);
@@ -2498,22 +2520,23 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
     }
 
     // Workflow-spawned subagents given a schema end on a forced StructuredOutput
-    // tool call and never emit a text lastMessage — surface that structured result
-    // as the agent's response. Only stopped agents (complete transcript); latch
+    // tool call (background subagents on SubagentHandback) and never emit a text
+    // lastMessage — surface that result as the agent's response.
+    // Only stopped agents (complete transcript); latch
     // resultUnavailable so we tail-read at most once per agent. Workflow subagents
     // are exempt from the latch: the poll that flips them to "stopped" can beat the
     // transcript's final StructuredOutput line to disk, latching resultUnavailable
     // against an incomplete transcript — so always re-attempt for them, mirroring
     // the prompt/name/description reconcile above.
     const agentsNeedingResult = agents.filter(
-      (a) => !a.lastMessage && !isAgentLive(a) && (!a.resultUnavailable || a.type === 'workflow-subagent'),
+      (a) => !a.lastMessage && !isAgentLive(a) && (a.resultUnavailable !== RESULT_SCAN || a.type === 'workflow-subagent'),
     );
     if (agentsNeedingResult.length && meta.jsonlPath) {
       for (const agent of agentsNeedingResult) {
         let result = null;
-        try { result = extractStructuredResultFromTranscript(subagentJsonlForExtraction(meta, agent.agentId)); } catch (_) {}
+        try { result = extractAgentResultFromTranscript(subagentJsonlForExtraction(meta, agent.agentId)); } catch (_) {}
         if (result) agent.lastMessage = result;
-        else agent.resultUnavailable = true;
+        else agent.resultUnavailable = RESULT_SCAN;
         dirty.add(agent);
       }
     }
@@ -2570,20 +2593,29 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
   }
 });
 
-function clearWaitingFile(sessionId) {
-  try { unlinkSync(path.join(AGENT_ACTIVITY_DIR, sessionId, '_waiting.json')); }
+function clearActivityMarker(sessionId, file) {
+  try { unlinkSync(path.join(AGENT_ACTIVITY_DIR, sessionId, file)); }
   catch (e) { if (e.code !== 'ENOENT') throw e; }
 }
 
 app.post('/api/sessions/:sessionId/waiting/discard', (req, res) => {
   try {
-    clearWaitingFile(resolveSessionId(req.params.sessionId));
+    clearActivityMarker(resolveSessionId(req.params.sessionId), '_waiting.json');
     res.json({ ok: true });
   } catch {
     res.status(500).json({ error: 'Failed to discard waiting' });
   }
 });
 
+app.post('/api/sessions/:sessionId/read', (req, res) => {
+  try {
+    clearActivityMarker(resolveSessionId(req.params.sessionId), '_stop.json');
+    res.json({ ok: true });
+  } catch {
+    res.status(500).json({ error: 'Failed to mark session read' });
+  }
+});
+
 // UI-driven approvals: answers the ask approval-gate.sh is blocking on by
 // writing _decision-<id>.json next to the marker. The hook consumes and deletes
 // both files; a write for a hook that already gave up is accepted anyway (D13)
@@ -2619,7 +2651,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
-    clearWaitingFile(sessionId);
+    clearActivityMarker(sessionId, '_waiting.json');
     res.json({ ok: true });
   } catch {
     res.status(500).json({ error: 'Failed to stop agent' });
@@ -3187,6 +3219,32 @@ function isAllowedFolder(dir) {
   try { return known && statSync(dir).isDirectory(); } catch { return false; }
 }
 
+// Restore runs before the first full metadata scan, so until that scan has run a session's
+// folder is read from its own JSONL, by the same rules the scan uses.
+function resolveSessionFolder(id) {
+  if (lastMetadataRefresh || !isSafeId(id)) {
+    const meta = loadSessionMetadata()[id];
+    return meta ? meta.project || meta.cwd || null : null;
+  }
+  try {
+    for (const dir of readdirSync(PROJECTS_DIR, { withFileTypes: true })) {
+      if (!dir.isDirectory()) continue;
+      const jsonlPath = path.join(PROJECTS_DIR, dir.name, `${id}.jsonl`);
+      if (!existsSync(jsonlPath)) continue;
+      let indexProject = null;
+      try {
+        const index = JSON.parse(readFileSync(path.join(PROJECTS_DIR, dir.name, 'sessions-index.json'), 'utf8'));
+        indexProject = (index.entries || []).find((e) => e.projectPath)?.projectPath || null;
+      } catch {}
+      const info = readSessionInfoFromJsonl(jsonlPath);
+      const folder = indexProject || info.projectPath || info.cwd;
+      if (folder) return folder;
+    }
+  } catch {}
+  const meta = loadSessionMetadata()[id];
+  return meta ? meta.project || meta.cwd || null : null;
+}
+
 let listenPort = null;
 const terminal = createTerminalService({
   config: readTerminalConfig({ getArgValue }),
@@ -3195,14 +3253,15 @@ const terminal = createTerminalService({
   claudeDir: CLAUDE_DIR,
   isDefaultDir: isDefaultClaudeDir(CLAUDE_DIR),
   token: process.env.CCK_TERMINAL_TOKEN,
+  load: () => {
+    try { return JSON.parse(readFileSync(TERMINALS_FILE, 'utf8')); } catch { return null; }
+  },
+  save: (data) => writeJsonAtomic(TERMINALS_FILE, data),
   which: whichSync,
   isLiveElsewhere: isSessionProcessAlive,
   // The project, not the last cwd: `claude --resume` finds a session under the
   // project dir it started in, and cwd drifts into subdirectories.
-  resolveCwd: (id) => {
-    const meta = loadSessionMetadata()[id];
-    return meta ? meta.project || meta.cwd || null : null;
-  },
+  resolveCwd: resolveSessionFolder,
   isAllowedFolder,
   liveSessions: () => loadLiveSessions(true),
   onChange: () => broadcast({ type: 'terminals-update', ids: terminal.list().map((t) => t.id) }),
@@ -4027,7 +4086,7 @@ const AGENT_FILE_CAP = 20;
 
 agentActivityWatcher.on('all', (event, filePath) => {
   const base = path.basename(filePath);
-  const isAgentEvent = filePath.endsWith('.jsonl') || base === '_waiting.json';
+  const isAgentEvent = filePath.endsWith('.jsonl') || base === '_waiting.json' || base === '_stop.json';
   if ((event === 'add' || event === 'change' || event === 'unlink') && isAgentEvent) {
     const relativePath = path.relative(AGENT_ACTIVITY_DIR, filePath);
     const sessionId = relativePath.split(path.sep)[0];
@@ -4048,7 +4107,8 @@ agentActivityWatcher.on('all', (event, filePath) => {
         }
       } catch { /* ignore */ }
     }
-    broadcast({ type: 'agent-update', sessionId });
+    const unreadOnly = base === '_stop.json';
+    broadcast({ type: 'agent-update', sessionId, unreadOnly });
     // For team sessions, also broadcast with team name so frontend picks it up
     if (existsSync(TEAMS_DIR)) {
       try {
@@ -4056,7 +4116,7 @@ agentActivityWatcher.on('all', (event, filePath) => {
         for (const td of teamDirs) {
           const cfg = loadTeamConfig(td.name);
           if (cfg && cfg.leadSessionId === sessionId) {
-            broadcast({ type: 'agent-update', sessionId: td.name });
+            broadcast({ type: 'agent-update', sessionId: td.name, unreadOnly });
             break;
           }
         }
@@ -4210,6 +4270,7 @@ async function prewarmCaches() {
     if (process.argv.includes('--open')) {
       import('open').then(open => open.default(`http://localhost:${actualPort}`));
     }
+    terminal.restore();
     setTimeout(startPrewarm, PREWARM_FALLBACK_MS).unref();
   };