claude-code-kanban 3.2.4 → 3.4.0

package/public/style.css

@@ -739,6 +739,10 @@ body::before {
   background-position: top;
   font-size: 10px;
   color: var(--text-muted);
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
 }
 
 .sidebar-footer a {
@@ -747,6 +751,11 @@ body::before {
   transition: color 0.15s;
 }
 
+.sidebar-footer .footer-limits strong {
+  color: var(--text-secondary);
+  font-weight: 600;
+}
+
 .sidebar-footer a:hover {
   color: var(--text-secondary);
 }
@@ -2489,6 +2498,28 @@ body::before {
   cursor: default;
 }
 
+.linked-docs-badge,
+.bookmarks-badge {
+  display: inline-flex;
+  align-items: center;
+  gap: 2px;
+  font-size: 10px;
+  padding: 2px 6px;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  color: var(--text-secondary);
+  cursor: pointer;
+  flex-shrink: 0;
+  line-height: 1;
+}
+
+.linked-docs-badge:hover,
+.bookmarks-badge:hover {
+  border-color: var(--accent);
+  color: var(--text-primary);
+}
+
 /* #endregion */
 
 /* #region PERMISSION_PENDING */
@@ -2689,6 +2720,68 @@ body.light .msg-assistant .msg-text {
   max-height: 92vh;
 }
 
+.modal.preview-modal-dialog {
+  width: 90vw;
+  max-width: 1200px;
+  max-height: 90vh;
+  display: flex;
+  flex-direction: column;
+}
+
+.modal.preview-modal-dialog.fullscreen {
+  width: 90vw;
+  max-width: 90vw;
+  height: 90vh;
+  max-height: 90vh;
+}
+
+.preview-fm {
+  margin: 0 0 14px;
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  background: var(--bg-elevated, rgba(127, 127, 127, 0.06));
+  font-family: var(--font-mono, ui-monospace, SFMono-Regular, Menlo, Consolas, monospace);
+  font-size: 11px;
+}
+
+.preview-fm > summary {
+  cursor: pointer;
+  padding: 6px 10px;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  font-size: 10px;
+  user-select: none;
+}
+
+.preview-fm[open] > summary {
+  border-bottom: 1px solid var(--border);
+}
+
+.preview-fm .fm-grid {
+  padding: 8px 10px;
+  display: grid;
+  gap: 4px 12px;
+}
+
+.preview-fm .fm-row {
+  display: grid;
+  grid-template-columns: minmax(80px, 140px) 1fr;
+  gap: 12px;
+  align-items: baseline;
+}
+
+.preview-fm .fm-k {
+  color: var(--accent, #7aa2f7);
+  font-weight: 600;
+}
+
+.preview-fm .fm-v {
+  color: var(--text, inherit);
+  word-break: break-word;
+  white-space: pre-wrap;
+}
+
 .modal-sm {
   max-width: 440px;
 }

package/server.js

@@ -15,19 +15,22 @@ const {
   readMessagesPage: _readMessagesPageUncached,
   readSessionInfoFromJsonl,
   buildAgentProgressMap,
+  buildSessionDigest,
   readCompactSummaries,
   findTerminatedTeammates,
-  extractPromptFromTranscript
+  extractPromptFromTranscript,
+  extractModelFromTranscript
 } = require('./lib/parsers');
 
-const isSetupCommand = process.argv.includes('--install') || process.argv.includes('--uninstall');
-
-if (isSetupCommand) {
-  const { runInstall, runUninstall } = require('./install');
-  (process.argv.includes('--install') ? runInstall() : runUninstall())
+if (process.argv.includes("--install") || process.argv.includes("--uninstall")) {
+  const { runInstall, runUninstall } = require("./install");
+  (process.argv.includes("--install") ? runInstall() : runUninstall())
     .then(() => process.exit(0))
     .catch(e => { console.error(e.message); process.exit(1); });
+  return;
 }
+if (require("./cli").runCli(process.argv)) return;
+
 
 const app = express();
 const PORT = process.env.PORT || 3456;
@@ -79,7 +82,10 @@ const WAITING_RESOLVE_GRACE_MS = 15000;
 
 function persistAgent(dir, agent) {
   const file = path.join(dir, agent.agentId + '.json');
-  fs.writeFile(file, JSON.stringify(agent), 'utf8').catch(() => {});
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFile(tmp, JSON.stringify(agent), 'utf8')
+    .then(() => fs.rename(tmp, file))
+    .catch(() => { fs.unlink(tmp).catch(() => {}); });
 }
 
 function checkWaitingForUser(agentDir, logMtime) {
@@ -209,8 +215,6 @@ app.use(express.static(path.join(__dirname, 'public')));
 const messageCache = new Map();
 const MESSAGE_CACHE_TTL = 5000;
 const MAX_CACHE_ENTRIES = 200;
-const progressMapCache = new Map();
-const terminatedCache = new Map();
 const compactSummaryCache = new Map();
 const taskCountsCache = new Map();
 const contextStatusCache = new Map();
@@ -324,12 +328,17 @@ function cachedByMtime(cache, cacheKey, filePath, loadFn, fallback) {
   } catch (_) { return fallback; }
 }
 
+const sessionDigestCache = new Map();
+function getSessionDigest(jsonlPath) {
+  return cachedByMtime(sessionDigestCache, jsonlPath, jsonlPath, () => buildSessionDigest(jsonlPath), { progressMap: {}, terminated: new Map() });
+}
+
 function getProgressMap(jsonlPath) {
-  return cachedByMtime(progressMapCache, jsonlPath, jsonlPath, () => buildAgentProgressMap(jsonlPath), {});
+  return getSessionDigest(jsonlPath).progressMap;
 }
 
 function getTerminatedTeammates(jsonlPath) {
-  return cachedByMtime(terminatedCache, jsonlPath, jsonlPath, () => findTerminatedTeammates(jsonlPath), new Set());
+  return getSessionDigest(jsonlPath).terminated;
 }
 
 function readRecentMessages(jsonlPath, limit = 10) {
@@ -791,6 +800,12 @@ app.get('/api/sessions', async (req, res) => {
     let sessions = Array.from(sessionsMap.values());
     sessions.sort((a, b) => new Date(b.modifiedAt) - new Date(a.modifiedAt));
 
+    // Apply project filter before limit so the limit is per-project
+    const projectFilter = req.query.project;
+    if (projectFilter) {
+      sessions = sessions.filter(s => s.project === projectFilter);
+    }
+
     // Apply limit if specified, but always include pinned sessions
     if (limit !== null && limit > 0) {
       const top = sessions.slice(0, limit);
@@ -958,10 +973,14 @@ app.post('/api/open-folder', (req, res) => {
   }
 });
 
-// API: Open content in editor as temp file
+// API: Open file in editor — either an existing path ({ file }) or content as a temp file ({ content, title })
 app.post('/api/open-in-editor', (req, res) => {
   try {
-    const { content, title } = req.body;
+    const { content, title, file } = req.body;
+    if (file) {
+      openInEditor(file);
+      return res.json({ success: true, path: file });
+    }
     if (!content) return res.status(400).json({ error: 'No content provided' });
 
     const safeName = (title || 'message').replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 50);
@@ -1049,14 +1068,11 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
       } catch (_) {}
     }
 
-    function persistPrompt(agent, prompt) {
-      agent.prompt = prompt;
-      persistAgent(agentDir, agent);
-    }
+    const dirty = new Set();
 
-    const agentsNeedingPrompt = agents.filter(a => !a.prompt);
-    const agentsNeedingName = agents.filter(a => !a.agentName);
-    const agentsNeedingDesc = agents.filter(a => !a.description);
+    const agentsNeedingPrompt = agents.filter(a => !a.prompt && !a.promptUnavailable);
+    const agentsNeedingName = agents.filter(a => !a.agentName && !a.agentNameUnavailable);
+    const agentsNeedingDesc = agents.filter(a => !a.description && !a.descriptionUnavailable);
     if ((agentsNeedingPrompt.length || agentsNeedingName.length || agentsNeedingDesc.length) && meta.jsonlPath) {
       let byAgentId = {};
       let nameByAgentId = {};
@@ -1072,37 +1088,34 @@ app.get('/api/sessions/:sessionId/agents', (req, res) => {
       for (const agent of agentsNeedingPrompt) {
         const prompt = byAgentId[agent.agentId]
           || (() => { try { return extractPromptFromTranscript(subagentJsonlPath(meta, agent.agentId)); } catch (_) { return null; } })();
-        if (prompt) persistPrompt(agent, prompt);
+        if (prompt) agent.prompt = prompt;
+        else agent.promptUnavailable = true;
+        dirty.add(agent);
       }
       for (const agent of agentsNeedingName) {
         if (nameByAgentId[agent.agentId]) agent.agentName = nameByAgentId[agent.agentId];
+        else agent.agentNameUnavailable = true;
+        dirty.add(agent);
       }
       for (const agent of agentsNeedingDesc) {
         if (descByAgentId[agent.agentId]) agent.description = descByAgentId[agent.agentId];
+        else agent.descriptionUnavailable = true;
+        dirty.add(agent);
       }
     }
 
-    const agentsNeedingModel = agents.filter(a => !a.model);
+    const agentsNeedingModel = agents.filter(a => !a.model && !a.modelUnavailable);
     if (agentsNeedingModel.length && meta.jsonlPath) {
       for (const agent of agentsNeedingModel) {
-        try {
-          const jsonl = subagentJsonlPath(meta, agent.agentId);
-          const content = readFileSync(jsonl, 'utf8');
-          for (const line of content.split('\n')) {
-            if (!line.trim()) continue;
-            try {
-              const obj = JSON.parse(line);
-              const model = obj.model || (obj.message && obj.message.model);
-              if (model) {
-                agent.model = model;
-                persistAgent(agentDir, agent);
-                break;
-              }
-            } catch (_) {}
-          }
-        } catch (_) {}
+        let model = null;
+        try { model = extractModelFromTranscript(subagentJsonlPath(meta, agent.agentId)); } catch (_) {}
+        if (model) agent.model = model;
+        else agent.modelUnavailable = true;
+        dirty.add(agent);
       }
     }
+
+    for (const agent of dirty) persistAgent(agentDir, agent);
     const teamColors = {};
     if (teamConfig?.members) {
       for (const m of teamConfig.members) {
@@ -1303,6 +1316,7 @@ app.get('/api/tasks/all', async (req, res) => {
     }
 
     const metadata = loadSessionMetadata();
+    const { listToSessions } = loadAllTaskMaps();
     const sessionDirs = readdirSync(TASKS_DIR, { withFileTypes: true })
       .filter(d => d.isDirectory());
 
@@ -1313,6 +1327,19 @@ app.get('/api/tasks/all', async (req, res) => {
       const taskFiles = readdirSync(sessionPath).filter(f => f.endsWith('.json'));
       const meta = metadata[sessionDir.name] || {};
 
+      // For custom task list directories (non-UUID dirs), resolve project from the
+      // mapped sessions since those dirs don't have their own metadata entry.
+      let project = meta.project || null;
+      if (!project) {
+        const mappedSessions = listToSessions[sessionDir.name];
+        if (mappedSessions) {
+          for (const [sid, info] of Object.entries(mappedSessions)) {
+            project = metadata[sid]?.project || info.project || null;
+            if (project) break;
+          }
+        }
+      }
+
       for (const file of taskFiles) {
         try {
           const task = JSON.parse(readFileSync(path.join(sessionPath, file), 'utf8'));
@@ -1320,7 +1347,7 @@ app.get('/api/tasks/all', async (req, res) => {
             ...task,
             sessionId: sessionDir.name,
             sessionName: getSessionDisplayName(sessionDir.name, meta),
-            project: meta.project || null
+            project
           });
         } catch (e) {
           // Skip invalid files
@@ -1431,6 +1458,91 @@ app.delete('/api/tasks/:sessionId/:taskId', async (req, res) => {
   }
 });
 
+// API: Markdown preview — read file and broadcast to clients
+async function readMarkdownFile(absPath) {
+  const ext = path.extname(absPath).toLowerCase();
+  if (ext !== '.md' && ext !== '.markdown') {
+    const err = new Error('Only .md/.markdown files are allowed');
+    err.status = 400;
+    throw err;
+  }
+  try {
+    return await fs.readFile(absPath, 'utf8');
+  } catch (e) {
+    if (e.code === 'ENOENT') { const err = new Error('File not found'); err.status = 404; throw err; }
+    if (e.code === 'EISDIR') { const err = new Error('Not a file'); err.status = 400; throw err; }
+    throw e;
+  }
+}
+
+function resolvePreviewPath(filePath) {
+  if (!filePath || typeof filePath !== 'string') return null;
+  return path.isAbsolute(filePath) ? filePath : path.resolve(filePath);
+}
+
+app.post('/api/preview', async (req, res) => {
+  try {
+    const { path: filePath, sessionId } = req.body || {};
+    const abs = resolvePreviewPath(filePath);
+    if (!abs) return res.status(400).json({ error: 'path is required' });
+    const content = await readMarkdownFile(abs);
+    broadcast({ type: 'preview:open', path: abs, content, sessionId: sessionId || null });
+    res.json({ success: true });
+  } catch (error) {
+    console.error('Error in /api/preview:', error);
+    res.status(error.status || 500).json({ error: error.message || 'Preview failed' });
+  }
+});
+
+app.get('/api/session/resolve', (req, res) => {
+  try {
+    const idArg = (req.query.id || '').toString();
+    if (!idArg) return res.status(400).json({ error: 'id is required' });
+    const metadata = loadSessionMetadata();
+    const ids = Object.keys(metadata);
+    if (Object.hasOwn(metadata, idArg)) {
+      const m = metadata[idArg];
+      return res.json({ id: idArg, customTitle: m?.customTitle || null });
+    }
+    const matches = ids.filter(id => id.startsWith(idArg));
+    if (matches.length === 0) return res.status(404).json({ matches: [] });
+    if (matches.length > 1) {
+      return res.status(409).json({
+        matches: matches.slice(0, 50).map(id => ({ id, customTitle: metadata[id]?.customTitle || null }))
+      });
+    }
+    const id = matches[0];
+    res.json({ id, customTitle: metadata[id]?.customTitle || null });
+  } catch (error) {
+    console.error('Error in /api/session/resolve:', error);
+    res.status(500).json({ error: error.message || 'Failed' });
+  }
+});
+
+app.post('/api/session/open', async (req, res) => {
+  try {
+    const { id } = req.body || {};
+    if (!id || typeof id !== 'string') return res.status(400).json({ error: 'id is required' });
+    broadcast({ type: 'session:open', id });
+    res.json({ success: true, id });
+  } catch (error) {
+    console.error('Error in /api/session/open:', error);
+    res.status(500).json({ error: error.message || 'Failed' });
+  }
+});
+
+app.get('/api/preview', async (req, res) => {
+  try {
+    const abs = resolvePreviewPath(req.query.path);
+    if (!abs) return res.status(400).json({ error: 'path is required' });
+    const content = await readMarkdownFile(abs);
+    res.json({ path: abs, content });
+  } catch (error) {
+    console.error('Error in GET /api/preview:', error);
+    res.status(error.status || 500).json({ error: error.message || 'Preview failed' });
+  }
+});
+
 // SSE endpoint for live updates
 app.get('/api/events', (req, res) => {
   res.setHeader('Content-Type', 'text/event-stream');
@@ -1468,9 +1580,6 @@ app.use('/api', (req, res) => {
   res.status(404).json({ error: 'Not found' });
 });
 
-// File watchers and server startup (skip for --install/--uninstall)
-if (!isSetupCommand) {
-
 // Watch for file changes (chokidar handles non-existent paths)
 const watcher = chokidar.watch(TASKS_DIR, {
   persistent: true,
@@ -1719,4 +1828,3 @@ const server = app.listen(PORT, () => {
     }
   });
 
-} // end if (!isSetupCommand)