ccakashic 0.2.8 → 0.3.1

package/README.md

@@ -4,11 +4,13 @@
 
 # ccakashic
 
-An Akashic Record of your Claude Code sessions — browse Claude Code session logs (`~/.claude/projects/`) as beautiful HTML in your browser.
+An Akashic Record of your Claude Code sessions — a cross-project **dashboard** for your `~/.claude/projects/` logs, rendered as beautiful HTML in your browser. See every recent session side by side, spot at a glance which ones are waiting for your input, and **resume any of them in one click** straight into a [cmux](https://github.com/manaflow-ai/cmux) workspace.
 
-![Session detail with stats, cost badges, and chat layout](https://raw.githubusercontent.com/ashimon83/ccakashic/main/docs/screenshot1.png)
+![Cross-project dashboard: recent sessions side by side with live status dots, a waiting-for-you badge, and one-click Resume / Jump](https://raw.githubusercontent.com/ashimon83/ccakashic/main/docs/dashboard.png)
 
-![Collapsible tool calls, code blocks, and per-message cost](https://raw.githubusercontent.com/ashimon83/ccakashic/main/docs/screenshot2.png)
+![Session detail with stats, cost badges, and a chat-style layout](https://raw.githubusercontent.com/ashimon83/ccakashic/main/docs/screenshot1.png)
+
+![Expanded tool calls with red/green diffs and per-message cost](https://raw.githubusercontent.com/ashimon83/ccakashic/main/docs/screenshot2.png)
 
 ## Usage
 
@@ -30,7 +32,9 @@ A local HTTP server starts and your browser opens automatically.
 
 ## Features
 
-- **Fully browser-based** — Project list → Session list → Conversation detail
+- **Dashboard** — The top page shows your 4/6/8 most recently active sessions across all projects side by side, each pane an independently scrollable thread of the last 24h, with live status dots (🟢 active / 🟡 recent / ⚪ idle) refreshed by polling
+- **Waiting-for-you indicator** — Sessions cmux is notifying you about (an **unread** "Claude is waiting for your input" / "needs your permission") get an orange frame and a `⏳ Your turn` / `🔐 Permission` badge. cmux marks the notification read the moment you focus that workspace, so the highlight **self-clears** on the next poll once you open the tab — it mirrors cmux's own badge exactly. The browser tab title shows the count (`(2) ccakashic`) and the favicon turns orange, so a glance at the tab tells you how many sessions need you. (Requires cmux; covers sessions resumed through ccakashic, which are tracked in the resume map.)
+- **Fully browser-based** — Dashboard → Project list → Session list → Conversation detail
 - **Chat-style layout** — User / assistant messages in chat bubbles
 - **Collapsible tool calls** — Bash, Read, Edit, and other tool invocations collapsed by default
 - **Diff view** — File edits shown with red/green line highlights
@@ -44,13 +48,38 @@ A local HTTP server starts and your browser opens automatically.
 - **Dark mode** — Follows `prefers-color-scheme` automatically
 - **Filter search** — Incremental filtering on list pages
 - **Keyboard navigation** — `j` / `k` to move between messages
+- **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
 - **Zero dependencies** — Node.js built-in modules only
 
+## cmux integration
+
+When the [cmux](https://github.com/manaflow-ai/cmux) terminal is detected (`cmux ping` succeeds), ccakashic becomes a session dashboard:
+
+- The UI opens in a cmux browser pane instead of your default browser
+- Every session with a recorded `cwd` gets a `▶ Resume` button: one click creates a new cmux workspace, `cd`s into the session's directory, and runs `claude --resume <session-id>` — the workspace is renamed to the session title
+- Resuming the same session again jumps to the already-open workspace instead of forking the conversation (the button turns into `↪ Jump`)
+- Alt-click `▶ Resume` to open the workspace in the background and stay on the list
+- Sessions that look active (modified in the last 2 minutes) ask for a second click before resuming, since resuming a live session forks it
+- Without cmux, the `📋 Copy` button still gives you a ready-to-paste `cd … && claude --resume …` command
+
+Notes:
+
+- The resume CSRF token is persisted to `~/.config/ccakashic/token` (mode 600), so restarting the server doesn't break the buttons on already-open tabs
+- cmux's socket only accepts callers inside the cmux process tree, so run `npx ccakashic` from a terminal **inside cmux** (or configure a socket password in cmux settings and export `CMUX_SOCKET_PASSWORD`)
+- The `cmux` binary is found via `$PATH`, then the common Homebrew locations. If it lives elsewhere, point `CCAKASHIC_CMUX` at it (e.g. `CCAKASHIC_CMUX=/path/to/cmux npx ccakashic`)
+- Disable the integration with `--no-cmux` or `CCAKASHIC_NO_CMUX=1`
+
 ## Options
 
 ```bash
 # Custom port (default: 3333)
 CCAKASHIC_PORT=3000 npx ccakashic
+
+# Skip cmux detection (regular browser, no resume buttons)
+npx ccakashic --no-cmux
+
+# Start the server without opening a browser
+npx ccakashic --no-open
 ```
 
 ## Requirements

package/dist/bin/ccakashic.js

@@ -39,10 +39,13 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
+const util_1 = require("../util");
 const discover_1 = require("../discover");
 const parser_1 = require("../parser");
 const html_generator_1 = require("../html-generator");
 const pages_1 = require("../pages");
+const dashboard_1 = require("../dashboard");
+const cmux_1 = require("../cmux");
 // Published at dist/bin/ccakashic.js, so ../../package.json resolves from dist/
 const pkg = __importStar(require("../../package.json"));
 function openInBrowser(url) {
@@ -51,11 +54,182 @@ function openInBrowser(url) {
             : 'xdg-open';
     (0, child_process_1.exec)(`${cmd} "${url}"`);
 }
+async function openUrl(url) {
+    if (NO_OPEN) {
+        console.log(`Not opening a browser (--no-open). URL: ${url}`);
+        return;
+    }
+    if (!NO_CMUX && await (0, cmux_1.isCmuxAvailable)()) {
+        try {
+            await (0, cmux_1.openInCmuxBrowser)(url);
+            console.log('Opened in cmux browser pane (use --no-cmux for a regular browser)');
+            return;
+        }
+        catch {
+            // cmux is up but the browser pane failed; use the regular browser
+        }
+    }
+    openInBrowser(url);
+}
 const PORT = parseInt(process.env.CCAKASHIC_PORT || '') || 3333;
 const MAX_PORT_TRIES = 20;
 const LOCK_FILE = path.join(os.tmpdir(), `ccakashic-${os.userInfo().username || 'user'}.json`);
+const NO_CMUX = process.argv.includes('--no-cmux') || !!process.env.CCAKASHIC_NO_CMUX;
+const NO_OPEN = process.argv.includes('--no-open') || !!process.env.CCAKASHIC_NO_OPEN;
+// CSRF guard for /api/resume: any webpage can POST to localhost, but only
+// pages we served know this token. Persisted across restarts so open tabs keep
+// working without a reload.
+const RESUME_TOKEN = (0, util_1.getOrCreateToken)();
+async function buildResumeContext() {
+    if (NO_CMUX)
+        return undefined;
+    const cmuxAvailable = await (0, cmux_1.isCmuxAvailable)();
+    const openSessionIds = new Set();
+    if (cmuxAvailable) {
+        try {
+            const live = await (0, cmux_1.listWorkspaceIdsCached)();
+            const map = (0, cmux_1.loadResumeMap)();
+            for (const [sessionId, wsId] of Object.entries(map)) {
+                if (live.has(wsId.toUpperCase()))
+                    openSessionIds.add(sessionId);
+            }
+        }
+        catch {
+            // liveness markers are cosmetic; resume still works without them
+        }
+    }
+    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.
+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)();
+        const wsToSession = (0, cmux_1.loadWorkspaceToSession)();
+        for (const [wsId, reason] of waiting) {
+            const sessionId = wsToSession.get(wsId);
+            if (sessionId)
+                result.set(sessionId, reason);
+        }
+    }
+    catch {
+        // notifications are an enrichment; jsonl activity still drives the badge
+    }
+    return result;
+}
+// Waiting is driven solely by cmux's unread notifications: cmux clears them the
+// moment you focus a workspace, so the dashboard badge self-clears when you open
+// the tab — mirroring cmux exactly. (A jsonl "assistant ended its turn" signal
+// was tried but flags nearly every finished session and never self-clears.)
+function resolveWaiting(sessionId, cmuxWait) {
+    return cmuxWait.get(sessionId) ?? null;
+}
+function readJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        let data = '';
+        req.on('data', (chunk) => {
+            data += chunk;
+            if (data.length > 64 * 1024) {
+                reject(new Error('Body too large'));
+                req.destroy();
+            }
+        });
+        req.on('end', () => {
+            try {
+                resolve(JSON.parse(data));
+            }
+            catch {
+                reject(new Error('Invalid JSON'));
+            }
+        });
+        req.on('error', reject);
+    });
+}
+async function handleResume(req, res) {
+    const respond = (status, body) => {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(body));
+    };
+    if (req.method !== 'POST')
+        return respond(405, { action: 'error', message: 'POST only' });
+    if (req.headers['x-ccakashic-token'] !== RESUME_TOKEN) {
+        return respond(403, { action: 'error', message: 'Invalid token' });
+    }
+    let body;
+    try {
+        body = await readJsonBody(req);
+    }
+    catch (err) {
+        return respond(400, { action: 'error', message: err?.message || 'Bad request' });
+    }
+    const { project: rawName, session: sessionId, mode } = body || {};
+    if (typeof rawName !== 'string' || typeof sessionId !== 'string') {
+        return respond(400, { action: 'error', message: 'project and session are required' });
+    }
+    const projects = await (0, discover_1.listProjects)();
+    const project = projects.find((p) => p.rawName === rawName);
+    const sessionPath = project ? path.join(project.dir, `${sessionId}.jsonl`) : null;
+    if (!project || !sessionPath || !fs.existsSync(sessionPath)) {
+        return respond(404, { action: 'error', message: 'Session not found' });
+    }
+    const cwd = await (0, discover_1.readCwdFromSession)(sessionPath);
+    if (!cwd)
+        return respond(200, { action: 'error', message: 'No cwd recorded in this session' });
+    if (!fs.existsSync(cwd)) {
+        return respond(200, { action: 'error', message: `Directory no longer exists: ${cwd}` });
+    }
+    const command = (0, cmux_1.buildResumeCommand)(cwd, sessionId);
+    if (NO_CMUX) {
+        return respond(200, { action: 'unavailable', command });
+    }
+    // Any cmux call can fail if the long-running server has lost contact with the
+    // current cmux instance (Mac sleep/wake, cmux restart). Rather than surface a
+    // hard error or hide the button, fall back to handing back the copy command
+    // with a hint to restart ccakashic if it persists.
+    try {
+        // Already open via a previous resume → jump instead of forking.
+        const liveWorkspace = await (0, cmux_1.findLiveWorkspaceForSession)(sessionId);
+        if (liveWorkspace) {
+            await (0, cmux_1.selectWorkspace)(liveWorkspace);
+            return respond(200, { action: 'jumped', workspace: liveWorkspace });
+        }
+        const sessions = await (0, discover_1.listSessions)(project.dir);
+        const preview = sessions.find((s) => s.id === sessionId);
+        const title = preview?.customTitle || preview?.aiTitle || preview?.slug || sessionId.slice(0, 8);
+        const result = await (0, cmux_1.resumeInNewWorkspace)(cwd, sessionId, title, mode === 'background');
+        (0, cmux_1.saveResumeMapEntry)(sessionId, result.workspaceId);
+        return respond(200, { action: 'resumed', workspace: result.workspaceId });
+    }
+    catch (err) {
+        if (process.env.CCAKASHIC_DEBUG)
+            console.error('[resume] cmux failed:', err?.message || err);
+        return respond(200, {
+            action: 'unavailable',
+            command,
+            message: 'cmux unreachable — copied the command instead. If this persists, restart ccakashic.',
+        });
+    }
+}
+// Only accept loopback Host headers. The server binds 127.0.0.1, but without
+// this check a malicious site could DNS-rebind its hostname to 127.0.0.1 and
+// become same-origin, defeating the resume token and reading session content.
+function isAllowedHost(host) {
+    if (!host)
+        return false;
+    const hostname = host.replace(/:\d+$/, '').toLowerCase();
+    return hostname === '127.0.0.1' || hostname === 'localhost' || hostname === '[::1]' || hostname === '::1';
+}
 const server = http.createServer(async (req, res) => {
     try {
+        if (!isAllowedHost(req.headers.host)) {
+            res.writeHead(403, { 'Content-Type': 'text/plain' });
+            res.end('Forbidden: invalid Host header');
+            return;
+        }
         const url = new URL(req.url || '/', `http://localhost`);
         const pathname = url.pathname;
         if (pathname === '/__ccakashic') {
@@ -63,12 +237,60 @@ const server = http.createServer(async (req, res) => {
             res.end(JSON.stringify({ name: 'ccakashic', version: pkg.version }));
             return;
         }
+        if (pathname === '/api/resume') {
+            await handleResume(req, res);
+            return;
+        }
         if (pathname === '/' || pathname === '') {
+            const requested = parseInt(url.searchParams.get('n') || '') || dashboard_1.DEFAULT_PANE_COUNT;
+            const paneCount = dashboard_1.PANE_COUNTS.includes(requested) ? requested : dashboard_1.DEFAULT_PANE_COUNT;
+            const recent = await (0, discover_1.listRecentSessions)(paneCount);
+            const cmuxWait = await buildCmuxWaitMap();
+            const panes = await Promise.all(recent.map(async (session) => ({
+                session,
+                bodyHtml: (0, dashboard_1.renderPaneBody)(await (0, parser_1.parseSessionCached)(session.path, session.lastModified)),
+                waiting: resolveWaiting(session.id, cmuxWait),
+            })));
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end((0, dashboard_1.generateDashboard)(panes, paneCount, await buildResumeContext()));
+            return;
+        }
+        if (pathname === '/projects') {
             const projects = await (0, discover_1.listProjects)();
             res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
             res.end((0, pages_1.generateIndex)(projects));
             return;
         }
+        if (pathname === '/api/pane') {
+            const rawName = url.searchParams.get('project') || '';
+            const sessionId = url.searchParams.get('session') || '';
+            const since = parseFloat(url.searchParams.get('since') || '0');
+            const projects = await (0, discover_1.listProjects)();
+            const project = projects.find((p) => p.rawName === rawName);
+            const sessionPath = project ? path.join(project.dir, `${sessionId}.jsonl`) : null;
+            if (!project || !sessionPath || !fs.existsSync(sessionPath)) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Session not found' }));
+                return;
+            }
+            const mtime = fs.statSync(sessionPath).mtimeMs;
+            const status = (0, dashboard_1.paneStatus)(mtime);
+            const ago = (0, dashboard_1.timeAgo)(mtime);
+            const cmuxWait = await buildCmuxWaitMap();
+            const waiting = resolveWaiting(sessionId, cmuxWait);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            // mtimeMs is sub-millisecond (nanosecond FS resolution) so distinct
+            // appends get distinct values; `<=` means "nothing newer since last poll".
+            // Waiting still re-evaluates here (cmux notifications change without the
+            // jsonl growing) so the badge clears on the next poll after you open a tab.
+            if (mtime <= since) {
+                res.end(JSON.stringify({ changed: false, status, ago, waiting }));
+                return;
+            }
+            const parsed = await (0, parser_1.parseSessionCached)(sessionPath, mtime);
+            res.end(JSON.stringify({ changed: true, mtime, status, ago, waiting, html: (0, dashboard_1.renderPaneBody)(parsed) }));
+            return;
+        }
         const projectMatch = pathname.match(/^\/project\/(.+)$/);
         if (projectMatch && !pathname.includes('/session/')) {
             const rawName = decodeURIComponent(projectMatch[1]);
@@ -81,7 +303,7 @@ const server = http.createServer(async (req, res) => {
             }
             const sessions = await (0, discover_1.listSessions)(project.dir);
             res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-            res.end((0, pages_1.generateSessionList)(project, sessions));
+            res.end((0, pages_1.generateSessionList)(project, sessions, await buildResumeContext()));
             return;
         }
         const sessionMatch = pathname.match(/^\/project\/(.+)\/session\/(.+)$/);
@@ -104,7 +326,13 @@ const server = http.createServer(async (req, res) => {
             const sessions = await (0, discover_1.listSessions)(project.dir);
             const session = sessions.find((s) => s.id === sessionId) || { id: sessionId, path: sessionPath };
             const parsed = await (0, parser_1.parseSession)(sessionPath);
-            const html = (0, html_generator_1.generate)(parsed, { projectName: project.name, session, backUrl: `/project/${encodeURIComponent(rawName)}` });
+            const html = (0, html_generator_1.generate)(parsed, {
+                projectName: project.name,
+                projectRawName: rawName,
+                session,
+                backUrl: `/project/${encodeURIComponent(rawName)}`,
+                resume: await buildResumeContext(),
+            });
             res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
             res.end(html);
             return;
@@ -219,7 +447,7 @@ async function main() {
         const url = `http://127.0.0.1:${existing}`;
         console.log(`Reusing existing ccakashic at ${url}`);
         writeLockFile(existing);
-        openInBrowser(await buildOpenUrl(url));
+        await openUrl(await buildOpenUrl(url));
         return;
     }
     const result = await startServer(PORT);
@@ -228,7 +456,7 @@ async function main() {
         const url = `http://127.0.0.1:${port}`;
         console.log(`Reusing existing ccakashic at ${url}`);
         writeLockFile(port);
-        openInBrowser(await buildOpenUrl(url));
+        await openUrl(await buildOpenUrl(url));
         return;
     }
     const port = result;
@@ -240,7 +468,7 @@ async function main() {
     process.on('SIGINT', cleanup);
     process.on('SIGTERM', cleanup);
     process.on('exit', cleanupLockFile);
-    openInBrowser(await buildOpenUrl(url));
+    await openUrl(await buildOpenUrl(url));
 }
 main().catch((err) => {
     console.error(err);

package/dist/cmux.js

@@ -0,0 +1,274 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCmuxAvailable = isCmuxAvailable;
+exports.shellQuote = shellQuote;
+exports.buildResumeCommand = buildResumeCommand;
+exports.listWorkspaceIds = listWorkspaceIds;
+exports.listWorkspaceIdsCached = listWorkspaceIdsCached;
+exports.parseWaitingNotifications = parseWaitingNotifications;
+exports.listWaitingWorkspaces = listWaitingWorkspaces;
+exports.listWaitingWorkspacesCached = listWaitingWorkspacesCached;
+exports.currentWorkspaceId = currentWorkspaceId;
+exports.selectWorkspace = selectWorkspace;
+exports.resumeInNewWorkspace = resumeInNewWorkspace;
+exports.parseOkId = parseOkId;
+exports.openInCmuxBrowser = openInCmuxBrowser;
+exports.loadResumeMap = loadResumeMap;
+exports.saveResumeMapEntry = saveResumeMapEntry;
+exports.loadWorkspaceToSession = loadWorkspaceToSession;
+exports.findLiveWorkspaceForSession = findLiveWorkspaceForSession;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'ccakashic');
+const RESUME_MAP_FILE = path.join(CONFIG_DIR, 'resume-map.json');
+// Resolve the cmux binary. PATH alone is unreliable: `npx ccakashic` is often
+// launched from a GUI terminal / login shell whose PATH omits Homebrew, so a
+// bare execFile('cmux') fails with ENOENT and the whole integration silently
+// disables (only the Copy button survives). Honor CCAKASHIC_CMUX, then fall
+// back to PATH, then to the common install locations.
+function resolveCmuxBin() {
+    const candidates = [
+        process.env.CCAKASHIC_CMUX,
+        '/opt/homebrew/bin/cmux', // Apple Silicon Homebrew
+        '/usr/local/bin/cmux', // Intel Homebrew / manual installs
+    ].filter(Boolean);
+    for (const c of candidates) {
+        try {
+            if (fs.existsSync(c))
+                return c;
+        }
+        catch {
+            // ignore and try the next candidate
+        }
+    }
+    return 'cmux'; // last resort: rely on PATH
+}
+const CMUX_BIN = resolveCmuxBin();
+function run(args, timeoutMs = 5000) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.execFile)(CMUX_BIN, args, { timeout: timeoutMs }, (err, stdout, stderr) => {
+            if (err) {
+                if (process.env.CCAKASHIC_DEBUG)
+                    console.error('[cmux]', args.join(' '), '->', err.message, stderr);
+                reject(new Error((stderr || err.message).trim()));
+            }
+            else {
+                resolve(stdout.trim());
+            }
+        });
+    });
+}
+let everAvailable = false;
+let cachedUnavailableAt = 0;
+async function isCmuxAvailable() {
+    // Sticky-positive: once cmux has answered, keep reporting available for the
+    // life of the process. A long-running server can transiently lose contact
+    // with cmux (Mac sleep/wake, cmux app restart) and `ping` then fails — but we
+    // must NOT hide the Resume UI on such a blip. The buttons stay; if cmux is
+    // genuinely unreachable at click time, /api/resume degrades to the copy
+    // command. Negative results are cached only ~5s so first contact is quick.
+    if (everAvailable)
+        return true;
+    if (cachedUnavailableAt && Date.now() - cachedUnavailableAt < 5_000)
+        return false;
+    let value = false;
+    try {
+        value = (await run(['ping'], 2500)) === 'PONG';
+    }
+    catch {
+        value = false;
+    }
+    if (value)
+        everAvailable = true;
+    else
+        cachedUnavailableAt = Date.now();
+    return value;
+}
+function shellQuote(s) {
+    return `'` + s.replace(/'/g, `'\\''`) + `'`;
+}
+function buildResumeCommand(cwd, sessionId) {
+    return `cd ${shellQuote(cwd)} && claude --resume ${shellQuote(sessionId)}`;
+}
+async function listWorkspaceIds() {
+    const out = await run(['--json', '--id-format', 'both', 'list-workspaces']);
+    const data = JSON.parse(out);
+    const ids = new Set();
+    for (const ws of data.workspaces || []) {
+        if (ws.id)
+            ids.add(String(ws.id).toUpperCase());
+    }
+    return ids;
+}
+let cachedWorkspaceIds = null;
+// Cached variant for page renders: buildResumeContext runs on every request
+// and only needs workspace liveness to pick the Resume vs Jump button label,
+// which tolerates a few seconds of staleness. Avoids spawning a cmux
+// subprocess on each navigation.
+async function listWorkspaceIdsCached() {
+    if (cachedWorkspaceIds && Date.now() - cachedWorkspaceIds.at < 5_000) {
+        return cachedWorkspaceIds.value;
+    }
+    const value = await listWorkspaceIds();
+    cachedWorkspaceIds = { value, at: Date.now() };
+    return value;
+}
+// Map of workspaceId → wait reason, derived from cmux's UNREAD notifications.
+// cmux marks a notification read once you focus its workspace, so an unread
+// "Claude is waiting" / "needs your permission" is a live "needs attention"
+// signal that matches the desktop notification ring.
+function parseWaitingNotifications(data) {
+    const result = new Map();
+    if (!Array.isArray(data))
+        return result;
+    for (const n of data) {
+        if (!n || n.is_read || !n.workspace_id)
+            continue;
+        const body = String(n.body || '').toLowerCase();
+        const reason = body.includes('permission') ? 'permission' : 'input';
+        // permission outranks a plain input wait if both exist for one workspace
+        const ws = String(n.workspace_id).toUpperCase();
+        if (reason === 'permission' || !result.has(ws))
+            result.set(ws, reason);
+    }
+    return result;
+}
+async function listWaitingWorkspaces() {
+    const out = await run(['--json', 'list-notifications']);
+    return parseWaitingNotifications(JSON.parse(out));
+}
+let cachedWaiting = null;
+async function listWaitingWorkspacesCached() {
+    if (cachedWaiting && Date.now() - cachedWaiting.at < 5_000)
+        return cachedWaiting.value;
+    const value = await listWaitingWorkspaces();
+    cachedWaiting = { value, at: Date.now() };
+    return value;
+}
+async function currentWorkspaceId() {
+    try {
+        const out = await run(['--json', '--id-format', 'both', 'current-workspace']);
+        const data = JSON.parse(out);
+        return data.workspace_id ? String(data.workspace_id).toUpperCase() : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function selectWorkspace(id) {
+    await run(['select-workspace', '--workspace', id]);
+}
+async function resumeInNewWorkspace(cwd, sessionId, title, background) {
+    const prev = background ? await currentWorkspaceId() : null;
+    const out = await run(['new-workspace', '--command', buildResumeCommand(cwd, sessionId)]);
+    const workspaceId = parseOkId(out);
+    if (title) {
+        try {
+            await run(['rename-workspace', '--workspace', workspaceId, title]);
+        }
+        catch {
+            // title is cosmetic; the workspace is already running
+        }
+    }
+    // Foreground: jump to the new workspace (new-workspace doesn't reliably
+    // focus it). Background: restore the workspace we were on.
+    try {
+        await selectWorkspace(prev || workspaceId);
+    }
+    catch {
+        // focus is best-effort; the workspace is already running either way
+    }
+    return { workspaceId };
+}
+function parseOkId(output) {
+    const match = output.match(/^OK\s+(\S+)/);
+    if (!match)
+        throw new Error(`Unexpected cmux output: ${output}`);
+    return match[1].toUpperCase();
+}
+async function openInCmuxBrowser(url) {
+    await run(['browser', 'open', url]);
+}
+// --- sessionId → workspaceId mapping, so a second Resume click jumps to the
+// --- already-open workspace instead of forking the session.
+function loadResumeMap() {
+    try {
+        const data = JSON.parse(fs.readFileSync(RESUME_MAP_FILE, 'utf-8'));
+        return data && typeof data === 'object' ? data : {};
+    }
+    catch {
+        return {};
+    }
+}
+function saveResumeMapEntry(sessionId, workspaceId) {
+    try {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        const map = loadResumeMap();
+        map[sessionId] = workspaceId;
+        // Atomic write: a crash mid-write would otherwise truncate the file, and
+        // loadResumeMap swallows the parse error and returns {} — wiping every
+        // mapping. Write to a temp file and rename (atomic on the same fs).
+        const tmp = `${RESUME_MAP_FILE}.${process.pid}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(map, null, 2));
+        fs.renameSync(tmp, RESUME_MAP_FILE);
+    }
+    catch {
+        // best-effort: losing the map only means a duplicate workspace later
+    }
+}
+// Inverse of the resume map: workspaceId(upper) → sessionId. Only covers
+// sessions ccakashic itself resumed (manually-opened ones aren't tracked).
+function loadWorkspaceToSession() {
+    const inv = new Map();
+    for (const [sessionId, wsId] of Object.entries(loadResumeMap())) {
+        inv.set(wsId.toUpperCase(), sessionId);
+    }
+    return inv;
+}
+async function findLiveWorkspaceForSession(sessionId) {
+    const mapped = loadResumeMap()[sessionId];
+    if (!mapped)
+        return null;
+    try {
+        const live = await listWorkspaceIds();
+        return live.has(mapped.toUpperCase()) ? mapped.toUpperCase() : null;
+    }
+    catch {
+        return null;
+    }
+}