claude-rpc 0.5.0 → 0.6.0

package/src/install.js

@@ -8,7 +8,7 @@ import {
   readdirSync, unlinkSync,
 } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import {
   CLAUDE_SETTINGS, CONFIG_PATH, USER_CONFIG_DIR, ROOT,
   HOOK_SCRIPT, IS_PACKAGED, IS_NPM_INSTALL,
@@ -135,10 +135,10 @@ function sweepStaleCanonicalBackups() {
     const prefix = CANONICAL_EXE_NAME + '.old-';
     for (const name of readdirSync(CANONICAL_INSTALL_DIR)) {
       if (name.startsWith(prefix)) {
-        try { unlinkSync(join(CANONICAL_INSTALL_DIR, name)); } catch {}
+        try { unlinkSync(join(CANONICAL_INSTALL_DIR, name)); } catch { /* file locked or vanished — sweep is best-effort */ }
       }
     }
-  } catch {}
+  } catch { /* install dir unreadable — nothing to sweep */ }
 }
 
 // Copy the running binary into CANONICAL_EXE if it's not already there.
@@ -160,7 +160,7 @@ export function ensureCanonicalExe(currentExe) {
         console.log(`  exe already installed → ${CANONICAL_EXE}`);
         return CANONICAL_EXE;
       }
-    } catch {}
+    } catch { /* stat failed — fall through to copy attempt */ }
   }
 
   try {
@@ -170,7 +170,7 @@ export function ensureCanonicalExe(currentExe) {
     // renamed copy when the process exits.
     if (process.platform === 'win32' && existsSync(CANONICAL_EXE)) {
       try { renameSync(CANONICAL_EXE, CANONICAL_EXE + '.old-' + Date.now()); }
-      catch {}
+      catch { /* not running, no rename needed — copyFileSync below will just overwrite */ }
     }
     copyFileSync(currentExe, CANONICAL_EXE);
     if (process.platform !== 'win32') chmodSync(CANONICAL_EXE, 0o755);
@@ -270,6 +270,39 @@ export function migrateConfig() {
   return true;
 }
 
+// Round-trip a synthetic SessionStart event through the same launcher
+// shape that Claude Code itself will use. Proves the hook command actually
+// resolves and runs — without this, `setup` could happily wire a broken
+// command and report success, leaving the user to discover the breakage
+// the next time they open Claude Code. Returns { ok, detail }.
+function verifyHookPipe(exePath) {
+  const cmd  = IS_PACKAGED ? exePath
+              : IS_NPM_INSTALL ? 'claude-rpc'
+              : process.execPath;
+  const args = IS_PACKAGED || IS_NPM_INSTALL
+              ? ['hook', 'SessionStart']
+              : [HOOK_SCRIPT, 'SessionStart'];
+  let result;
+  try {
+    result = spawnSync(cmd, args, {
+      input: '',
+      encoding: 'utf8',
+      timeout: 3000,
+      windowsHide: true,
+    });
+  } catch (e) {
+    return { ok: false, detail: `spawn failed: ${e.message}` };
+  }
+  if (result.error) return { ok: false, detail: `spawn error: ${result.error.message}` };
+  if (result.status !== 0) {
+    return { ok: false, detail: `hook exit ${result.status}: ${(result.stderr || '').trim().slice(0, 120)}` };
+  }
+  if (!result.stdout.includes('"continue"')) {
+    return { ok: false, detail: `unexpected hook output: ${result.stdout.trim().slice(0, 120)}` };
+  }
+  return { ok: true, detail: 'SessionStart round-trip succeeded' };
+}
+
 export async function install({ exePath, withStartup = true } = {}) {
   if (process.platform !== 'win32' && withStartup) {
     console.warn('Note: startup registration only works on Windows; other steps still run.');
@@ -288,6 +321,18 @@ export async function install({ exePath, withStartup = true } = {}) {
     try { await addStartupEntry(target); }
     catch (e) { console.warn(`  startup entry failed: ${e.message}`); }
   }
+
+  // Proof the hook pipe actually fires. A setup that returns success
+  // without verification is a lie — we caught broken-hook-path bugs
+  // twice during v0.3.x because no one ran a real event after install.
+  const probe = verifyHookPipe(target);
+  if (probe.ok) {
+    console.log(`  hook pipe   ✓ ${probe.detail}`);
+  } else {
+    console.warn(`  hook pipe   ✗ ${probe.detail}`);
+    console.warn(`              ↳ run \`claude-rpc doctor\` for a full diagnostic`);
+  }
+
   console.log('\nDone.');
   console.log(`Edit ${CONFIG_PATH} to set your Discord clientId, then run:`);
   // Per-mode "start" instructions — packaged exe takes a daemon subcommand,
@@ -301,6 +346,7 @@ export async function install({ exePath, withStartup = true } = {}) {
     console.log(`  node "${join(ROOT, 'src', 'daemon.js').replace(/\\/g, '/')}"`);
     console.log(`  # or: claude-rpc start  (if you've run \`npm link\`)`);
   }
+  console.log(`\nThen: \`claude-rpc doctor\` to verify everything is wired.`);
 }
 
 export async function uninstall() {

package/src/pricing.js

@@ -29,16 +29,39 @@ const PRICING = {
 
 const DEFAULT = PRICING.sonnet;
 
+const TIERS = new Set(['opus', 'sonnet', 'haiku']);
+
 // Map a model id like "claude-opus-4-7-20251101" to a pricing key.
+//
+// The old implementation did `s.includes(key)` against the PRICING keys
+// sorted by descending length, which silently mis-routed any future model
+// id whose name contained one of those substrings out of order
+// (e.g. `claude-sonneteer-x` matching `sonnet`). Now: split the id on `-`,
+// find the first explicit tier token, then read the version digits that
+// follow. Falls back from `tier-major-minor` → `tier-major` → tier generic
+// → sonnet, in that order.
 export function pricingKeyFor(modelId) {
   if (!modelId) return 'sonnet';
-  const s = String(modelId).toLowerCase();
-  // Most specific match wins.
-  const candidates = Object.keys(PRICING).sort((a, b) => b.length - a.length);
-  for (const key of candidates) {
-    if (s.includes(key)) return key;
+  const parts = String(modelId).toLowerCase().split('-');
+
+  let tier = null;
+  let tierIdx = -1;
+  for (let i = 0; i < parts.length; i++) {
+    if (TIERS.has(parts[i])) { tier = parts[i]; tierIdx = i; break; }
+  }
+  if (!tier) return 'sonnet'; // unknown family — sonnet-class fallback
+
+  const major = parts[tierIdx + 1];
+  const minor = parts[tierIdx + 2];
+  if (major && /^\d+$/.test(major)) {
+    if (minor && /^\d+$/.test(minor)) {
+      const k = `${tier}-${major}-${minor}`;
+      if (PRICING[k]) return k;
+    }
+    const km = `${tier}-${major}`;
+    if (PRICING[km]) return km;
   }
-  return 'sonnet';
+  return tier; // generic tier rates
 }
 
 export function ratesFor(modelId) {

package/src/privacy.js

@@ -83,7 +83,7 @@ function readPrivateList() {
   try {
     const v = JSON.parse(readFileSync(PRIVATE_LIST_PATH, 'utf8'));
     if (Array.isArray(v?.paths)) return v;
-  } catch {}
+  } catch { /* broken JSON ≡ no list (treat as empty rather than crash) */ }
   return { paths: [] };
 }
 

package/src/scanner.js

@@ -358,7 +358,7 @@ function readTranscriptCwd(path, mtimeMs) {
       const r = safeJson(line);
       if (r?.cwd) { cwd = r.cwd; break; }
     }
-  } catch {}
+  } catch { /* transcript head unreadable — cwd stays null, project name falls back to slug */ }
   cwdCache.set(path, { mtime: mtimeMs, cwd });
   return cwd;
 }
@@ -464,7 +464,7 @@ function readNotificationsByDay() {
       const k = dayKey(e.ts);
       out[k] = (out[k] || 0) + 1;
     }
-  } catch {}
+  } catch { /* events log unreadable/truncated — return whatever we got, the aggregate will just under-count notifications */ }
   return out;
 }
 

package/src/server/api.js

@@ -2,15 +2,18 @@
 // over the aggregate + state files; no HTTP concerns. Tested separately
 // from the routing layer.
 
-import { readFileSync } from 'node:fs';
 import { basename } from 'node:path';
 import { readState } from '../state.js';
 import { buildVars, fillTemplate, applyIdle, framePasses } from '../format.js';
 import { readAggregate, findLiveSessions, dayKey } from '../scanner.js';
-import { CONFIG_PATH } from '../paths.js';
+import { loadConfig as loadSharedConfig } from '../config.js';
 
+// Re-export under the historical name so any external callers (e.g. tests
+// that did `import { loadConfig } from '../api.js'`) still resolve.
+// Internally everything uses the shared loader so a bad config doesn't
+// blank out the dashboard with `{}` — it falls back to defaults.
 export function loadConfig() {
-  try { return JSON.parse(readFileSync(CONFIG_PATH, 'utf8')); } catch { return {}; }
+  return loadSharedConfig();
 }
 
 export function rangeToDays(range) {

package/src/server/page.js

@@ -1,17 +1,22 @@
 // All browser-side assets for the local web dashboard, packaged as JS
-// string constants so the bundler picks them up cleanly. Three blocks:
+// string constants so the bundler picks them up cleanly. Single export
+// is `buildHtml({ port })`.
 //
-//   CSS                     — full stylesheet, dark + light themes
-//   LANG_PALETTE            — per-language color JSON consumed by the
-//                             client-side language stack chart
-//   HTML                    — the full HTML scaffold, interpolating
-//                             both of the above plus the browser-side
-//                             JS produced by HTML_SCRIPT_PLACEHOLDER()
-//   HTML_SCRIPT_PLACEHOLDER — the client-side runtime (SSE wiring,
-//                             range selector, drilldowns, theme toggle,
-//                             charts, keyboard shortcuts)
+// ┌─ TABLE OF CONTENTS ─────────────────────────────────────┐
+// │  §1  CSS                — stylesheet (light + dark)     │ ~line 26
+// │  §2  LANG_PALETTE       — language → swatch hex         │ ~line 400
+// │  §3  buildHtml          — HTML scaffold + interpolation │ ~line 420
+// │  §4  HTML_SCRIPT_BODY   — client runtime (SSE, charts,  │ ~line 700
+// │                            range selector, drilldowns,  │
+// │                            theme toggle, keyboard)      │
+// └─────────────────────────────────────────────────────────┘
 //
-// Only HTML is exported. Edit the three blocks below in isolation.
+// Each section is just a string constant — no runtime dependencies
+// between them. Edit one without re-reading the others.
+
+// ─────────────────────────────────────────────────────────────────────
+// §1  CSS
+// ─────────────────────────────────────────────────────────────────────
 
 const CSS = `
 :root {
@@ -389,7 +394,13 @@ footer a:hover { color: var(--text-2); }
 }
 `;
 
-// Color palette for languages, by name. Stable across renders.
+// ─────────────────────────────────────────────────────────────────────
+// §2  LANG_PALETTE — language → swatch hex
+// ─────────────────────────────────────────────────────────────────────
+//
+// Stable across renders. Embedded as a JS object literal inside the
+// client script template; the client parses it once at startup.
+
 const LANG_PALETTE = `{
   'JavaScript': '#f7df1e', 'TypeScript': '#3178c6', 'Python': '#3776ab', 'Rust': '#dea584',
   'Go': '#00add8', 'Ruby': '#cc342d', 'Java': '#b07219', 'Kotlin': '#a97bff',
@@ -410,6 +421,14 @@ const LANG_PALETTE = `{
   'Config': '#888', 'Git': '#f1502f',
 }`;
 
+// ─────────────────────────────────────────────────────────────────────
+// §3  buildHtml — HTML scaffold + interpolation
+// ─────────────────────────────────────────────────────────────────────
+//
+// Returns the full HTML string. The only dynamic value is the port,
+// which is fixed at server startup, so this is composed once and reused
+// for every request (see src/server/index.js).
+
 function buildHtml({ port }) {
   const PORT = port;
   return String.raw`<!doctype html>
@@ -686,6 +705,25 @@ ${HTML_SCRIPT_PLACEHOLDER()}
 </html>`;
 }
 
+// ─────────────────────────────────────────────────────────────────────
+// §4  HTML_SCRIPT_BODY — client runtime
+// ─────────────────────────────────────────────────────────────────────
+//
+// Returned as a string and inlined into the HTML at the bottom of the
+// document. Vanilla browser JS — no bundler, no framework, no npm. The
+// IIFE keeps all locals out of window.
+//
+// Sub-structure within the IIFE:
+//   • $              — DOM accessor
+//   • LANGS          — parsed language palette
+//   • Utilities      — fmtH / fmtN / fmtCost / escape / etc.
+//   • State buckets  — liveData / aggData / allFrames / rotationTimer
+//   • Range pills    — active selector + delta vs previous range
+//   • Charts         — area chart, sparkline, heatmap, lang stack
+//   • Drilldowns     — project drawer + day-detail modal
+//   • SSE wiring     — EventSource('/events') → refresh handlers
+//   • Keyboard       — 1..5 range, t theme, esc close, ? help
+
 function HTML_SCRIPT_PLACEHOLDER() {
   return `(() => {
   const $ = (id) => document.getElementById(id);
@@ -1239,10 +1277,10 @@ function HTML_SCRIPT_PLACEHOLDER() {
             await fetchAggregate();
             await fetchInsights();
           }
-        } catch {}
+        } catch { /* malformed SSE frame — wait for the next one */ }
       };
       ev.onerror = () => { $('conn-state').textContent = 'reconnecting'; setTimeout(() => { $('conn-state').textContent = 'live'; }, 4000); };
-    } catch {}
+    } catch { /* EventSource constructor failed (very old browser) — dashboard falls back to one-shot fetches */ }
   }
 
   async function refreshState() {

package/src/server/sse.js

@@ -22,11 +22,11 @@ export function watchSources() {
       clearTimeout(stTimer);
       stTimer = setTimeout(() => broadcast({ type: 'state' }), 200);
     });
-  } catch {}
+  } catch { /* state file not on disk yet — dashboard still works, just no SSE state events until daemon writes one */ }
   try {
     watch(AGGREGATE_PATH, () => {
       clearTimeout(agTimer);
       agTimer = setTimeout(() => broadcast({ type: 'aggregate' }), 200);
     });
-  } catch {}
+  } catch { /* aggregate not on disk yet — dashboard renders empty stats until first scan completes */ }
 }

package/src/tui.js

@@ -9,7 +9,8 @@ import { readFileSync, existsSync } from 'node:fs';
 import { readState } from './state.js';
 import { readAggregate, findLiveSessions, dayKey, weekKey } from './scanner.js';
 import { buildVars, applyIdle, humanProject } from './format.js';
-import { CONFIG_PATH, PID_PATH } from './paths.js';
+import { loadConfig } from './config.js';
+import { PID_PATH } from './paths.js';
 import { fmtCost } from './pricing.js';
 import { generateInsights } from './insights.js';
 
@@ -52,9 +53,7 @@ let exiting = false;
 function loadSnapshot() {
   let state = readState();
   state.liveSessions = findLiveSessions({ thresholdMs: 90_000 });
-  const config = existsSync(CONFIG_PATH)
-    ? (() => { try { return JSON.parse(readFileSync(CONFIG_PATH, 'utf8')); } catch { return {}; } })()
-    : {};
+  const config = loadConfig();
   state = applyIdle(state, config);
   const aggregate = readAggregate() || {};
   const vars = buildVars(state, config, aggregate);
@@ -371,7 +370,7 @@ function cleanup() {
   if (exiting) return;
   exiting = true;
   if (refreshTimer) clearInterval(refreshTimer);
-  try { process.stdin.setRawMode(false); } catch {}
+  try { process.stdin.setRawMode(false); } catch { /* not a tty (CI, pipe) — no-op */ }
   process.stdin.pause();
   process.stdout.write(SHOW_CURSOR + CLEAR + '\n');
   process.exit(0);
@@ -402,7 +401,7 @@ export function startTui() {
   }
   process.stdout.write(HIDE_CURSOR);
 
-  try { process.stdin.setRawMode(true); } catch {}
+  try { process.stdin.setRawMode(true); } catch { /* not a tty — TUI will print once and exit */ }
   process.stdin.resume();
   process.stdin.on('data', handleKey);
 
@@ -410,7 +409,7 @@ export function startTui() {
   process.on('SIGTERM', cleanup);
   process.on('SIGHUP', cleanup);
   process.on('exit', () => {
-    try { process.stdin.setRawMode(false); } catch {}
+    try { process.stdin.setRawMode(false); } catch { /* not a tty (CI, pipe) — no-op */ }
     process.stdout.write(SHOW_CURSOR);
   });
   process.stdout.on('resize', () => render());

package/src/ui.js

@@ -0,0 +1,89 @@
+// Shared CLI output primitives.
+//
+// Three duplicates of the same ANSI table + symbol set existed in cli.js,
+// doctor.js, and tui.js. This is the one place; everything else imports.
+//
+// All output goes to stdout/stderr via console.log/console.error. The
+// daemon's file-bound `log()` is a separate concern (no tty, no color)
+// and stays in src/daemon.js — these helpers are for human-facing
+// surfaces only.
+//
+// Standard exit codes (also documented in --help):
+//   0  success
+//   1  user error  — bad args, unknown command, malformed input
+//   2  system error — IO failed, Discord unreachable, etc.
+//   3  wrong state — daemon already running, no aggregate yet, etc.
+
+import process from 'node:process';
+
+const TTY = process.stdout.isTTY && !process.env.NO_COLOR;
+
+export const c = {
+  reset:   TTY ? '\x1b[0m'  : '',
+  dim:     TTY ? '\x1b[2m'  : '',
+  bold:    TTY ? '\x1b[1m'  : '',
+  red:     TTY ? '\x1b[31m' : '',
+  green:   TTY ? '\x1b[32m' : '',
+  yellow:  TTY ? '\x1b[33m' : '',
+  blue:    TTY ? '\x1b[34m' : '',
+  magenta: TTY ? '\x1b[35m' : '',
+  cyan:    TTY ? '\x1b[36m' : '',
+  gray:    TTY ? '\x1b[90m' : '',
+};
+
+export const SYM_OK   = TTY ? `${c.green}✓${c.reset}`  : '[ok]  ';
+export const SYM_FAIL = TTY ? `${c.red}✗${c.reset}`    : '[fail]';
+export const SYM_WARN = TTY ? `${c.yellow}!${c.reset}` : '[warn]';
+export const SYM_INFO = TTY ? `${c.cyan}·${c.reset}`   : '[info]';
+
+// Standard exit-code values. Use these instead of process.exit(1) so
+// intent is visible in the source.
+export const EX_OK         = 0;
+export const EX_USER_ERROR = 1;
+export const EX_SYS_ERROR  = 2;
+export const EX_BAD_STATE  = 3;
+
+// Print a one-line message plus an indented dim hint on the next line.
+// Hint is the tired-user safety net: every failure surface tells you
+// what to type next. Empty hint omits the second line.
+function withHint(sym, label, hint, stream = process.stdout) {
+  stream.write(`  ${sym}  ${label}\n`);
+  if (hint) stream.write(`        ${c.gray}↳ ${hint}${c.reset}\n`);
+}
+
+export function ok(label, detail = '') {
+  process.stdout.write(`  ${SYM_OK}  ${label}${detail ? `  ${c.dim}${detail}${c.reset}` : ''}\n`);
+}
+
+export function info(label, detail = '') {
+  process.stdout.write(`  ${SYM_INFO}  ${label}${detail ? `  ${c.dim}${detail}${c.reset}` : ''}\n`);
+}
+
+export function warn(label, hint = '') {
+  withHint(SYM_WARN, label, hint);
+}
+
+// Print a failure with a hint and exit with the given code. The hint is
+// the difference between a frustrated user and a fixed user — always
+// supply one when you can, and default it to `claude-rpc doctor` when
+// you have no better idea.
+export function fail(label, { hint = 'run `claude-rpc doctor` for a full diagnostic', code = EX_USER_ERROR } = {}) {
+  withHint(SYM_FAIL, label, hint, process.stderr);
+  process.exit(code);
+}
+
+// Compatibility with doctor.js's existing API. Same `check(label, status,
+// detail, hint)` signature; doctor.js can switch its private copy out for
+// this without behavior change.
+export function check(label, status, detail = '', hint = '') {
+  let sym;
+  if (status === 'pass')      sym = SYM_OK;
+  else if (status === 'fail') sym = SYM_FAIL;
+  else if (status === 'warn') sym = SYM_WARN;
+  else                        sym = SYM_INFO;
+  const tail = detail ? `  ${c.dim}${detail}${c.reset}` : '';
+  process.stdout.write(`  ${sym}  ${label}${tail}\n`);
+  if (hint && status !== 'pass') {
+    process.stdout.write(`        ${c.gray}↳ ${hint}${c.reset}\n`);
+  }
+}

package/src/version.js

@@ -0,0 +1,26 @@
+// Single source of truth for the user-visible version string.
+//
+// Read from package.json at module load (works in dev + npm-installed
+// modes). For packaged SEA exes, package.json isn't shipped — `npm run
+// build:exe` snapshots whatever package.json holds at build time and
+// the BAKED fallback below catches the SEA-only "package.json missing"
+// case. Bump BAKED when cutting a release; the test in
+// test/version.test.js asserts the two stay in sync.
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ROOT } from './paths.js';
+
+const BAKED = '0.6.0';
+
+function readPkgVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf8'));
+    if (pkg && typeof pkg.version === 'string') return pkg.version;
+  } catch {
+    // package.json not on disk (SEA exe) or unreadable — fall back to BAKED.
+  }
+  return BAKED;
+}
+
+export const VERSION = readPkgVersion();