ccakashic 0.6.0 → 0.7.0

package/README.md

@@ -81,13 +81,16 @@ After a reboot (memory pressure, an update) or a hung cmux you had to kill, ever
 
 ```bash
 # From a terminal inside cmux
-npx ccakashic restore            # lists the sessions you had open, then reopens them
+npx ccakashic restore            # pick from the sessions you had open, then reopen them
+npx ccakashic restore --yes      # reopen all of them, no prompt
 npx ccakashic restore --dry-run  # just list them
 
 # Optional: record open sessions every minute (launchd, macOS) for an exact list
 npx ccakashic install-agent
 ```
 
+`restore` opens a checkbox list with every session ticked: `space` toggles one, `a` toggles all, `enter` reopens what is ticked, `q` cancels. So reopening the lot is just `enter`, and reopening one is `a` then `space`. Piped or non-interactive, it needs `--yes`.
+
 **No setup needed.** Without the agent, the list is estimated from the conversation logs: the most recent group of sessions that stopped together. When they were closed normally — including by a shutdown or reboot — each wrote an exit record at the same moment, so the group is precise. When cmux was force-quit nothing gets written, so it falls back to "active within 15 minutes of the last one", which misses sessions that sat idle. Install the agent if that case matters to you.
 
 Sessions are only offered when **none of the group is still running** alongside something older: if you closed one session while others kept going, nothing is offered. Sessions you have already reopened drop off the list, and once a group is fully reopened, older ones are not dug up.

package/dist/bin/ccakashic.js

@@ -38,7 +38,6 @@ const http = __importStar(require("http"));
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
-const readline = __importStar(require("readline"));
 const child_process_1 = require("child_process");
 const util_1 = require("../util");
 const discover_1 = require("../discover");
@@ -49,6 +48,7 @@ const pages_1 = require("../pages");
 const dashboard_1 = require("../dashboard");
 const snapshot_1 = require("../snapshot");
 const restore_1 = require("../restore");
+const picker_1 = require("../picker");
 const agent_1 = require("../agent");
 const cmux_1 = require("../cmux");
 // Published at dist/bin/ccakashic.js, so ../../package.json resolves from dist/
@@ -534,15 +534,6 @@ function formatClock(ms) {
     const pad = (n) => String(n).padStart(2, '0');
     return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
 }
-function askYesNo(question) {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    return new Promise((resolve) => {
-        rl.question(question, (answer) => {
-            rl.close();
-            resolve(/^(y|yes|)$/i.test(answer.trim()));
-        });
-    });
-}
 async function runRestoreCommand() {
     const dryRun = process.argv.includes('--dry-run');
     const yes = process.argv.includes('--yes') || process.argv.includes('-y');
@@ -565,21 +556,48 @@ async function runRestoreCommand() {
         return;
     }
     const items = await (0, restore_1.describeStopped)(stop.sessions);
-    console.log(`${items.length} session(s) you had open until ${formatClock(stop.stoppedAt)}${stop.estimated ? ' (estimated)' : ''}:\n`);
-    for (const it of items)
-        console.log(`  • ${it.title}\n    ${it.cwd}`);
-    console.log('');
+    const heading = `${items.length} session(s) you had open until ${formatClock(stop.stoppedAt)}${stop.estimated ? ' (estimated)' : ''}:`;
+    const printList = () => {
+        console.log(`${heading}\n`);
+        for (const it of items)
+            console.log(`  • ${it.title}\n    ${it.cwd}`);
+        console.log('');
+    };
     if (dryRun)
-        return;
+        return printList();
     if (NO_CMUX || !(await (0, cmux_1.isCmuxAvailable)())) {
+        printList();
         console.log('cmux is not reachable (run this from a terminal inside cmux). Commands to resume by hand:\n');
         for (const it of items)
             console.log((0, cmux_1.buildResumeCommand)(it.cwd, it.sessionId));
         return;
     }
-    if (!yes && !(await askYesNo(`Reopen all ${items.length} in new cmux workspaces? [Y/n] `)))
-        return;
-    const outcomes = await (0, restore_1.restoreAll)(items, (o) => {
+    // Interactive: a checkbox list, everything ticked, so reopening all is just
+    // Enter. --yes (or a pipe, where there are no keys to read) takes them all.
+    let chosen = items;
+    if (!yes) {
+        if (!process.stdin.isTTY) {
+            printList();
+            console.log('Re-run with --yes to reopen them (no terminal to choose in).');
+            return;
+        }
+        console.log(heading);
+        const picked = await (0, picker_1.pickItems)(items.map((it) => ({ label: it.title, hint: it.cwd })));
+        if (picked === null) {
+            console.log('Cancelled.');
+            return;
+        }
+        chosen = picked.map((i) => items[i]);
+        if (!chosen.length) {
+            console.log('Nothing selected.');
+            return;
+        }
+        console.log('');
+    }
+    else {
+        printList();
+    }
+    const outcomes = await (0, restore_1.restoreAll)(chosen, (o) => {
         console.log(o.ok ? `  ✓ ${o.title}` : `  ✗ ${o.title} — ${o.message}`);
     });
     const failed = outcomes.filter((o) => !o.ok).length;

package/dist/discover.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLAUDE_DIR = void 0;
+exports.listKnownSessionIds = listKnownSessionIds;
 exports.decodeDirName = decodeDirName;
 exports.listProjects = listProjects;
 exports.listSessions = listSessions;
@@ -46,6 +47,32 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const readline = __importStar(require("readline"));
 exports.CLAUDE_DIR = path.join(os.homedir(), '.claude', 'projects');
+// Every session id that has a conversation log, by filename only (no parsing).
+// A session with no log cannot be resumed, so restore uses this to skip them.
+function listKnownSessionIds(root = exports.CLAUDE_DIR) {
+    const ids = new Set();
+    let dirs;
+    try {
+        dirs = fs.readdirSync(root);
+    }
+    catch {
+        return ids;
+    }
+    for (const d of dirs) {
+        let names;
+        try {
+            names = fs.readdirSync(path.join(root, d));
+        }
+        catch {
+            continue;
+        }
+        for (const f of names) {
+            if (f.endsWith('.jsonl'))
+                ids.add(f.slice(0, -'.jsonl'.length));
+        }
+    }
+    return ids;
+}
 function decodeDirName(dirName) {
     // Directory names encode paths: /Users/foo/bar → -Users-foo-bar
     // This is lossy (dots become dashes too), but good enough for display

package/dist/infer.js

@@ -38,6 +38,7 @@ exports.inferLastStop = inferLastStop;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const discover_1 = require("./discover");
+const snapshot_1 = require("./snapshot");
 // Best-effort "what was running before the crash" from the conversation logs
 // alone, for when the snapshot agent is not installed.
 //
@@ -131,7 +132,7 @@ function listLogFiles(root, since) {
     }
     return out.sort((a, b) => b.mtime - a.mtime);
 }
-function inferLastStop(live, now = Date.now(), root = discover_1.CLAUDE_DIR, readFacts = readLogFacts) {
+function inferLastStop(live, now = Date.now(), root = discover_1.CLAUDE_DIR, readFacts = readLogFacts, notOlderThan = 0) {
     const liveIds = new Set(live.map((s) => s.sessionId));
     const factsCache = new Map();
     const facts = (f) => {
@@ -140,29 +141,35 @@ function inferLastStop(live, now = Date.now(), root = discover_1.CLAUDE_DIR, rea
             factsCache.set(f.file, (v = readFacts(f.file)));
         return v;
     };
-    // Newest interactive session that is no longer running marks the stop.
-    const dead = listLogFiles(root, now - LOOKBACK_MS).filter((f) => !liveIds.has(f.sessionId));
-    const newest = dead.find((f) => facts(f).interactive && facts(f).cwd);
-    if (!newest)
+    const dead = listLogFiles(root, now - LOOKBACK_MS)
+        .filter((f) => !liveIds.has(f.sessionId) && facts(f).interactive && facts(f).cwd);
+    if (!dead.length)
         return null;
-    const stoppedAt = Math.floor(newest.mtime); // an integer survives the round trip through the page
-    // Same rule as the recorded path: a session started before the stop and still
-    // running means the others were closed on purpose, not killed together.
-    if (live.some((s) => s.startedAt !== undefined && s.startedAt <= stoppedAt))
+    // Same shape as the recorded path: prefer a group that stopped together over a
+    // lone session that happens to be newer (a scheduled run, a quick question).
+    // Without exit records the times are "last active", so they spread out more.
+    const anchor = dead[0];
+    const gap = facts(anchor).exited ? EXIT_BURST_WINDOW_MS : ACTIVITY_WINDOW_MS;
+    const group = (0, snapshot_1.pickStoppedGroup)(dead, (f) => f.mtime, gap);
+    const burst = facts(group[0]).exited;
+    const stoppedAt = Math.floor(group[0].mtime); // an integer survives the round trip through the page
+    if (stoppedAt < notOlderThan)
         return null;
-    const burst = facts(newest).exited;
-    const window = burst ? EXIT_BURST_WINDOW_MS : ACTIVITY_WINDOW_MS;
-    const sessions = [];
-    for (const f of dead) {
-        if (f.mtime < stoppedAt - window)
-            break; // sorted newest first
-        const x = facts(f);
-        if (!x.interactive || !x.cwd)
-            continue;
+    // Same rule as the recorded path: only a lone stop is explained away by
+    // something older still running.
+    const liveSince = live.map((s) => s.startedAt).filter((v) => v !== undefined);
+    if ((0, snapshot_1.survivedBy)(group.length, liveSince, stoppedAt))
+        return null;
+    const sessions = group
         // In a shutdown burst, only sessions that actually exited belong to it.
-        if (burst && !x.exited)
-            continue;
-        sessions.push({ sessionId: f.sessionId, cwd: x.cwd, name: null, proc: 'log', aliveSince: f.mtime, lastSeenAlive: f.mtime });
-    }
+        .filter((f) => !burst || facts(f).exited)
+        .map((f) => ({
+        sessionId: f.sessionId,
+        cwd: facts(f).cwd,
+        name: null,
+        proc: 'log',
+        aliveSince: f.mtime,
+        lastSeenAlive: f.mtime,
+    }));
     return { stoppedAt, sessions, estimated: true };
 }

package/dist/picker.js

@@ -0,0 +1,140 @@
+"use strict";
+// A checkbox list for the terminal: pick which sessions to reopen. No
+// dependencies, so the state machine and the rendering are plain functions and
+// only the last few lines touch stdin.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialState = initialState;
+exports.keyOf = keyOf;
+exports.applyKey = applyKey;
+exports.renderLines = renderLines;
+exports.pickItems = pickItems;
+const ESC = '\u001b';
+function initialState(count, rows) {
+    return { cursor: 0, checked: new Array(count).fill(true), offset: 0, rows: Math.max(1, Math.min(rows, count)) };
+}
+// Names the keys the loop cares about; anything else is ignored.
+function keyOf(data) {
+    switch (data) {
+        case '\u0003': return 'cancel'; // Ctrl-C
+        case '\u0004': return 'cancel'; // Ctrl-D
+        case 'q':
+        case ESC: return 'cancel';
+        case '\r':
+        case '\n': return 'confirm';
+        case ' ': return 'toggle';
+        case 'a': return 'toggleAll';
+        case `${ESC}[A`:
+        case 'k': return 'up';
+        case `${ESC}[B`:
+        case 'j': return 'down';
+        case `${ESC}[H`:
+        case 'g': return 'first';
+        case `${ESC}[F`:
+        case 'G': return 'last';
+        default: return '';
+    }
+}
+function applyKey(state, key) {
+    const count = state.checked.length;
+    const next = { ...state, checked: state.checked.slice() };
+    switch (key) {
+        case 'cancel': return { state, action: 'cancel' };
+        case 'confirm': return { state, action: 'confirm' };
+        case 'toggle':
+            next.checked[next.cursor] = !next.checked[next.cursor];
+            // Step down so space-space-space walks the list, as in most pickers.
+            next.cursor = Math.min(count - 1, next.cursor + 1);
+            break;
+        case 'toggleAll': {
+            // All on unless they already are, in which case clear them.
+            const allOn = next.checked.every(Boolean);
+            next.checked = next.checked.map(() => !allOn);
+            break;
+        }
+        case 'up':
+            next.cursor = Math.max(0, next.cursor - 1);
+            break;
+        case 'down':
+            next.cursor = Math.min(count - 1, next.cursor + 1);
+            break;
+        case 'first':
+            next.cursor = 0;
+            break;
+        case 'last':
+            next.cursor = count - 1;
+            break;
+        default: return { state, action: null };
+    }
+    // Keep the cursor inside the visible window.
+    if (next.cursor < next.offset)
+        next.offset = next.cursor;
+    if (next.cursor >= next.offset + next.rows)
+        next.offset = next.cursor - next.rows + 1;
+    return { state: next, action: null };
+}
+function renderLines(items, state, width = 80) {
+    const lines = [];
+    const picked = state.checked.filter(Boolean).length;
+    lines.push(`Select sessions to reopen (${picked}/${items.length})`);
+    lines.push('space toggle · a all/none · ↑↓ move · enter reopen · q cancel');
+    const end = Math.min(items.length, state.offset + state.rows);
+    for (let i = state.offset; i < end; i++) {
+        const box = state.checked[i] ? '[x]' : '[ ]';
+        const pointer = i === state.cursor ? '>' : ' ';
+        const hint = items[i].hint ? `  ${items[i].hint}` : '';
+        lines.push(truncate(`${pointer} ${box} ${items[i].label}${hint}`, width));
+    }
+    if (end < items.length || state.offset > 0) {
+        lines.push(`    … ${state.offset + 1}-${end} of ${items.length}`);
+    }
+    return lines;
+}
+function truncate(s, width) {
+    return s.length <= width ? s : `${s.slice(0, Math.max(1, width - 1))}…`;
+}
+// Runs the list on a TTY and resolves with the chosen indices, or null if the
+// user backed out. Callers must check process.stdin.isTTY first.
+function pickItems(items, io = { input: process.stdin, output: process.stdout }) {
+    const { input, output } = io;
+    const viewRows = Math.max(3, (output.rows || 24) - 4);
+    let state = initialState(items.length, viewRows);
+    let drawn = 0;
+    const draw = () => {
+        if (drawn)
+            output.write(`${ESC}[${drawn}A`); // back to the top of the list
+        output.write(`${ESC}[J`); // clear from here down
+        const lines = renderLines(items, state, (output.columns || 80) - 1);
+        output.write(`${lines.join('\n')}\n`);
+        drawn = lines.length;
+    };
+    return new Promise((resolve) => {
+        const finish = (result) => {
+            input.setRawMode?.(false);
+            input.pause();
+            input.removeListener('data', onData);
+            output.write(`${ESC}[?25h`); // cursor back on
+            resolve(result);
+        };
+        const onData = (buf) => {
+            const key = keyOf(buf.toString());
+            if (!key)
+                return;
+            const next = applyKey(state, key);
+            state = next.state;
+            if (next.action === 'cancel')
+                return finish(null);
+            if (next.action === 'confirm') {
+                const chosen = state.checked.flatMap((on, i) => (on ? [i] : []));
+                draw();
+                return finish(chosen);
+            }
+            draw();
+        };
+        output.write(`${ESC}[?25l`); // hide the cursor while redrawing
+        input.setRawMode?.(true);
+        input.resume();
+        input.setEncoding('utf-8');
+        input.on('data', onData);
+        draw();
+    });
+}

package/dist/restore.js

@@ -53,7 +53,8 @@ const STAGGER_MS = 1500;
 function detectLastStop(now = Date.now()) {
     const live = (0, snapshot_1.readLiveSessions)();
     const agentInstalled = fs.existsSync(agent_1.AGENT_PLIST);
-    const { state, stop } = chooseStop((0, snapshot_1.recordLive)((0, snapshot_1.loadSnapshot)(), live, now), live, agentInstalled, () => (0, infer_1.inferLastStop)(live, now));
+    const known = (0, discover_1.listKnownSessionIds)();
+    const { state, stop } = chooseStop((0, snapshot_1.recordLive)((0, snapshot_1.loadSnapshot)(), live, now), live, agentInstalled, (notOlderThan) => (0, infer_1.inferLastStop)(live, now, undefined, undefined, notOlderThan), (id) => known.has(id));
     try {
         (0, snapshot_1.saveSnapshot)(state);
     }
@@ -64,23 +65,26 @@ function detectLastStop(now = Date.now()) {
 }
 // Pure decision between the agent's records and a log estimate; returns the
 // state to persist alongside it.
-function chooseStop(state, live, agentInstalled, infer) {
-    if (agentInstalled) {
-        const recorded = (0, snapshot_1.findLastStop)(state, new Set(live.map((s) => s.sessionId)));
-        if (recorded)
-            return { state, stop: recorded };
-    }
-    const inferred = infer();
-    if (!inferred)
-        return { state, stop: null };
-    // Within the recorded period the agent saw no stop, so trust it over a guess.
-    if (agentInstalled && state.recordingSince !== null && inferred.stoppedAt >= state.recordingSince) {
-        return { state, stop: null };
-    }
-    if (state.lastEstimatedStopAt !== null && inferred.stoppedAt < state.lastEstimatedStopAt) {
+function chooseStop(state, live, agentInstalled, infer, resumable = () => true) {
+    // Never dig further back than the last group offered: once those are reopened,
+    // the group before them is just history, not something that stopped on you.
+    const floor = state.lastOfferedStopAt ?? 0;
+    const liveIds = new Set(live.map((s) => s.sessionId));
+    const stop = (agentInstalled ? (0, snapshot_1.findLastStop)(state, liveIds, resumable, floor) : null)
+        // Within the recorded period the agent's records are the truth, so the log
+        // estimate is only for stops from before recording began.
+        ?? inferBeforeRecording(state, agentInstalled, infer, floor);
+    if (!stop)
         return { state, stop: null };
-    }
-    return { state: { ...state, lastEstimatedStopAt: inferred.stoppedAt }, stop: inferred };
+    return { state: { ...state, lastOfferedStopAt: Math.max(floor, stop.stoppedAt) }, stop };
+}
+function inferBeforeRecording(state, agentInstalled, infer, floor) {
+    const inferred = infer(floor);
+    if (!inferred)
+        return null;
+    if (agentInstalled && state.recordingSince !== null && inferred.stoppedAt >= state.recordingSince)
+        return null;
+    return inferred;
 }
 async function describeStopped(sessions) {
     const previews = await (0, discover_1.findRecentSessionsByIds)(sessions.map((s) => s.sessionId));

package/dist/snapshot.js

@@ -40,6 +40,8 @@ exports.saveSnapshot = saveSnapshot;
 exports.readLiveSessions = readLiveSessions;
 exports.recordLive = recordLive;
 exports.findLastStop = findLastStop;
+exports.survivedBy = survivedBy;
+exports.pickStoppedGroup = pickStoppedGroup;
 exports.snapshotNow = snapshotNow;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -56,18 +58,25 @@ const path = __importStar(require("path"));
 const CONFIG_DIR = path.join(os.homedir(), '.config', 'ccakashic');
 exports.SNAPSHOT_FILE = path.join(CONFIG_DIR, 'live-sessions.json');
 const SESSION_REGISTRY_DIR = path.join(os.homedir(), '.claude', 'sessions');
-// Sessions killed by the same event share their last sighting, give or take a
-// run that was in progress while they went down.
-const GROUP_WINDOW_MS = 150_000;
+// Sessions killed by the same event share their last sighting, give or take the
+// run that was in progress while they went down. Measured between consecutive
+// sightings, not from the newest one: a session that was opened and closed after
+// the stop must not push the real group out of a fixed window.
+const GROUP_GAP_MS = 150_000;
 const RETENTION_MS = 14 * 24 * 60 * 60_000;
 function emptyState() {
-    return { version: 1, lastRunAt: 0, recordingSince: null, lastEstimatedStopAt: null, dismissedStopAt: null, sessions: {} };
+    return { version: 1, lastRunAt: 0, recordingSince: null, lastOfferedStopAt: null, dismissedStopAt: null, sessions: {} };
 }
 function loadSnapshot(file = exports.SNAPSHOT_FILE) {
     try {
         const data = JSON.parse(fs.readFileSync(file, 'utf-8'));
         if (data && data.version === 1 && data.sessions && typeof data.sessions === 'object') {
-            return { ...emptyState(), ...data };
+            const state = { ...emptyState(), ...data };
+            // 0.6.0 called it lastEstimatedStopAt, when only the log estimate used it.
+            if (state.lastOfferedStopAt === null && typeof data.lastEstimatedStopAt === 'number') {
+                state.lastOfferedStopAt = data.lastEstimatedStopAt;
+            }
+            return state;
         }
     }
     catch {
@@ -150,24 +159,50 @@ function recordLive(state, live, now) {
 // brought back. A group only counts as a stop when nothing survived it: if some
 // session was alive both before and after, the others were closed one by one on
 // purpose (/exit, closing a tab), not killed by a reboot or a hung cmux.
-function findLastStop(state, liveIds) {
+function findLastStop(state, liveIds, 
+// Sessions without a conversation log can't be resumed; leaving them in would
+// let a throwaway session started after the stop stand in for the group.
+resumable = () => true, notOlderThan = 0) {
     const dead = [];
     for (const [sessionId, e] of Object.entries(state.sessions)) {
-        if (!liveIds.has(sessionId))
+        if (!liveIds.has(sessionId) && resumable(sessionId))
             dead.push({ sessionId, ...e });
     }
     if (!dead.length)
         return null;
-    const stoppedAt = Math.max(...dead.map((d) => d.lastSeenAlive));
-    for (const id of liveIds) {
-        const e = state.sessions[id];
-        if (e && e.aliveSince <= stoppedAt)
-            return null;
+    dead.sort((a, b) => b.lastSeenAlive - a.lastSeenAlive || a.cwd.localeCompare(b.cwd));
+    const group = pickStoppedGroup(dead, (d) => d.lastSeenAlive);
+    const stoppedAt = group[0].lastSeenAlive;
+    if (stoppedAt < notOlderThan)
+        return null;
+    const liveSince = [...liveIds].map((id) => state.sessions[id]?.aliveSince).filter((v) => v !== undefined);
+    if (survivedBy(group.length, liveSince, stoppedAt))
+        return null;
+    return { stoppedAt, sessions: group };
+}
+// A lone session that stopped while something older kept running was closed on
+// purpose, so it is not offered. Several at once is a different story: they went
+// down together even if a session elsewhere (another terminal, the desktop app,
+// a scheduled run) was untouched by whatever took them.
+function survivedBy(groupSize, liveSince, stoppedAt) {
+    if (groupSize > 1)
+        return false;
+    return liveSince.some((since) => since <= stoppedAt);
+}
+// The most recent group that went down together, newest first. Sessions come
+// and go all day — a scheduled run, a quick question — and any of them would
+// otherwise stand in for the last stop just by being the newest. So a group of
+// several wins over a lone session, even a more recent one.
+function pickStoppedGroup(deadNewestFirst, at, gapMs = GROUP_GAP_MS) {
+    const clusters = [];
+    for (const item of deadNewestFirst) {
+        const current = clusters[clusters.length - 1];
+        if (current && at(current[current.length - 1]) - at(item) <= gapMs)
+            current.push(item);
+        else
+            clusters.push([item]);
     }
-    const sessions = dead
-        .filter((d) => d.lastSeenAlive >= stoppedAt - GROUP_WINDOW_MS)
-        .sort((a, b) => b.lastSeenAlive - a.lastSeenAlive || a.cwd.localeCompare(b.cwd));
-    return { stoppedAt, sessions };
+    return clusters.find((c) => c.length > 1) ?? clusters[0];
 }
 // One launchd tick. Kept free of any import beyond Node built-ins: the agent
 // runs a copy of this compiled file, not the installed package (see agent.ts).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccakashic",
-  "version": "0.6.0",
+  "version": "0.7.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"