claude-rpc 0.3.11 → 0.6.0

package/src/cli.js

@@ -8,7 +8,7 @@ import process from 'node:process';
 // code page on Win10 is 437/850, which displays many of our chars as `?`.
 // Hook events (no TTY) skip this — they don't print anything user-visible.
 if (process.platform === 'win32' && process.stdout.isTTY) {
-  try { spawnSync('chcp.com', ['65001'], { stdio: 'ignore', windowsHide: true }); } catch {}
+  try { spawnSync('chcp.com', ['65001'], { stdio: 'ignore', windowsHide: true }); } catch { /* chcp absent (Wine, custom shell) — accept whatever code page is set */ }
 }
 import { DAEMON_SCRIPT, PID_PATH, STATE_PATH, LOG_PATH, AGGREGATE_PATH, CONFIG_PATH, IS_PACKAGED, EXE_PATH, CANONICAL_EXE } from './paths.js';
 import { readState } from './state.js';
@@ -20,6 +20,10 @@ import { startTui } from './tui.js';
 import { generateInsights } from './insights.js';
 import { badgeSvg } from './badge.js';
 import { fmtCost } from './pricing.js';
+import { addPrivateCwd, removePrivateCwd, listPrivateCwds, resolveVisibility } from './privacy.js';
+import { loadConfig, hasUserConfig } from './config.js';
+import { VERSION } from './version.js';
+import { fail, EX_USER_ERROR, EX_BAD_STATE } from './ui.js';
 import { basename } from 'node:path';
 
 const cmd = process.argv[2];
@@ -245,7 +249,7 @@ function bar(val, max, width = 22) {
 function showStatus() {
   const state = readState();
   const aggregate = readAggregate();
-  const config = readJson(CONFIG_PATH, {});
+  const config = loadConfig();
   const live = findLiveSessions({ thresholdMs: 90_000 });
   state.liveSessions = live;
   const vars = buildVars(state, config, aggregate);
@@ -429,7 +433,7 @@ function showStatus() {
 function showToday() {
   const state = readState();
   const aggregate = readAggregate();
-  const config = readJson(CONFIG_PATH, {});
+  const config = loadConfig();
   state.liveSessions = findLiveSessions({ thresholdMs: 90_000 });
   const vars = buildVars(state, config, aggregate);
 
@@ -457,7 +461,7 @@ function showToday() {
 function showWeek() {
   const state = readState();
   const aggregate = readAggregate();
-  const config = readJson(CONFIG_PATH, {});
+  const config = loadConfig();
   state.liveSessions = findLiveSessions({ thresholdMs: 90_000 });
   const vars = buildVars(state, config, aggregate);
 
@@ -517,7 +521,7 @@ function statusColor(status) {
 function showPreview() {
   let state = readState();
   const aggregate = readAggregate();
-  const config = readJson(CONFIG_PATH, {});
+  const config = loadConfig();
   const live = findLiveSessions({ thresholdMs: 90_000 });
   state.liveSessions = live;
   state = applyIdle(state, config);
@@ -557,7 +561,7 @@ function showPreview() {
 // previous helper exactly: { vars: [sorted keys], live: <full vars object> }.
 function dumpVars() {
   let state = readState();
-  const config = readJson(CONFIG_PATH, {});
+  const config = loadConfig();
   state.liveSessions = findLiveSessions({ thresholdMs: 90_000 });
   state = applyIdle(state, config);
   const live = buildVars(state, config, readAggregate() || {});
@@ -579,9 +583,53 @@ function doScan(force = false) {
   });
   process.stdout.write('\n');
   console.log(`${c.green}✓${c.reset} Done in ${Date.now() - t0}ms — ${c.cyan}${result.scanned}${c.reset} parsed · ${result.skipped} cached · ${result.removed} removed (${result.total} total)`);
+  if (result.dirs && result.dirs.length > 1) {
+    console.log(`${c.dim}Scanned roots:${c.reset} ${result.dirs.join(', ')}`);
+  }
   console.log(`${c.dim}Aggregate written to ${AGGREGATE_PATH}${c.reset}`);
 }
 
+// Backfill from any folder that has .jsonl transcripts. Useful for:
+//   • restoring from a backup of ~/.claude
+//   • merging transcripts from another machine
+//   • importing data from an older Claude Code install with a non-default path
+//
+// Walks the given path recursively, adds every .jsonl to the existing cache,
+// and rebuilds the aggregate. Does NOT remove anything from the existing
+// aggregate — adds only.
+function doBackfill(argv) {
+  const path = argv[0];
+  if (!path) {
+    fail('usage: claude-rpc backfill <path>',
+      { hint: 'point at any folder containing .jsonl transcripts (e.g. a backup of ~/.claude/projects)' });
+  }
+  if (!existsSync(path)) {
+    fail(`path doesn't exist: ${path}`,
+      { hint: 'check the spelling, or run `claude-rpc doctor` to see where transcripts live' });
+  }
+  console.log(`${c.dim}Backfilling from${c.reset} ${c.cyan}${path}${c.reset}…`);
+  const t0 = Date.now();
+  let lastReport = 0;
+  // Pass `extraDirs` rather than `projectsDirs` — this way the default
+  // ~/.claude/projects (+ any auto-discovered alt paths) ALSO gets scanned
+  // and the user's existing cache for those isn't pruned.
+  const result = scan({
+    force: false,
+    extraDirs: [path],
+    onProgress: ({ scanned, total }) => {
+      if (Date.now() - lastReport > 500) {
+        process.stdout.write(`\r  parsed ${scanned}/${total}…`);
+        lastReport = Date.now();
+      }
+    },
+  });
+  process.stdout.write('\n');
+  console.log(`${c.green}✓${c.reset} Done in ${Date.now() - t0}ms — ${c.cyan}${result.scanned}${c.reset} new/changed · ${result.skipped} cached`);
+  console.log(`${c.dim}Scanned roots:${c.reset} ${result.dirs.join(', ')}`);
+  const hours = ((result.aggregate.activeMs || 0) / 3_600_000).toFixed(1);
+  console.log(`${c.dim}Aggregate now:${c.reset} ${result.aggregate.sessions} sessions · ${hours}h · ${result.aggregate.userMessages} prompts`);
+}
+
 function showInsights() {
   const aggregate = readAggregate();
   const insights = generateInsights(aggregate, { limit: 6 });
@@ -608,8 +656,7 @@ function doBadge(argv) {
   const opts = parseBadgeArgs(argv);
   const aggregate = readAggregate();
   if (!aggregate) {
-    console.error(`${c.yellow}No aggregate yet. Run ${c.cyan}claude-rpc scan${c.reset} first.`);
-    process.exit(1);
+    fail('no aggregate yet — nothing to render', { hint: 'run `claude-rpc scan` first', code: EX_BAD_STATE });
   }
   const svg = badgeSvg({ aggregate, metric: opts.metric, range: opts.range, label: opts.label });
   if (opts.out) {
@@ -620,6 +667,84 @@ function doBadge(argv) {
   }
 }
 
+// Poster-style SVG card. Bigger sibling of `badge` — shareable summary
+// for a range (year / month / week / all-time). Output is SVG only;
+// screenshot or convert to PNG offline if needed.
+function parseCardArgs(argv) {
+  const out = { range: 'year', out: '' };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--range' || a === '-r') out.range = argv[++i];
+    else if (a === '--out' || a === '-o') out.out = argv[++i];
+  }
+  return out;
+}
+
+async function doCard(argv) {
+  const opts = parseCardArgs(argv);
+  const aggregate = readAggregate();
+  if (!aggregate) {
+    fail('no aggregate yet — nothing to render', { hint: 'run `claude-rpc scan` first', code: EX_BAD_STATE });
+  }
+  const { renderCard } = await import('./card.js');
+  const svg = renderCard(aggregate, { range: opts.range });
+  if (opts.out) {
+    writeFileSync(opts.out, svg);
+    console.log(`${c.green}✓${c.reset} Wrote ${c.cyan}${opts.out}${c.reset} (${svg.length} bytes)`);
+    console.log(`${c.dim}Tip: open in a browser, right-click → Save as PNG. Or drop straight into a Discord message — it'll render inline.${c.reset}`);
+  } else {
+    process.stdout.write(svg);
+  }
+}
+
+// ── Privacy commands ─────────────────────────────────────────────────────
+//
+// `claude-rpc private`        → add current cwd to ~/.claude-rpc/private-list.json
+// `claude-rpc public`         → remove current cwd
+// `claude-rpc privacy`        → show resolved visibility for current cwd + listed paths
+//
+// Per-project overrides live in <project>/.claude-rpc.json and take priority
+// over the runtime list. See src/privacy.js for the full resolution chain.
+
+function doPrivate() {
+  const cwd = process.cwd();
+  const list = addPrivateCwd(cwd);
+  console.log(`${c.green}✓${c.reset} ${c.cyan}${cwd}${c.reset} marked private`);
+  console.log(`${c.dim}  ${list.length} ${list.length === 1 ? 'path' : 'paths'} in the private list. Daemon picks it up within ~5 min (cache TTL) or restart.${c.reset}`);
+}
+
+function doPublic() {
+  const cwd = process.cwd();
+  const before = listPrivateCwds().length;
+  const list = removePrivateCwd(cwd);
+  if (list.length === before) {
+    console.log(`${c.yellow}!${c.reset} ${c.cyan}${cwd}${c.reset} wasn't in the private list`);
+  } else {
+    console.log(`${c.green}✓${c.reset} ${c.cyan}${cwd}${c.reset} removed from the private list`);
+  }
+}
+
+function doPrivacy() {
+  const cwd = process.cwd();
+  const cfg = loadConfig();
+  const { visibility, projectName, reason } = resolveVisibility(cwd, cfg);
+  const color = visibility === 'hidden' ? c.red : visibility === 'name-only' ? c.yellow : c.green;
+  console.log('');
+  console.log(`  ${c.bold}privacy${c.reset}  ${c.dim}for${c.reset} ${c.cyan}${cwd}${c.reset}`);
+  console.log(`    ${c.dim}visibility:${c.reset} ${color}${visibility}${c.reset}   ${c.dim}(${reason})${c.reset}`);
+  if (projectName) console.log(`    ${c.dim}alias:    ${c.reset} ${projectName}`);
+  const list = listPrivateCwds();
+  if (list.length) {
+    console.log('');
+    console.log(`  ${c.bold}private-list${c.reset}  ${c.dim}(${list.length} ${list.length === 1 ? 'path' : 'paths'})${c.reset}`);
+    for (const p of list) console.log(`    ${p === cwd ? c.cyan + '●' + c.reset : ' '} ${p}`);
+  }
+  console.log('');
+  console.log(`  ${c.dim}toggle:   claude-rpc private  /  claude-rpc public${c.reset}`);
+  console.log(`  ${c.dim}per-proj: drop a {"private": true} into .claude-rpc.json at the repo root${c.reset}`);
+  console.log('');
+}
+
 function tailLog() {
   if (!existsSync(LOG_PATH)) {
     console.log(`${c.yellow}No log yet at ${LOG_PATH}${c.reset}`);
@@ -641,14 +766,85 @@ function tailLog() {
         // file rotated
         lastSize = buf.length;
       }
-    } catch {}
+    } catch { /* read race vs rotation — next watchFile tick recovers */ }
   });
 }
 
+// One-screen "where am I?" view. Goal: a user typing `claude-rpc` with no
+// args sees in <24 lines what's happening and the four most useful next
+// commands. Full command list lives behind --help.
+function overview() {
+  const setUp = hasUserConfig();
+  const cfg = loadConfig();
+  const pid = daemonPid();
+
+  console.log('');
+  console.log(`  ${c.bold}${c.magenta}◆ claude-rpc${c.reset}  ${c.dim}v${VERSION} — Discord Rich Presence for Claude Code${c.reset}`);
+  console.log('');
+
+  if (!setUp) {
+    console.log(`  ${c.yellow}○${c.reset} not configured yet`);
+    console.log('');
+    console.log(`  Run ${c.cyan}claude-rpc setup${c.reset} to get started.`);
+    console.log('');
+    console.log(`  ${c.dim}--help for the full command list${c.reset}`);
+    console.log('');
+    return;
+  }
+
+  // Status line: daemon up/down + project + model + status verb.
+  const state = readState();
+  const aggregate = readAggregate();
+  state.liveSessions = findLiveSessions({ thresholdMs: 90_000 });
+  const vars = buildVars(state, cfg, aggregate);
+  const dot = pid
+    ? `${c.green}●${c.reset} running ${c.dim}pid ${pid}${c.reset}`
+    : `${c.yellow}○${c.reset} ${c.dim}daemon not running${c.reset}`;
+  if (pid) {
+    console.log(`  ${dot}  ${c.gray}·${c.reset}  ${c.bold}${vars.modelPretty}${c.reset} in ${c.bold}${vars.project}${c.reset}  ${c.gray}·${c.reset}  ${statusColor(vars.status)}${vars.statusVerbose}${c.reset}`);
+  } else {
+    console.log(`  ${dot}`);
+  }
+
+  if (aggregate) {
+    console.log('');
+    console.log(`  ${c.dim}today  ${c.reset}${c.green}${vars.todayHours.padEnd(6)}${c.reset}${c.dim}active  ·  ${vars.todayPromptsLabel}  ·  ${vars.todayCostFmt}${c.reset}`);
+    console.log(`  ${c.dim}streak ${c.reset}${c.magenta}${String(vars.streak).padEnd(6)}${c.reset}${c.dim}${vars.streak === 1 ? 'day' : 'days'}  ·  longest ${vars.longestStreak}  ·  ${vars.allHours} all-time${c.reset}`);
+  } else {
+    console.log('');
+    console.log(`  ${c.dim}no stats yet — run ${c.reset}${c.cyan}claude-rpc scan${c.reset}${c.dim} to build aggregates${c.reset}`);
+  }
+
+  // Four most useful next commands. Doctor leads — it's the answer to
+  // "something looks wrong" without the user having to read anything.
+  console.log('');
+  const next = pid
+    ? [['status', 'full dashboard with heatmap'],
+       ['doctor', 'diagnose problems'],
+       ['serve',  'open the web dashboard'],
+       ['stop',   'stop the daemon']]
+    : (cfg.clientId && cfg.clientId !== '1234567890123456789')
+      ? [['start',  'launch the daemon'],
+         ['doctor', 'diagnose problems'],
+         ['status', 'show current stats'],
+         ['setup',  'register Claude Code hooks']]
+      : [['setup',  'install hooks and seed config'],
+         ['doctor', 'diagnose problems'],
+         ['start',  'launch the daemon'],
+         ['status', 'show current stats']];
+  for (const [name, desc] of next) {
+    console.log(`  ${c.cyan}${name.padEnd(8)}${c.reset}  ${c.dim}→${c.reset}  ${desc}`);
+  }
+  console.log('');
+  console.log(`  ${c.dim}--help for the full command list  ·  --version${c.reset}`);
+  console.log('');
+}
+
 function help() {
   const cmds = [
     ['setup',     'Install Claude Code hooks (~/.claude/settings.json)'],
     ['uninstall', 'Remove Claude Code hooks'],
+    ['upgrade-config', 'Re-run idempotent migrations on an existing config.json'],
     ['start',     'Start the Discord RPC daemon (detached)'],
     ['stop',      'Stop the daemon'],
     ['restart',   'Stop then start the daemon'],
@@ -659,8 +855,14 @@ function help() {
     ['preview',   'Show how each rotation frame renders right now'],
     ['scan',      'Incrementally scan ~/.claude/projects for all-time totals'],
     ['rescan',    'Force re-parse every transcript (ignores cache)'],
+    ['backfill',  'Import transcripts from any folder (e.g. a backup)'],
     ['insights',  'Auto-generated insights from your history'],
     ['badge',     'Render a Shields-style SVG (--metric --range --out)'],
+    ['card',      'Render a poster-style SVG summary (--range year|month|week|all)'],
+    ['private',   'Mark the current directory as private (hide from Discord)'],
+    ['public',    'Un-mark the current directory'],
+    ['privacy',   'Show resolved visibility for the current directory'],
+    ['doctor',    'Run a diagnostic checklist — common-failure triage'],
     ['tail',      'Tail the daemon log file'],
     ['daemon',    'Run daemon in foreground (debug)'],
   ];
@@ -679,6 +881,8 @@ function help() {
   console.log('');
   console.log(`  ${c.dim}Tip: ${c.reset}edit ${c.cyan}config.json${c.reset} to customize rotation frames. Run ${c.cyan}claude-rpc preview${c.reset} to see the result without Discord.`);
   console.log('');
+  console.log(`  ${c.dim}Exit codes:${c.reset} ${c.dim}0 ok · 1 user error · 2 system error · 3 wrong state${c.reset}`);
+  console.log('');
 }
 
 // Packaged exe: `claude-rpc.exe` with no args → first-run install + start.
@@ -691,9 +895,16 @@ const packagedDefault = IS_PACKAGED && !cmd;
 // top-level await.
 (async () => {
   switch (cmd) {
+    case '--version':
+    case '-V':
+    case '-v':        console.log(`claude-rpc ${VERSION}`); break;
+    case '--help':
+    case '-h':
+    case 'help':      help(); break;
     case 'setup':     await runInstall({ exePath: EXE_PATH || process.execPath, withStartup: false }); break;
     case 'install':   await runInstall({ exePath: EXE_PATH || process.execPath }); break;
     case 'uninstall': await runUninstall(); break;
+    case 'upgrade-config': migrateConfig(); break;
     case 'start':     startDaemon(); break;
     case 'stop':      stopDaemon(); break;
     case 'restart':   restartDaemon(); break;
@@ -706,13 +917,23 @@ const packagedDefault = IS_PACKAGED && !cmd;
     case 'dump':      showStatus(); break;
     case 'today':     showToday(); break;
     case 'week':      showWeek(); break;
-    case 'serve':     await import('./server.js'); break;
+    case 'serve':     await import('./server/index.js'); break;
     case 'preview':   showPreview(); break;
     case 'vars':      dumpVars(); break;
     case 'scan':      doScan(false); break;
     case 'rescan':    doScan(true); break;
+    case 'backfill':  doBackfill(process.argv.slice(3)); break;
     case 'insights':  showInsights(); break;
     case 'badge':     doBadge(process.argv.slice(3)); break;
+    case 'card':      await doCard(process.argv.slice(3)); break;
+    case 'private':   doPrivate(); break;
+    case 'public':    doPublic(); break;
+    case 'privacy':   doPrivacy(); break;
+    case 'doctor': {
+      const { runDoctor } = await import('./doctor.js');
+      process.exit(runDoctor());
+      break;
+    }
     case 'tail':
     case 'logs':
     case 'log':       tailLog(); break;
@@ -749,7 +970,7 @@ const packagedDefault = IS_PACKAGED && !cmd;
             console.warn(`refresh skipped: ${e.message}`);
           }
           const wasRunning = stopDaemon({ quiet: true });
-          try { if (existsSync(STATE_PATH)) unlinkSync(STATE_PATH); } catch {}
+          try { if (existsSync(STATE_PATH)) unlinkSync(STATE_PATH); } catch { /* state.json locked or already gone — next hook will recreate it */ }
           if (wasRunning) {
             // Brief wait for the OS to release the pid file before we spawn.
             setTimeout(() => startDaemon(), 700);
@@ -757,8 +978,14 @@ const packagedDefault = IS_PACKAGED && !cmd;
             startDaemon();
           }
         }
+      } else if (!cmd) {
+        // True no-args invocation in dev/npm mode → one-screen overview.
+        // The packagedDefault branch above handles the SEA exe's "double-
+        // click with no args" install-and-start flow.
+        overview();
       } else {
-        help();
+        fail(`unknown command: ${cmd}`,
+          { hint: 'run `claude-rpc --help` for the full list', code: EX_USER_ERROR });
       }
     }
   }

package/src/config.js

@@ -0,0 +1,89 @@
+// Config loader. One place that knows how to:
+//
+//   1. Read the user's config.json from disk.
+//   2. Deep-merge it over DEFAULT_CONFIG so the user file only needs to
+//      hold *overrides* (a fresh user file is two lines: clientId and
+//      maybe appName).
+//   3. Survive bad JSON / missing files / wrong types without crashing.
+//      Bad input logs a one-line warning and falls back to defaults.
+//      Critical for the daemon — an Electron-GUI mid-edit save used to
+//      hard-exit it via daemon.js's `process.exit(1)`. No more.
+//
+// Merge rule: plain objects deep-merge, arrays REPLACE. Arrays-as-deep-
+// merge is rarely what anyone wants (a user rotation array becomes a
+// spliced franken-array of theirs + defaults). Replacing matches what
+// you'd expect from "I set this, it's mine."
+//
+// All callers (daemon, server/api, tui, cli) should go through
+// `loadConfig()` rather than reading CONFIG_PATH directly.
+
+import { readFileSync, existsSync } from 'node:fs';
+import { CONFIG_PATH } from './paths.js';
+import { DEFAULT_CONFIG } from './default-config.js';
+
+// "Has the user run setup?" — a separate signal from `loadConfig` because
+// loadConfig now always returns merged defaults (the daemon needs them
+// even if the file isn't there yet). Callers that want to distinguish
+// "never been set up" from "everything default" check this instead.
+export function hasUserConfig(path = CONFIG_PATH) {
+  return existsSync(path);
+}
+
+function isPlainObject(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+// Deep-merge `over` onto `base`. Plain objects merge recursively; arrays
+// and primitives from `over` replace whatever was in `base`. Returns a
+// fresh object — neither input is mutated. Used for layering user config
+// over DEFAULT_CONFIG and (later) per-project overrides over user config.
+export function mergeConfig(base, over) {
+  if (over === undefined || over === null) return structuredClone(base);
+  if (!isPlainObject(base) || !isPlainObject(over)) return structuredClone(over);
+  const out = {};
+  const keys = new Set([...Object.keys(base), ...Object.keys(over)]);
+  for (const k of keys) {
+    const a = base[k];
+    const b = over[k];
+    if (b === undefined) {
+      out[k] = structuredClone(a);
+    } else if (isPlainObject(a) && isPlainObject(b)) {
+      out[k] = mergeConfig(a, b);
+    } else {
+      out[k] = structuredClone(b);
+    }
+  }
+  return out;
+}
+
+// Read + merge. `onError(message)` is called when the user config can't
+// be parsed — caller decides whether to log to stdout, daemon.log, or
+// nothing. Returning the merged-defaults object is the contract: never
+// throw, never exit. Worst case we render with shipped defaults.
+//
+// path defaults to CONFIG_PATH so all daemon-like callers can drop the
+// `readFileSync(CONFIG_PATH, ...)` boilerplate.
+export function loadConfig({ path = CONFIG_PATH, onError } = {}) {
+  if (!existsSync(path)) {
+    return mergeConfig(DEFAULT_CONFIG, {});
+  }
+  let raw;
+  try {
+    raw = readFileSync(path, 'utf8');
+  } catch (e) {
+    if (onError) onError(`config read failed at ${path}: ${e.message} — falling back to defaults`);
+    return mergeConfig(DEFAULT_CONFIG, {});
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    if (onError) onError(`config parse failed at ${path}: ${e.message} — falling back to defaults`);
+    return mergeConfig(DEFAULT_CONFIG, {});
+  }
+  if (!isPlainObject(parsed)) {
+    if (onError) onError(`config at ${path} is not an object — falling back to defaults`);
+    return mergeConfig(DEFAULT_CONFIG, {});
+  }
+  return mergeConfig(DEFAULT_CONFIG, parsed);
+}