ccakashic 0.4.0 → 0.5.0

package/README.md

@@ -53,6 +53,7 @@ A local HTTP server starts and your browser opens automatically.
 - **Filter search** — Incremental filtering on list pages
 - **Keyboard navigation** — `j` / `k` to move between messages, `p` / `n` to move between your own prompts
 - **One-click resume in cmux** — `▶ Resume` spawns a [cmux](https://github.com/manaflow-ai/cmux) workspace that runs `cd <session cwd> && claude --resume <id>`; `📋 Copy` copies the same command for any terminal
+- **Read-only JSON feed** — `GET /api/sessions?limit=40&waiting=1` returns what the dashboard shows (title, project, branch, model, `status`, `waiting`, `detailUrl`, `resumeCommand`) so other local tools can reuse the waiting signal. `waiting=1` returns only the sessions asking for you, and is the cheap path — it looks those up by id instead of parsing a whole window of session files
 - **Zero dependencies** — Node.js built-in modules only
 
 ## cmux integration

package/dist/api.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_SESSION_LIMIT = exports.DEFAULT_SESSION_LIMIT = void 0;
+exports.toSessionRow = toSessionRow;
+exports.parseSessionLimit = parseSessionLimit;
+exports.orderSessionRows = orderSessionRows;
+const dashboard_1 = require("./dashboard");
+const cmux_1 = require("./cmux");
+// Read-only JSON view of what the dashboard already computes, so other local
+// tools can treat ccakashic as the source of truth for "which session is
+// waiting for me" instead of re-deriving it from ~/.claude. The waiting signal
+// in particular cannot be rebuilt elsewhere: it maps cmux's unread
+// notifications through ccakashic's own resume map.
+exports.DEFAULT_SESSION_LIMIT = 40;
+// Each row costs a full session-file read, so cap what one request can ask for.
+exports.MAX_SESSION_LIMIT = 100;
+const PREVIEW_MAX = 200;
+function toSessionRow(session, waiting) {
+    return {
+        id: session.id,
+        projectRawName: session.projectRawName,
+        projectName: session.projectName,
+        cwd: session.cwd,
+        title: (0, dashboard_1.paneTitle)(session),
+        preview: (session.preview || '').slice(0, PREVIEW_MAX),
+        gitBranch: session.gitBranch,
+        model: session.model,
+        lastModified: session.lastModified,
+        status: (0, dashboard_1.paneStatus)(session.lastModified),
+        waiting,
+        detailUrl: `/project/${encodeURIComponent(session.projectRawName)}/session/${encodeURIComponent(session.id)}`,
+        // /api/resume is POST-only and requires the CSRF token, so there is no GET
+        // URL to hand out — and publishing that token from an unauthenticated
+        // endpoint would defeat it. Callers that want to act on a session either
+        // open detailUrl and press Resume, or run resumeCommand themselves.
+        resumeUrl: null,
+        resumeCommand: session.cwd ? (0, cmux_1.buildResumeCommand)(session.cwd, session.id) : null,
+    };
+}
+function parseSessionLimit(raw) {
+    const n = parseInt(raw || '', 10);
+    if (!Number.isFinite(n) || n <= 0)
+        return exports.DEFAULT_SESSION_LIMIT;
+    return Math.min(n, exports.MAX_SESSION_LIMIT);
+}
+function orderSessionRows(rows, limit) {
+    return rows.slice().sort((a, b) => b.lastModified - a.lastModified).slice(0, limit);
+}

package/dist/bin/ccakashic.js

@@ -41,6 +41,7 @@ const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
 const util_1 = require("../util");
 const discover_1 = require("../discover");
+const api_1 = require("../api");
 const parser_1 = require("../parser");
 const html_generator_1 = require("../html-generator");
 const pages_1 = require("../pages");
@@ -100,16 +101,25 @@ async function buildResumeContext() {
     }
     return { token: RESUME_TOKEN, cmuxAvailable, openSessionIds };
 }
-// sessionId → wait reason, from cmux's unread notifications mapped through the
-// resume map. Only covers ccakashic-resumed sessions; others fall back to the
-// jsonl-derived activity below. Empty when cmux is unavailable/disabled.
+// sessionId → wait reason, from cmux's unread notifications resolved through
+// two independent workspace→session sources. Empty when cmux is
+// unavailable/disabled.
 async function buildCmuxWaitMap() {
     const result = new Map();
     if (NO_CMUX || !(await (0, cmux_1.isCmuxAvailable)()))
         return result;
     try {
         const waiting = await (0, cmux_1.listWaitingWorkspacesCached)();
+        // The resume map only covers sessions ccakashic resumed, which left every
+        // hand-started session permanently unbadged. The live map reads
+        // CMUX_WORKSPACE_ID from each running session's own process and covers
+        // those. They complement each other — the resume map still resolves
+        // sessions that have since exited — so the live one is layered on top,
+        // winning conflicts because it reflects the process attached right now.
         const wsToSession = (0, cmux_1.loadWorkspaceToSession)();
+        for (const [wsId, sessionId] of await (0, cmux_1.liveWorkspaceToSessionCached)()) {
+            wsToSession.set(wsId, sessionId);
+        }
         for (const [wsId, reason] of waiting) {
             const sessionId = wsToSession.get(wsId);
             if (sessionId)
@@ -291,6 +301,24 @@ const server = http.createServer(async (req, res) => {
             res.end(JSON.stringify({ changed: true, mtime, status, ago, waiting, html: (0, dashboard_1.renderPaneBody)(parsed) }));
             return;
         }
+        // Read-only feed of the dashboard's own view, for other local tools.
+        if (pathname === '/api/sessions') {
+            const limit = (0, api_1.parseSessionLimit)(url.searchParams.get('limit'));
+            const waitingOnly = url.searchParams.get('waiting') === '1';
+            const cmuxWait = await buildCmuxWaitMap();
+            // Waiting sessions are fetched by id rather than filtered out of the
+            // recent window: a session can sit waiting while other projects churn
+            // past it, and reading a wide window means parsing every file in it.
+            const sessions = waitingOnly
+                ? await (0, discover_1.findRecentSessionsByIds)([...cmuxWait.keys()])
+                : await (0, discover_1.listRecentSessions)(limit);
+            const rows = (0, api_1.orderSessionRows)(sessions
+                .map((s) => (0, api_1.toSessionRow)(s, resolveWaiting(s.id, cmuxWait)))
+                .filter((r) => !waitingOnly || r.waiting !== null), limit);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(rows));
+            return;
+        }
         const projectMatch = pathname.match(/^\/project\/(.+)$/);
         if (projectMatch && !pathname.includes('/session/')) {
             const rawName = decodeURIComponent(projectMatch[1]);

package/dist/cmux.js

@@ -49,6 +49,10 @@ exports.openInCmuxBrowser = openInCmuxBrowser;
 exports.loadResumeMap = loadResumeMap;
 exports.saveResumeMapEntry = saveResumeMapEntry;
 exports.loadWorkspaceToSession = loadWorkspaceToSession;
+exports.loadSessionRegistry = loadSessionRegistry;
+exports.parseWorkspaceEnv = parseWorkspaceEnv;
+exports.liveWorkspaceToSession = liveWorkspaceToSession;
+exports.liveWorkspaceToSessionCached = liveWorkspaceToSessionCached;
 exports.findLiveWorkspaceForSession = findLiveWorkspaceForSession;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
@@ -260,6 +264,124 @@ function loadWorkspaceToSession() {
     }
     return inv;
 }
+// --- Live workspace mapping, read from the running processes themselves ---
+//
+// The resume map only knows about sessions ccakashic itself resumed, so a
+// session you started by hand inside cmux has no workspace mapping and never
+// gets a waiting badge. Claude Code registers every running session in
+// ~/.claude/sessions/<pid>.json, and a session launched inside cmux inherits
+// CMUX_WORKSPACE_ID in its environment — together those give the same mapping
+// without ccakashic having been involved.
+//
+// The two sources are complements, not replacements: this one sees only live
+// processes, while the resume map still covers sessions that have since exited.
+const SESSION_REGISTRY_DIR = path.join(os.homedir(), '.claude', 'sessions');
+function loadSessionRegistry() {
+    let names;
+    try {
+        names = fs.readdirSync(SESSION_REGISTRY_DIR);
+    }
+    catch {
+        return []; // no registry (older Claude Code, or nothing has run yet)
+    }
+    const out = [];
+    for (const f of names) {
+        if (!f.endsWith('.json'))
+            continue;
+        try {
+            const o = JSON.parse(fs.readFileSync(path.join(SESSION_REGISTRY_DIR, f), 'utf-8'));
+            if (typeof o?.pid === 'number' && typeof o?.sessionId === 'string') {
+                out.push({ pid: o.pid, sessionId: o.sessionId, procStart: o.procStart });
+            }
+        }
+        catch {
+            // a half-written or stale record; skip it
+        }
+    }
+    return out;
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0); // signal 0 only probes; it does not signal
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// `ps eww` prints one line per process: pid, then the command, then the
+// process's ENTIRE environment — which routinely holds API keys and tokens.
+// Only CMUX_WORKSPACE_ID is ever pulled out of it; no other variable is
+// stored, returned or logged, and the raw output is not retained.
+function parseWorkspaceEnv(psOutput) {
+    const byPid = new Map();
+    for (const line of psOutput.split('\n')) {
+        const pid = line.match(/^\s*(\d+)\s/);
+        if (!pid)
+            continue;
+        const ws = line.match(/\bCMUX_WORKSPACE_ID=([A-Za-z0-9-]+)/);
+        if (ws)
+            byPid.set(parseInt(pid[1], 10), ws[1].toUpperCase());
+    }
+    return byPid;
+}
+function runPlain(bin, args, timeoutMs = 3000) {
+    return new Promise((resolve) => {
+        (0, child_process_1.execFile)(bin, args, { timeout: timeoutMs, maxBuffer: 8 * 1024 * 1024 }, (err, stdout) => {
+            resolve(err ? '' : stdout);
+        });
+    });
+}
+// A process's environment is fixed at exec time, so a pid only ever needs
+// looking up once. Keyed with procStart as well so a recycled pid can't
+// inherit the previous process's answer. null means "checked, not a cmux
+// process" — cached too, so those aren't re-probed on every poll.
+const workspaceEnvCache = new Map();
+const envKey = (r) => `${r.pid}:${r.procStart ?? ''}`;
+async function liveWorkspaceToSession() {
+    const live = loadSessionRegistry().filter((r) => isProcessAlive(r.pid));
+    const result = new Map();
+    const unknown = [];
+    for (const r of live) {
+        const key = envKey(r);
+        if (workspaceEnvCache.has(key)) {
+            const ws = workspaceEnvCache.get(key);
+            if (ws)
+                result.set(ws, r.sessionId);
+        }
+        else {
+            unknown.push(r);
+        }
+    }
+    if (unknown.length) {
+        // One ps for every new pid at once, not one spawn per session.
+        const out = await runPlain('ps', ['eww', '-p', unknown.map((r) => r.pid).join(',')]);
+        const byPid = parseWorkspaceEnv(out);
+        for (const r of unknown) {
+            const ws = byPid.get(r.pid) ?? null;
+            workspaceEnvCache.set(envKey(r), ws);
+            if (ws)
+                result.set(ws, r.sessionId);
+        }
+    }
+    // Drop entries for processes that are gone, so a long-lived server doesn't
+    // accumulate one per session ever started.
+    const alive = new Set(live.map(envKey));
+    for (const key of workspaceEnvCache.keys()) {
+        if (!alive.has(key))
+            workspaceEnvCache.delete(key);
+    }
+    return result;
+}
+let cachedLiveWorkspaces = null;
+async function liveWorkspaceToSessionCached() {
+    if (cachedLiveWorkspaces && Date.now() - cachedLiveWorkspaces.at < 5_000) {
+        return cachedLiveWorkspaces.value;
+    }
+    const value = await liveWorkspaceToSession();
+    cachedLiveWorkspaces = { value, at: Date.now() };
+    return value;
+}
 async function findLiveWorkspaceForSession(sessionId) {
     const mapped = loadResumeMap()[sessionId];
     if (!mapped)

package/dist/dashboard.js

@@ -4,6 +4,7 @@ exports.DEFAULT_PANE_COUNT = exports.PANE_COUNTS = void 0;
 exports.timeAgo = timeAgo;
 exports.paneStatus = paneStatus;
 exports.renderPaneBody = renderPaneBody;
+exports.paneTitle = paneTitle;
 exports.waitBadgeHtml = waitBadgeHtml;
 exports.generateDashboard = generateDashboard;
 const template_assets_1 = require("./template-assets");

package/dist/discover.js

@@ -38,6 +38,7 @@ exports.decodeDirName = decodeDirName;
 exports.listProjects = listProjects;
 exports.listSessions = listSessions;
 exports.listRecentSessions = listRecentSessions;
+exports.findRecentSessionsByIds = findRecentSessionsByIds;
 exports.readCwdFromSession = readCwdFromSession;
 exports.findSessionForCwd = findSessionForCwd;
 const fs = __importStar(require("fs"));
@@ -232,6 +233,32 @@ async function listRecentSessions(limit) {
         projectName: top[i].scan.name,
     }));
 }
+// Locate specific sessions by id. scanProjects only stats filenames, so this
+// parses just the matched files — unlike listRecentSessions, which parses every
+// file in its window (getSessionPreview reads a session end to end to total its
+// tokens). Callers that know which ids they want should use this: a session can
+// sit waiting for you while other projects churn past it, so it is not
+// necessarily inside any "most recent N" window.
+async function findRecentSessionsByIds(ids) {
+    const wanted = new Set(ids);
+    if (!wanted.size)
+        return [];
+    const scans = await scanProjects();
+    const hits = [];
+    for (const scan of scans) {
+        for (const f of scan.files) {
+            if (wanted.has(f.file.replace(/\.jsonl$/, ''))) {
+                hits.push({ file: path.join(scan.dir, f.file), scan });
+            }
+        }
+    }
+    const previews = await Promise.all(hits.map((h) => getSessionPreview(h.file)));
+    return previews.map((s, i) => ({
+        ...s,
+        projectRawName: hits[i].scan.rawName,
+        projectName: hits[i].scan.name,
+    }));
+}
 function readCwdFromSession(filePath) {
     return new Promise((resolve) => {
         const rl = readline.createInterface({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccakashic",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "A cross-project dashboard for your Claude Code sessions (~/.claude/projects/) — browse logs as beautiful HTML, see which sessions are waiting for you, and resume any of them in one click via cmux",
   "bin": {
     "ccakashic": "dist/bin/ccakashic.js"