claude-rpc 0.3.8 → 0.3.11

package/package.json

@@ -1,10 +1,18 @@
 {
   "name": "claude-rpc",
-  "version": "0.3.8",
+  "version": "0.3.11",
   "description": "Discord Rich Presence for Claude Code — live model, project, tokens, and lifetime stats driven by Claude Code's hook system.",
   "type": "module",
   "license": "MIT",
   "author": "Archer Simmons",
+  "homepage": "https://github.com/rar-file/claude-rpc#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rar-file/claude-rpc.git"
+  },
+  "bugs": {
+    "url": "https://github.com/rar-file/claude-rpc/issues"
+  },
   "bin": {
     "claude-rpc": "./bin/claude-rpc.js"
   },

package/src/daemon.js

@@ -3,7 +3,7 @@ import { readFileSync, writeFileSync, existsSync, unlinkSync, watch, appendFileS
 import { Client } from '@xhayper/discord-rpc';
 import { readState } from './state.js';
 import { buildVars, fillTemplate, framePasses, applyIdle } from './format.js';
-import { scan, readAggregate, findLiveSessions } from './scanner.js';
+import { scan, readAggregate, findLiveSessions, readSessionTokens } from './scanner.js';
 import { detectGithubUrl } from './git.js';
 import { CONFIG_PATH, STATE_PATH, PID_PATH, LOG_PATH, STATE_DIR, AGGREGATE_PATH } from './paths.js';
 
@@ -82,6 +82,23 @@ function buildActivity(opts = {}) {
   // see ongoing transcript activity, not just this daemon's hook state.
   state.liveSessions = opts.liveSessions || liveSessions;
   state = applyIdle(state, config);
+
+  // Pull live session tokens from the transcript file. Claude Code's hook
+  // payloads don't include usage data, so state.tokens from PostToolUse
+  // events is always {0,0,0,0}. The transcript is the only running source
+  // of truth — readSessionTokens is mtime-cached, so this is cheap unless
+  // the session is actively writing.
+  if (state.cwd && state.status !== 'stale') {
+    const cwdLower = state.cwd.toLowerCase();
+    const match = (state.liveSessions || []).find(s =>
+      (s.cwd || '').toLowerCase() === cwdLower
+    );
+    if (match) {
+      const t = readSessionTokens(match.path);
+      if (t) state.tokens = t;
+    }
+  }
+
   const vars = buildVars(state, config, opts.aggregate || aggregate);
   const p = config.presence || {};
 

package/src/install.js

@@ -10,8 +10,8 @@ import {
 import { dirname, join, resolve } from 'node:path';
 import { spawn } from 'node:child_process';
 import {
-  CLAUDE_SETTINGS, CONFIG_PATH, USER_CONFIG_DIR,
-  HOOK_SCRIPT, IS_PACKAGED,
+  CLAUDE_SETTINGS, CONFIG_PATH, USER_CONFIG_DIR, ROOT,
+  HOOK_SCRIPT, IS_PACKAGED, IS_NPM_INSTALL,
   CANONICAL_EXE, CANONICAL_INSTALL_DIR, CANONICAL_EXE_NAME,
 } from './paths.js';
 import { DEFAULT_CONFIG } from './default-config.js';
@@ -42,10 +42,16 @@ function isOurHookCommand(cmd) {
 export function installHooks(exePath) {
   const settings = readJson(CLAUDE_SETTINGS, {});
   settings.hooks = settings.hooks || {};
-  // Packaged: `"<exe>" hook <event>`. Dev: `node "<src/hook.js>" <event>`.
+  // Three modes, three shapes:
+  //   packaged → `"<exe>" hook <event>`         (canonical exe, no node)
+  //   npm     → `claude-rpc hook <event>`       (bin shim resolves through PATH;
+  //              survives `npm update` and nvm version switches)
+  //   dev     → `node "<src/hook.js>" <event>`  (cloned-source iteration)
   const cmdFor = IS_PACKAGED
     ? (event) => `"${exePath}" hook ${event}`
-    : (event) => `node "${HOOK_SCRIPT.replace(/\\/g, '/')}" ${event}`;
+    : IS_NPM_INSTALL
+      ? (event) => `claude-rpc hook ${event}`
+      : (event) => `node "${HOOK_SCRIPT.replace(/\\/g, '/')}" ${event}`;
 
   for (const event of EVENTS) {
     const bucket = settings.hooks[event] = settings.hooks[event] || [];
@@ -181,6 +187,25 @@ export function ensureCanonicalExe(currentExe) {
 }
 
 export function seedConfig() {
+  // npm-install upgrade path: prior v0.3.8 (and earlier) seeded config inside
+  // node_modules/claude-rpc/config.json. New shape puts it under USER_CONFIG_DIR.
+  // If the legacy file exists and the new one doesn't, copy first so the user
+  // doesn't lose their clientId.
+  if (IS_NPM_INSTALL) {
+    const legacyPath = join(ROOT, 'config.json');
+    try {
+      if (!existsSync(CONFIG_PATH) && existsSync(legacyPath)) {
+        mkdirSync(USER_CONFIG_DIR, { recursive: true });
+        copyFileSync(legacyPath, CONFIG_PATH);
+        console.log(`  config migrated → ${CONFIG_PATH}`);
+        console.log(`    (was: ${legacyPath} — safe to delete on next 'npm update')`);
+        return false;
+      }
+    } catch (e) {
+      console.warn(`  ! legacy-config migration skipped: ${e.message}`);
+    }
+  }
+
   if (existsSync(CONFIG_PATH)) {
     console.log(`  config exists → ${CONFIG_PATH}`);
     return false;
@@ -264,8 +289,18 @@ export async function install({ exePath, withStartup = true } = {}) {
     catch (e) { console.warn(`  startup entry failed: ${e.message}`); }
   }
   console.log('\nDone.');
-  console.log(`Edit ${CONFIG_PATH} to set your Discord clientId, then either reboot or run:`);
-  console.log(`  "${target}" daemon`);
+  console.log(`Edit ${CONFIG_PATH} to set your Discord clientId, then run:`);
+  // Per-mode "start" instructions — packaged exe takes a daemon subcommand,
+  // the npm bin shim handles `start` as a subcommand of itself, and dev
+  // mode runs the daemon script directly through node.
+  if (IS_PACKAGED) {
+    console.log(`  "${target}" daemon`);
+  } else if (IS_NPM_INSTALL) {
+    console.log(`  claude-rpc start`);
+  } else {
+    console.log(`  node "${join(ROOT, 'src', 'daemon.js').replace(/\\/g, '/')}"`);
+    console.log(`  # or: claude-rpc start  (if you've run \`npm link\`)`);
+  }
 }
 
 export async function uninstall() {

package/src/paths.js

@@ -11,6 +11,15 @@ export const IS_PACKAGED = typeof process.pkg !== 'undefined'
 
 export const ROOT = resolve(__dirname, '..');
 
+// True when we're running from a node_modules tree — `npm install -g claude-rpc`
+// or a local project's `node_modules`. Distinct from packaged mode (single
+// SEA exe) and dev mode (cloned repo, no node_modules wrapper).
+export const IS_NPM_INSTALL = !IS_PACKAGED && /[\\/]node_modules[\\/]/i.test(ROOT);
+
+// "Installed" covers both real distribution paths — config and runtime
+// artifacts live outside the install tree so they survive package updates.
+export const IS_INSTALLED = IS_PACKAGED || IS_NPM_INSTALL;
+
 // In packaged mode, persist user config in the per-OS app-data directory.
 // In dev mode, keep config.json next to the source tree for easy iteration.
 //   Windows: %APPDATA%\claude-rpc\
@@ -28,7 +37,11 @@ function userConfigDir() {
   return join(xdg, 'claude-rpc');
 }
 export const USER_CONFIG_DIR = userConfigDir();
-export const CONFIG_PATH = IS_PACKAGED
+// Persist config under USER_CONFIG_DIR whenever we're "installed" — packaged
+// exe OR npm-installed. The dev path keeps config next to source for easy
+// iteration. Putting it in node_modules would mean every `npm update` blows
+// away the user's clientId.
+export const CONFIG_PATH = IS_INSTALLED
   ? join(USER_CONFIG_DIR, 'config.json')
   : join(ROOT, 'config.json');
 

package/src/scanner.js

@@ -350,6 +350,47 @@ function readTranscriptCwd(path, mtimeMs) {
   return cwd;
 }
 
+// Per-transcript token cache. Reading a multi-MB .jsonl on every push tick
+// (4s) would be wasteful, so we only re-parse when the file's mtime has
+// advanced since the last read.
+const sessionTokenCache = new Map();  // path → { mtime, tokens }
+
+// Sum input/output/cache tokens from a single transcript JSONL.
+//
+// We need this because Claude Code's hook payloads don't carry usage data —
+// tokens are an assistant-message field, not a tool-call field, so PostToolUse
+// hooks fire with no `usage` block to capture. The live transcript is the
+// only source of truth for the current session's running token count.
+//
+// Returns null when the file can't be read; { input, output, cacheRead,
+// cacheWrite } otherwise. Cached by mtime — repeat calls with no file
+// activity are O(1).
+export function readSessionTokens(path) {
+  let st;
+  try { st = statSync(path); } catch { return null; }
+  const cached = sessionTokenCache.get(path);
+  if (cached && cached.mtime === st.mtimeMs) return cached.tokens;
+
+  const tokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  try {
+    const raw = readFileSync(path, 'utf8');
+    for (const line of raw.split('\n')) {
+      if (!line) continue;
+      const r = safeJson(line);
+      if (!r || r.type !== 'assistant') continue;
+      const u = r.message?.usage;
+      if (!u) continue;
+      tokens.input      += u.input_tokens || 0;
+      tokens.output     += u.output_tokens || 0;
+      tokens.cacheRead  += u.cache_read_input_tokens || 0;
+      tokens.cacheWrite += u.cache_creation_input_tokens || 0;
+    }
+  } catch { return null; }
+
+  sessionTokenCache.set(path, { mtime: st.mtimeMs, tokens });
+  return tokens;
+}
+
 // Detect live sessions by transcript mtime. Returns array of { path, project, cwd, mtime, ageSec }.
 // A session is "live" if its .jsonl was modified within thresholdMs.
 export function findLiveSessions({ projectsDir = CLAUDE_PROJECTS, thresholdMs = 90_000 } = {}) {