@bakapiano/ccsm 0.3.0 → 0.4.0

package/CLAUDE.md

@@ -88,7 +88,8 @@ The alternative ("one repo per workspace") was explicitly rejected — don't ref
 | POST | `/api/sessions/new` | body `{repos, workspace?, launch?}` — picks/creates ws, clones missing repos, launches wt |
 | POST | `/api/sessions/finder` | opens a wt with `claude` in `D:\ccsm` and the `finderPrompt` as opening message |
 | POST | `/api/sessions/:id/resume` | body `{cwd}` — launches `wt -d <cwd> claude --resume <id>` |
-| POST | `/api/sessions/:id/focus` | walks up the claude PID parent chain to find the wt window, raises it via SetForegroundWindow |
+| GET | `/api/sessions/recent` | recently-used sessions discovered from `~/.claude/projects/*/*.jsonl` mtimes, excluding currently-live ids |
+| POST | `/api/sessions/:id/focus` | matches a wt window by title (cleaned of leading status glyphs) against the session's ai-title; falls back to PID-parent walk if no unique match |
 | GET | `/api/terminals` | enumerate built-in terminal kinds + their process names |
 | GET | `/api/health` | sanity ping |
 
@@ -112,6 +113,8 @@ ccsm uses variant 1 and always `path.resolve()`s the cwd first — defends again
 
 **Don't test wt launching via `node -e "..."` inside `bash -c`.** Backslashes get eaten by shell quoting and the JS string ends up malformed. Write a `.js` file and `node file.js` instead.
 
+**focusBySession — title-based wt window matching.** Walking up the claude.exe PID parent chain and taking `MainWindowHandle` of the wt process *always* returns the same canonical window in modern multi-window single-process wt — clicking different sessions all focused the same window. `focusBySession` instead lists all visible wt windows (`EnumWindows` filtered by process name), strips the leading wt status glyph (`✳ `, `⠐ `, `⠠ ` …) and compares to the session's ai-title. Falls back to title-substring, then cwd-basename, then the old PID-parent walk when no unique match — at least the user sees *some* wt window even if it's the wrong tab. Caveat: for sessions sitting in an inactive tab of a multi-tab wt window, the window title shows the *active* tab's title — so we can't find them by title alone and the fallback is wrong-tab.
+
 **Focus helper (`lib/focus.js`).** One `powershell.exe -EncodedCommand <base64>` invocation per call, dispatched by `CCSM_FOCUS_MODE` env var into modes `list` (enumerate visible top-level windows owned by a process name), `focus-hwnd` (activate a specific HWND), `focus-pid` (walk parent chain to MainWindowHandle then activate). Encoded as UTF-16-LE-base64 — passing the C# block via stdin to `-Command -` silently produces no output, so we don't. Three gotchas baked in:
 1. C# `out _` discard breaks PowerShell 5.1's bundled C# compiler — use a named `uint dummy`.
 2. Windows blocks background processes from `SetForegroundWindow` — synthesize an Alt-key down/up via `keybd_event 0x12` first ("Alt-key trick") to qualify our process. Without it, `activated` returns false even though the window is found.

package/lib/focus.js

@@ -192,6 +192,63 @@ async function focusByPid(pid) {
   return await runPsHelper('focus-pid', n);
 }
 
+// Strip the leading wt status glyph + whitespace ("✳ ", "⠐ ", "⠠ " etc) so
+// the title compares cleanly. wt prefixes the tab title with a Braille-style
+// progress glyph or a sparkle/asterisk depending on activity.
+function cleanWtTitle(t) {
+  return String(t || '').replace(/^[^\w一-鿿]+/, '').trim();
+}
+
+// Best-effort: focus the wt window that belongs to a specific session.
+// Modern wt is single-process multi-window, so walking from claude.exe PID
+// up to wt.exe + taking MainWindowHandle always returns the same canonical
+// window regardless of which tab the session is actually in. Instead we
+// list all wt windows and match by tab title against the session's AI
+// title / cwd basename.
+async function focusBySession({ pid, sessionId, title, cwd }) {
+  const procName = 'WindowsTerminal.exe';
+  const cands = await listWindowsOf(procName);
+
+  const cleanedTitle = title ? cleanWtTitle(title) : '';
+  const cwdBase = cwd ? require('node:path').basename(cwd) : '';
+
+  // 1. Exact match on cleaned ai-title
+  if (cleanedTitle) {
+    const exact = cands.filter((w) => cleanWtTitle(w.title) === cleanedTitle);
+    if (exact.length === 1) {
+      const r = await focusByHwnd(exact[0].hwnd);
+      return { ...r, matchedBy: 'title-exact', hwnd: exact[0].hwnd, windowTitle: exact[0].title };
+    }
+  }
+
+  // 2. Title substring match (some shells append " - <cwd>" etc)
+  if (cleanedTitle) {
+    const subs = cands.filter((w) => w.title.includes(cleanedTitle));
+    if (subs.length === 1) {
+      const r = await focusByHwnd(subs[0].hwnd);
+      return { ...r, matchedBy: 'title-substring', hwnd: subs[0].hwnd, windowTitle: subs[0].title };
+    }
+  }
+
+  // 3. Match by cwd basename (workspace name shows up in title for fresh launches)
+  if (cwdBase) {
+    const byCwd = cands.filter((w) => w.title.includes(cwdBase));
+    if (byCwd.length === 1) {
+      const r = await focusByHwnd(byCwd[0].hwnd);
+      return { ...r, matchedBy: 'cwd-basename', hwnd: byCwd[0].hwnd, windowTitle: byCwd[0].title };
+    }
+  }
+
+  // 4. Fall back to PID parent-chain walk (returns the wt process's
+  //    canonical MainWindowHandle — may be the wrong window when wt is
+  //    multi-window single-process, but better than nothing).
+  if (pid) {
+    const r = await focusByPid(pid);
+    return { ...r, matchedBy: 'pid-fallback', ambiguous: true };
+  }
+  return { ok: false, error: 'no match by title/cwd and no pid given', matchedBy: 'none' };
+}
+
 async function focusByHwnd(hwnd) {
   return await runPsHelper('focus-hwnd', hwnd);
 }
@@ -228,6 +285,7 @@ async function focusNewlyOpenedHwnd(beforeHwnds, processName, opts = {}) {
 
 module.exports = {
   focusByPid,
+  focusBySession,
   focusByHwnd,
   listWindowsOf,
   snapshotWindowsOf,

package/lib/sessions.js

@@ -110,8 +110,121 @@ async function listSessions() {
     .sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
 }
 
+// Pull cwd/title/firstTimestamp from a jsonl by reading the head (cwd lives in
+// any user/assistant/attachment line) and tailing for the last ai-title.
+async function readJsonlMetadata(jsonlPath) {
+  let fd;
+  try {
+    fd = await fs.open(jsonlPath, 'r');
+    const stat = await fd.stat();
+    if (stat.size === 0) return { size: 0 };
+
+    const HEAD = Math.min(stat.size, 128 * 1024);
+    const headBuf = Buffer.alloc(HEAD);
+    await fd.read(headBuf, 0, HEAD, 0);
+    const headText = headBuf.toString('utf8');
+
+    let cwd = null;
+    let gitBranch = null;
+    let firstTimestamp = null;
+    for (const line of headText.split('\n')) {
+      if (!line) continue;
+      if (cwd && firstTimestamp) break;
+      if (!line.includes('"cwd"') && !line.includes('"timestamp"')) continue;
+      try {
+        const obj = JSON.parse(line);
+        if (obj.cwd && !cwd) cwd = obj.cwd;
+        if (obj.gitBranch && !gitBranch) gitBranch = obj.gitBranch;
+        if (obj.timestamp && !firstTimestamp) firstTimestamp = obj.timestamp;
+      } catch {}
+    }
+
+    const TAIL = Math.min(stat.size, 512 * 1024);
+    const tailBuf = Buffer.alloc(TAIL);
+    await fd.read(tailBuf, 0, TAIL, Math.max(0, stat.size - TAIL));
+    const tailText = tailBuf.toString('utf8');
+    let title = null;
+    const tailLines = tailText.split('\n');
+    for (let i = tailLines.length - 1; i >= 0; i--) {
+      if (!tailLines[i].includes('"type":"ai-title"')) continue;
+      try {
+        const obj = JSON.parse(tailLines[i]);
+        if (obj.aiTitle) { title = obj.aiTitle; break; }
+      } catch {}
+    }
+
+    return { cwd, gitBranch, firstTimestamp, title, size: stat.size };
+  } catch {
+    return {};
+  } finally {
+    if (fd) await fd.close().catch(() => {});
+  }
+}
+
+// List every recently-used Claude session by enumerating ~/.claude/projects/
+// *.jsonl files. Excludes session ids that are currently live (caller passes
+// `excludeIds` from listSessions()). Sorted by file mtime desc.
+async function listRecentSessions({ limit = 50, excludeIds = null } = {}) {
+  let projectDirs;
+  try {
+    projectDirs = await fs.readdir(PROJECTS_DIR);
+  } catch {
+    return [];
+  }
+
+  const candidates = [];
+  for (const slugDir of projectDirs) {
+    const dirPath = path.join(PROJECTS_DIR, slugDir);
+    let entries;
+    try {
+      entries = await fs.readdir(dirPath);
+    } catch {
+      continue;
+    }
+    for (const file of entries) {
+      if (!file.endsWith('.jsonl')) continue;
+      const sessionId = file.slice(0, -'.jsonl'.length);
+      if (excludeIds && excludeIds.has(sessionId)) continue;
+      const fullPath = path.join(dirPath, file);
+      try {
+        const stat = await fs.stat(fullPath);
+        if (stat.size === 0) continue;
+        candidates.push({
+          sessionId,
+          slug: slugDir,
+          jsonlPath: fullPath,
+          mtime: stat.mtimeMs,
+        });
+      } catch {}
+    }
+  }
+
+  candidates.sort((a, b) => b.mtime - a.mtime);
+  const top = candidates.slice(0, limit);
+
+  const results = await Promise.all(
+    top.map(async (c) => {
+      const meta = await readJsonlMetadata(c.jsonlPath);
+      const firstTs = meta.firstTimestamp ? Date.parse(meta.firstTimestamp) : null;
+      return {
+        sessionId: c.sessionId,
+        cwd: meta.cwd || null,
+        title: meta.title || null,
+        gitBranch: meta.gitBranch || null,
+        updatedAt: c.mtime,
+        startedAt: Number.isFinite(firstTs) ? firstTs : null,
+        jsonlPath: c.jsonlPath,
+      };
+    })
+  );
+
+  // Drop entries with no cwd — can't resume without one
+  return results.filter((r) => r.cwd);
+}
+
 module.exports = {
   listSessions,
+  listRecentSessions,
   projectSlugForCwd,
   getLiveClaudePids,
   SESSIONS_DIR,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bakapiano/ccsm",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Claude Code Session Manager — Windows web UI to manage many concurrent claude sessions: live list, snapshot/restore, focus existing window, new session in an isolated workspace with repo clones",
   "license": "MIT",
   "main": "server.js",

package/public/app.js

@@ -83,6 +83,29 @@ function renderSessions() {
     state.sessions.length ? `${state.sessions.length} live · last refresh ${new Date().toLocaleTimeString()}` : 'no live sessions';
 }
 
+function renderRecent() {
+  const tb = $('#recentTable tbody');
+  tb.innerHTML = '';
+  const recent = state.recent || [];
+  for (const s of recent) {
+    const tr = document.createElement('tr');
+    tr.innerHTML = `
+      <td><div class="ellipsis" title="${escapeHtml(s.title || '')}">${escapeHtml(s.title || '(no title)')}</div>
+          <div class="mono small" title="${escapeHtml(s.sessionId)}">${escapeHtml(s.sessionId.slice(0,8))}…</div></td>
+      <td><div class="ellipsis mono" title="${escapeHtml(s.cwd || '')}">${escapeHtml(s.cwd || '')}</div></td>
+      <td class="mono small">${escapeHtml(s.gitBranch || '')}</td>
+      <td title="${escapeHtml(fmtTime(s.updatedAt))}">${escapeHtml(fmtAgo(s.updatedAt))}</td>
+      <td title="${escapeHtml(fmtTime(s.startedAt))}">${escapeHtml(fmtAgo(s.startedAt))}</td>
+      <td style="text-align:right;">
+        <button class="btn small btn-primary" data-continue="${escapeHtml(s.sessionId)}" data-cwd="${escapeHtml(s.cwd)}" title="open a new wt window with claude --resume">continue</button>
+      </td>
+    `;
+    tb.appendChild(tr);
+  }
+  $('#recentMeta').textContent =
+    recent.length ? `${recent.length} recent · last refresh ${new Date().toLocaleTimeString()}` : 'no recent sessions';
+}
+
 // ---- snapshot render ----
 
 function renderSnapshot() {
@@ -221,6 +244,12 @@ async function loadSessions() {
   renderSessions();
 }
 
+async function loadRecent() {
+  const r = await api('GET', '/api/sessions/recent?limit=50');
+  state.recent = r.recent;
+  renderRecent();
+}
+
 async function loadConfig() {
   const [cfg, terminals] = await Promise.all([
     api('GET', '/api/config'),
@@ -249,7 +278,7 @@ async function loadWorkspaces() {
 }
 
 async function refreshAll() {
-  await Promise.all([loadSessions(), loadSnapshot(), loadWorkspaces()]);
+  await Promise.all([loadSessions(), loadRecent(), loadSnapshot(), loadWorkspaces()]);
 }
 
 // ---- event wiring ----
@@ -298,6 +327,24 @@ function wireUp() {
     }
   });
 
+  $('#recentTable').addEventListener('click', async (ev) => {
+    const btn = ev.target.closest('button[data-continue]');
+    if (!btn) return;
+    const sessionId = btn.dataset.continue;
+    const cwd = btn.dataset.cwd;
+    btn.disabled = true;
+    try {
+      await api('POST', `/api/sessions/${sessionId}/resume`, { cwd });
+      toast(`continuing ${sessionId.slice(0, 8)}…`);
+      setTimeout(() => loadSessions().catch(() => {}), 3000);
+      setTimeout(() => loadRecent().catch(() => {}), 4000);
+    } catch (e) {
+      toast(e.message, 'error');
+    } finally {
+      btn.disabled = false;
+    }
+  });
+
   $('#finderBtn').onclick = async () => {
     try {
       await api('POST', '/api/sessions/finder');
@@ -408,6 +455,7 @@ function startAutoRefresh() {
   stopAutoRefresh();
   state.autoTimer = setInterval(() => {
     loadSessions().catch(() => {});
+    loadRecent().catch(() => {});
     loadSnapshot().catch(() => {});
   }, 5000);
 }

package/public/index.html

@@ -49,6 +49,28 @@
         </div>
       </section>
 
+      <section class="panel">
+        <header class="panel-header">
+          <h2>recently closed</h2>
+          <span id="recentMeta" class="muted"></span>
+        </header>
+        <div class="table-wrap">
+          <table id="recentTable" class="data-table">
+            <thead>
+              <tr>
+                <th>title</th>
+                <th>cwd</th>
+                <th>branch</th>
+                <th>updated</th>
+                <th>started</th>
+                <th></th>
+              </tr>
+            </thead>
+            <tbody></tbody>
+          </table>
+        </div>
+      </section>
+
       <section class="panel">
         <header class="panel-header">
           <h2>snapshot</h2>

package/server.js

@@ -4,7 +4,7 @@
 const path = require('node:path');
 const express = require('express');
 
-const { listSessions } = require('./lib/sessions');
+const { listSessions, listRecentSessions } = require('./lib/sessions');
 const { loadConfig, saveConfig, DATA_DIR } = require('./lib/config');
 const {
   saveSnapshot,
@@ -26,6 +26,7 @@ const {
 } = require('./lib/launcher');
 const {
   focusByPid,
+  focusBySession,
   snapshotWindowsOf,
   focusNewlyOpenedHwnd,
 } = require('./lib/focus');
@@ -61,6 +62,14 @@ app.get('/api/sessions', asyncH(async (_req, res) => {
   res.json({ sessions, takenAt: Date.now() });
 }));
 
+app.get('/api/sessions/recent', asyncH(async (req, res) => {
+  const limit = Math.min(200, Number(req.query.limit) || 50);
+  const live = await listSessions();
+  const excludeIds = new Set(live.map((s) => s.sessionId));
+  const recent = await listRecentSessions({ limit, excludeIds });
+  res.json({ recent, takenAt: Date.now() });
+}));
+
 // ---- config ----
 
 app.get('/api/config', asyncH(async (_req, res) => {
@@ -296,8 +305,13 @@ app.post('/api/sessions/:sessionId/focus', asyncH(async (req, res) => {
   const sessions = await listSessions();
   const s = sessions.find((x) => x.sessionId === sessionId);
   if (!s) return res.status(404).json({ error: `session ${sessionId} not live` });
-  const result = await focusByPid(s.pid);
-  res.json({ session: { pid: s.pid, sessionId: s.sessionId, cwd: s.cwd }, ...result });
+  const result = await focusBySession({
+    pid: s.pid,
+    sessionId: s.sessionId,
+    title: s.title,
+    cwd: s.cwd,
+  });
+  res.json({ session: { pid: s.pid, sessionId: s.sessionId, cwd: s.cwd, title: s.title }, ...result });
 }));
 
 // ---- terminal kinds ----