claude-code-kanban 3.2.2 → 3.2.4

package/lib/parsers.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const { readFileSync, existsSync, readdirSync, statSync } = fs;
 const path = require('path');
+const { StringDecoder } = require('string_decoder');
 
 function parseTask(raw) {
   const task = typeof raw === 'string' ? JSON.parse(raw) : raw;
@@ -171,52 +172,97 @@ function readCustomTitle(jsonlPath, existingStat) {
   }
 }
 
+const SCRAPE_CWD_RE = /"cwd"\s*:\s*"((?:[^"\\]|\\.)*)"/;
+const SCRAPE_SLUG_RE = /"slug"\s*:\s*"((?:[^"\\]|\\.)*)"/;
+const SCRAPE_GITBRANCH_RE = /"gitBranch"\s*:\s*"((?:[^"\\]|\\.)*)"/;
+
+function scrapeScalarFromBlob(blob, re) {
+  const m = blob.match(re);
+  if (!m) return null;
+  try { return JSON.parse(`"${m[1]}"`); } catch (e) { return null; }
+}
+
 function readSessionInfoFromJsonl(jsonlPath) {
   const result = { slug: null, projectPath: null, cwd: null, gitBranch: null, customTitle: null };
   let stat;
+  let fd;
+  // State shared across head-chunk parse, leftover flush, and tail parse.
+  let lastCwdFromHead = null;
+  const applyLine = (line) => {
+    try {
+      const data = JSON.parse(line);
+      if (data.slug) result.slug = data.slug;
+      if (data.cwd) {
+        if (!result.projectPath) result.projectPath = data.cwd;
+        lastCwdFromHead = data.cwd;
+      }
+      if (data.gitBranch) result.gitBranch = data.gitBranch;
+    } catch (e) {}
+  };
   try {
     stat = statSync(jsonlPath);
-    const fd = fs.openSync(jsonlPath, 'r');
-    const HEAD_SIZE = 16384;
+    fd = fs.openSync(jsonlPath, 'r');
+    const CHUNK_SIZE = 16384;
     const TAIL_SIZE = 16384;
-
-    const headBuf = Buffer.alloc(Math.min(HEAD_SIZE, stat.size));
-    const hn = fs.readSync(fd, headBuf, 0, headBuf.length, 0);
-    let lastCwdFromHead = null;
-    for (const line of headBuf.toString('utf8', 0, hn).split('\n')) {
-      try {
-        const data = JSON.parse(line);
-        if (data.slug) result.slug = data.slug;
-        if (data.cwd) {
-          if (!result.projectPath) result.projectPath = data.cwd;
-          lastCwdFromHead = data.cwd;
-        }
-        if (data.gitBranch) result.gitBranch = data.gitBranch;
-        if (result.slug && result.projectPath && result.gitBranch) break;
-      } catch (e) {}
+    // Stream head in chunks with StringDecoder to preserve multi-byte UTF-8
+    // codepoints across chunk boundaries. Scan up to HEAD_MAX so the last cwd
+    // in the window wins — sessions that change cwd mid-run must surface it.
+    const HEAD_MAX = 1048576;
+    const decoder = new StringDecoder('utf8');
+    const buf = Buffer.alloc(CHUNK_SIZE);
+    let leftover = '';
+    let offset = 0;
+    while (offset < stat.size && offset < HEAD_MAX) {
+      const len = Math.min(CHUNK_SIZE, stat.size - offset);
+      const n = fs.readSync(fd, buf, 0, len, offset);
+      if (n === 0) break;
+      offset += n;
+      const text = leftover + decoder.write(n === buf.length ? buf : buf.slice(0, n));
+      const lines = text.split('\n');
+      leftover = lines.pop();
+      for (const line of lines) applyLine(line);
+    }
+    leftover += decoder.end();
+    if (leftover) applyLine(leftover);
+    // Oversized first line (e.g. multi-MB inline image) left leftover unparsed
+    // above; scrape scalars out of it so we don't fall through to the tail and
+    // pick a mid-session cwd as projectPath.
+    if (!result.projectPath && leftover && leftover.length > CHUNK_SIZE) {
+      const scrapedCwd = scrapeScalarFromBlob(leftover, SCRAPE_CWD_RE);
+      if (scrapedCwd) { result.projectPath = scrapedCwd; lastCwdFromHead = scrapedCwd; }
+      if (!result.slug) result.slug = scrapeScalarFromBlob(leftover, SCRAPE_SLUG_RE);
+      if (!result.gitBranch) result.gitBranch = scrapeScalarFromBlob(leftover, SCRAPE_GITBRANCH_RE);
     }
 
     result.cwd = lastCwdFromHead;
 
-    if ((!result.slug || !result.projectPath || !result.gitBranch) && stat.size > HEAD_SIZE) {
-      const tailStart = stat.size - TAIL_SIZE;
+    // Tail scan: always runs when the file extends past the head window, so
+    // `cwd` reflects the latest value even in long sessions where a late cwd
+    // switch sits past HEAD_MAX. Also backfills projectPath/slug/gitBranch
+    // when the head couldn't find them. projectPath is NOT overwritten — it
+    // stays anchored to the earliest cwd seen.
+    if (stat.size > offset) {
+      const tailStart = Math.max(offset, stat.size - TAIL_SIZE);
       const tailBuf = Buffer.alloc(TAIL_SIZE);
       const tn = fs.readSync(fd, tailBuf, 0, TAIL_SIZE, tailStart);
       const lines = tailBuf.toString('utf8', 0, tn).split('\n');
+      let latestTailCwd = null;
       for (let i = lines.length - 1; i >= 0; i--) {
         try {
           const data = JSON.parse(lines[i]);
           if (!result.slug && data.slug) result.slug = data.slug;
           if (!result.projectPath && data.cwd) result.projectPath = data.cwd;
           if (!result.gitBranch && data.gitBranch) result.gitBranch = data.gitBranch;
-          if (!result.cwd && data.cwd) result.cwd = data.cwd;
-          if (result.slug && result.projectPath && result.gitBranch) break;
+          if (!latestTailCwd && data.cwd) latestTailCwd = data.cwd;
+          if (latestTailCwd && result.slug && result.projectPath && result.gitBranch) break;
         } catch (e) {}
       }
+      if (latestTailCwd) result.cwd = latestTailCwd;
     }
-
-    fs.closeSync(fd);
-  } catch (e) {}
+  } catch (e) {
+  } finally {
+    if (fd !== undefined) { try { fs.closeSync(fd); } catch (e) {} }
+  }
 
   result.customTitle = readCustomTitle(jsonlPath, stat);
   return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-kanban",
-  "version": "3.2.2",
+  "version": "3.2.4",
   "description": "A web-based Kanban board for viewing Claude Code tasks with agent teams support",
   "main": "server.js",
   "bin": {

package/public/app.js

@@ -4810,44 +4810,40 @@ async function showSessionInfoModal(sessionId) {
   const session = sessions.find((s) => s.id === sessionId);
   if (!session) return;
 
-  const promises = [];
-
-  // Fetch team config
-  let teamConfig = null;
-  if (session.isTeam) {
-    const teamId = session.teamName || sessionId;
-    promises.push(
-      fetch(`/api/teams/${teamId}`)
+  // Open modal immediately with session metadata (cwd / path / branch are
+  // already in-memory). Plan / team / tasks are fetched in the background
+  // and re-rendered when they arrive, so the modal doesn't block on network.
+  _planSessionId = sessionId;
+  const cachedTasks = currentSessionId === sessionId ? currentTasks : [];
+  showInfoModal(session, null, cachedTasks, null);
+
+  const rerender = (teamConfig, tasks, planContent) => {
+    if (_planSessionId !== sessionId) return; // user opened a different modal
+    const modal = document.getElementById('team-modal');
+    if (!modal?.classList.contains('visible')) return; // user closed modal — don't reopen
+    showInfoModal(session, teamConfig, tasks, planContent);
+  };
+
+  const teamPromise = session.isTeam
+    ? fetch(`/api/teams/${session.teamName || sessionId}`)
         .then((r) => (r.ok ? r.json() : null))
         .catch(() => null)
-        .then((data) => {
-          teamConfig = data;
-        }),
-    );
-  }
+    : Promise.resolve(null);
 
-  // Fetch plan
-  let planContent = null;
-  promises.push(
-    fetch(`/api/sessions/${sessionId}/plan`)
-      .then((r) => (r.ok ? r.json() : null))
-      .catch(() => null)
-      .then((data) => {
-        planContent = data?.content || null;
-      }),
-  );
+  const planPromise = fetch(`/api/sessions/${sessionId}/plan`)
+    .then((r) => (r.ok ? r.json() : null))
+    .catch(() => null)
+    .then((data) => data?.content || null);
 
-  await Promise.all(promises);
+  const tasksPromise =
+    cachedTasks.length > 0
+      ? Promise.resolve(cachedTasks)
+      : fetch(`/api/sessions/${sessionId}`)
+          .then((r) => (r.ok ? r.json() : []))
+          .catch(() => []);
 
-  let tasks = currentSessionId === sessionId ? currentTasks : [];
-  if (tasks.length === 0) {
-    try {
-      const r = await fetch(`/api/sessions/${sessionId}`);
-      if (r.ok) tasks = await r.json();
-    } catch {}
-  }
-  _planSessionId = sessionId;
-  showInfoModal(session, teamConfig, tasks, planContent);
+  const [teamConfig, planContent, tasks] = await Promise.all([teamPromise, planPromise, tasksPromise]);
+  rerender(teamConfig, tasks, planContent);
 }
 
 let _infoModalSessionId = null;
@@ -4891,7 +4887,7 @@ function showInfoModal(session, teamConfig, tasks, planContent) {
     const projectName = session.project.split(/[/\\]/).pop();
     infoRows.push(['Project', projectName, { openPath: session.projectDir }]);
     infoRows.push(['Path', session.project, { openPath: session.project }]);
-    if (session.cwd && session.cwd !== session.project) {
+    if (session.cwd) {
       infoRows.push(['CWD', session.cwd, { openPath: session.cwd }]);
     }
     if (session.gitBranch) {
@@ -5004,6 +5000,7 @@ function showInfoModal(session, teamConfig, tasks, planContent) {
   }
 
   bodyEl.innerHTML = html;
+  const alreadyVisible = modal.classList.contains('visible');
   _infoModalSessionId = session.id;
   updateStickyBtnState();
   updateDismissBtnState();
@@ -5011,6 +5008,8 @@ function showInfoModal(session, teamConfig, tasks, planContent) {
   if (costBtn) costBtn.style.display = window.__HUB__?.enabled || appConfig.costUrl ? '' : 'none';
   modal.classList.add('visible');
 
+  if (alreadyVisible) return; // re-render during deferred hydration — key handler already attached
+
   const keyHandler = (e) => {
     if (e.key === 'Escape') {
       if (document.getElementById('plan-modal').classList.contains('visible')) return;
@@ -5024,6 +5023,7 @@ function showInfoModal(session, teamConfig, tasks, planContent) {
 
 function closeTeamModal() {
   document.getElementById('team-modal').classList.remove('visible');
+  _planSessionId = null;
 }
 
 // biome-ignore lint/correctness/noUnusedVariables: used in HTML

package/server.js

@@ -387,9 +387,23 @@ function loadSessionMetadata() {
           resolvedProjectPath = sessionInfo.projectPath;
         }
 
+        const candidateProject = indexProjectPath || sessionInfo.projectPath || null;
+        const existing = metadata[sessionId];
+        // Same sessionId can appear in multiple project dirs (e.g. "shadow"
+        // JSONLs that only hold custom-title/agent-name records when a session
+        // is continued from a worktree). Don't let a weaker entry (no cwd, no
+        // project) overwrite a previously resolved one — just merge scalars.
+        if (existing && existing.project && !candidateProject) {
+          if (!existing.slug && sessionInfo.slug) existing.slug = sessionInfo.slug;
+          if (!existing.customTitle && sessionInfo.customTitle) existing.customTitle = sessionInfo.customTitle;
+          if (!existing.gitBranch && sessionInfo.gitBranch) existing.gitBranch = sessionInfo.gitBranch;
+          sessionIds.push(sessionId);
+          continue;
+        }
+
         metadata[sessionId] = {
           slug: sessionInfo.slug,
-          project: indexProjectPath || sessionInfo.projectPath || null,
+          project: candidateProject,
           cwd: sessionInfo.cwd || null,
           gitBranch: sessionInfo.gitBranch || null,
           customTitle: sessionInfo.customTitle || null,