claude-rpc 0.17.2 → 0.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-rpc",
-  "version": "0.17.2",
+  "version": "0.18.0",
   "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",

package/src/daemon.js

@@ -2,8 +2,8 @@
 import { writeFileSync, readFileSync, existsSync, unlinkSync, watch, appendFileSync, mkdirSync, statSync, renameSync } from 'node:fs';
 import { basename, dirname } from 'node:path';
 import { Client } from './discord-ipc.js';
-import { readState, sweepStaleStateTmp } from './state.js';
-import { makeRotationCursor, pickFrames, selectFrame, resolveLargeImageKey, shouldShowGithubButton } from './presence.js';
+import { readState, sweepStaleStateTmp, listSessionStates, sweepStaleSessionStates } from './state.js';
+import { makeRotationCursor, pickFrames, selectFrame, resolveLargeImageKey, shouldShowGithubButton, pickActiveSession } from './presence.js';
 import { buildVars, fillTemplate, framePasses, applyIdle, applyShipped, applyTrigger } from './format.js';
 import { scan, readAggregate, findLiveSessions, readSessionTokens } from './scanner.js';
 import { detectGithubUrl } from './git.js';
@@ -96,6 +96,9 @@ let reconnectDelayMs    = RECONNECT_BASE_MS;
 // 12-frame rotation into a single-frame working state and back, producing a
 // jarring "blank tick" until modulo aligns.
 const rotationCursor = makeRotationCursor();
+// Which concurrent session's card we're currently showing. pickActiveSession
+// keeps it sticky — see resolvePresence.
+let displayedSessionId = null;
 // Stabilizes Discord's elapsed timer: applyIdle can synthesize a sessionStart
 // from a moving transcript mtime, and missing-hook scenarios leave it null —
 // either case would make startTimestamp jump on every rotation.
@@ -121,8 +124,10 @@ try {
 } catch { /* unreadable PID file — fall through and claim it */ }
 writeFileSync(PID_PATH, String(process.pid));
 
-// Reclaim any per-pid state tmp files orphaned by a hard-killed writer.
+// Reclaim any per-pid state tmp files orphaned by a hard-killed writer, plus
+// per-session state files from sessions that ended long ago.
 sweepStaleStateTmp();
+sweepStaleSessionStates();
 
 // pickFrames / selectFrame / resolveLargeImageKey now live in presence.js (pure
 // + unit-tested). The rotation cursor (rotationCursor) is owned here and passed
@@ -135,7 +140,29 @@ sweepStaleStateTmp();
 // previously this chain ran twice and only buildActivity applied the trigger
 // overlay, so the two could diverge.
 function resolvePresence(opts = {}) {
-  let state = opts.state || readState();
+  let state;
+  if (opts.state) {
+    state = opts.state; // standalone caller (preview/api) passes an explicit state
+  } else {
+    // Multi-session: each session writes its own state-<id>.json. Pick which one
+    // to show, sticking with the current session while it's active so the card
+    // doesn't thrash between projects (which also stabilizes the elapsed timer
+    // and the GitHub button — both follow the displayed session). Fall back to
+    // the legacy global state.json when there are no per-session files.
+    const sessions = listSessionStates();
+    if (sessions.length) {
+      const idleMs = Math.max(30_000, (config.idleThresholdSec || 60) * 1000);
+      const picked = pickActiveSession(sessions, displayedSessionId, Date.now(), idleMs);
+      displayedSessionId = picked.sessionId;
+      state = picked.state || readState();
+      // Party count from the SAME per-session list we selected from, so the
+      // "N sessions" field stays consistent with the card instead of wobbling
+      // on transcript-mtime timing.
+      state._liveCount = picked.liveCount;
+    } else {
+      state = readState();
+    }
+  }
   // Attach live sessions BEFORE applyIdle so the stale/idle decision can
   // see ongoing transcript activity, not just this daemon's hook state.
   state.liveSessions = opts.liveSessions || liveSessions;
@@ -257,7 +284,9 @@ function buildActivity(opts = {}) {
   // Concurrent sessions render natively via Discord's party field — the card
   // shows "(2 of 2)" with no template work. Only attached when more than one
   // live session exists (a party of one is noise). Opt out: showPartySize:false.
-  const liveCount = (state.liveSessions || []).length;
+  // Prefer the per-session count (consistent with the displayed session); fall
+  // back to the transcript-derived count for the legacy single-state path.
+  const liveCount = state._liveCount != null ? state._liveCount : (state.liveSessions || []).length;
   if (config.showPartySize !== false && liveCount > 1) {
     activity.partyId = 'claude-rpc';
     activity.partySize = liveCount;

package/src/hook.js

@@ -125,9 +125,17 @@ function parseInput() {
 // directly (avoids spawning a child process per hook).
 export function processHookEvent(event, input = {}) {
   const now = Date.now();
+  // Each session writes its OWN state file (state-<sessionId>.json) so concurrent
+  // sessions stop clobbering one shared state.json — that thrash made the card
+  // jump between projects, the timer reset, and counters over-count. Subagent
+  // hooks carry the parent's session_id, so their activity rolls up correctly.
+  // No id (legacy payload) → the global state.json, preserving old behavior.
+  const sid = input.session_id || input.sessionId || null;
+  const update = (fn) => updateState(fn, sid);
+  const reset = (seed) => resetState(seed, sid);
 
   function setActivity(patch) {
-    updateState((s) => {
+    update((s) => {
       Object.assign(s, patch);
       s.lastActivity = now;
       // Any hook firing means Claude Code is alive — clear the closed flag
@@ -140,7 +148,7 @@ export function processHookEvent(event, input = {}) {
 
   switch (event) {
     case 'SessionStart': {
-      resetState({
+      reset({
         cwd: input.cwd || process.cwd(),
         model: input.model?.id || input.model || 'claude',
         status: 'idle',
@@ -148,7 +156,7 @@ export function processHookEvent(event, input = {}) {
       break;
     }
     case 'UserPromptSubmit': {
-      updateState((s) => {
+      update((s) => {
         s.messages += 1;
         s.lastUserPrompt = now;
         s.lastActivity = now;
@@ -164,7 +172,7 @@ export function processHookEvent(event, input = {}) {
       const toolName = input.tool_name || input.toolName || 'tool';
       const toolInput = input.tool_input || input.toolInput || {};
       const file = toolInput.file_path || toolInput.path || toolInput.notebook_path || null;
-      updateState((s) => {
+      update((s) => {
         s.tools += 1;
         s.toolBreakdown[toolName] = (s.toolBreakdown[toolName] || 0) + 1;
         s.currentTool = toolName;
@@ -211,7 +219,7 @@ export function processHookEvent(event, input = {}) {
           }
         }
       }
-      updateState((s) => {
+      update((s) => {
         s.currentTool = null;
         s.toolStartedAt = null;
         s.lastActivity = now;
@@ -236,7 +244,7 @@ export function processHookEvent(event, input = {}) {
       break;
     }
     case 'Notification': {
-      updateState((s) => {
+      update((s) => {
         s.status = 'notification';
         s.lastNotification = now;
         s.lastActivity = now;
@@ -254,7 +262,7 @@ export function processHookEvent(event, input = {}) {
       // rewriting earlier context, not advancing a turn. Surface it as its
       // own state so the card stops reading "Thinking…" for the 10-60s
       // compactions can take on big sessions.
-      updateState((s) => {
+      update((s) => {
         s.status = 'compacting';
         s.compactStartedAt = now;
         s.compactTrigger = input.trigger || input.matcher || null;
@@ -276,7 +284,7 @@ export function processHookEvent(event, input = {}) {
       // staleSessionMin timeout. applyIdle short-circuits to stale when it
       // sees claudeClosed=true. Any subsequent hook from another live
       // session will flip the flag back to false.
-      updateState((s) => {
+      update((s) => {
         s.status = 'stale';
         s.claudeClosed = true;
         s.currentTool = null;

package/src/presence.js

@@ -55,6 +55,34 @@ export function selectFrame(rawFrames, vars, status, cursor, intervalMs, framePa
   return frames[cursor.index % frames.length] || {};
 }
 
+// Pick which session's card to show when several Claude sessions run at once.
+// Each session writes its own state-<id>.json (lastActivity stamped on every
+// hook), so `states` is one entry per session. Behavior: STICK to the currently
+// shown session while it's still active (lastActivity within idleMs), so the
+// card doesn't thrash between sessions while you're working in one; only once
+// the shown session goes idle do we switch to the most-recently-active session.
+// Returns { state, sessionId, liveCount } — liveCount feeds the "N sessions"
+// party field so it stays consistent with what's displayed.
+export function pickActiveSession(states, displayedId, now, idleMs) {
+  const list = (states || []).filter((s) => s && s.sessionId);
+  if (!list.length) return { state: null, sessionId: null, liveCount: 0 };
+  // A just-ended session (SessionEnd → claudeClosed) stamps a recent
+  // lastActivity but is gone — never count it live or stick to it.
+  const isLive = (s) => !s.claudeClosed && now - (s.lastActivity || 0) <= idleMs;
+  const liveCount = list.filter(isLive).length;
+  const byRecent = [...list].sort((a, b) => (b.lastActivity || 0) - (a.lastActivity || 0));
+  // Stickiness: keep the shown session while it's still active.
+  const current = list.find((s) => s.sessionId === displayedId);
+  if (current && isLive(current)) {
+    return { state: current, sessionId: current.sessionId, liveCount };
+  }
+  // Otherwise show the most-recently-active live session — or, if none are live,
+  // the most-recent overall so the card follows the last session into idle/stale
+  // rather than blanking.
+  const chosen = byRecent.find(isLive) || byRecent[0];
+  return { state: chosen, sessionId: chosen.sessionId, liveCount };
+}
+
 // Should the daemon auto-add a "View on GitHub →" button for this cwd? The
 // button URL is read from .git/config (no `gh` needed), but private-repo
 // detection DOES need the gh CLI — so on a machine without gh a private repo

package/src/state.js

@@ -68,8 +68,8 @@ function ensureDir() {
 // serialize through an exclusive lock file. The lock is strictly best-effort:
 // if we can't get it within LOCK_MAX_WAIT_MS we proceed anyway (a slightly racy
 // write is better than a dropped hook), and a stale lock from a crashed process
-// is reclaimed after LOCK_STALE_MS.
-const LOCK_PATH = STATE_PATH + '.lock';
+// is reclaimed after LOCK_STALE_MS. The lock path is per state file (passed in)
+// so per-session writers don't serialize against each other.
 const LOCK_STALE_MS = 2000;
 const LOCK_RETRY_MS = 4;
 const LOCK_MAX_WAIT_MS = 1000;
@@ -85,18 +85,18 @@ function sleepSync(ms) {
   }
 }
 
-function acquireLock() {
+function acquireLock(lockPath) {
   const deadline = Date.now() + LOCK_MAX_WAIT_MS;
   for (;;) {
     try {
       // 'wx' fails if the file exists — that's our mutex.
-      return openSync(LOCK_PATH, 'wx');
+      return openSync(lockPath, 'wx');
     } catch (err) {
       if (err.code !== 'EEXIST') return null; // unexpected (perms, etc.) — go lockless
       try {
-        if (Date.now() - statSync(LOCK_PATH).mtimeMs > LOCK_STALE_MS) {
+        if (Date.now() - statSync(lockPath).mtimeMs > LOCK_STALE_MS) {
           try {
-            unlinkSync(LOCK_PATH);
+            unlinkSync(lockPath);
           } catch {
             /* someone else reclaimed it first */
           }
@@ -111,7 +111,7 @@ function acquireLock() {
   }
 }
 
-function releaseLock(fd) {
+function releaseLock(fd, lockPath) {
   if (fd === null) return;
   // Only unlink the lock if the path still points at OUR lock file. If this
   // process somehow held it past LOCK_STALE_MS, a sibling has reclaimed the
@@ -120,7 +120,7 @@ function releaseLock(fd) {
   let ours;
   try {
     const a = fstatSync(fd);
-    const b = statSync(LOCK_PATH);
+    const b = statSync(lockPath);
     ours = a.ino === b.ino && a.dev === b.dev;
   } catch {
     ours = false; // lock already gone — nothing to unlink
@@ -132,40 +132,53 @@ function releaseLock(fd) {
   }
   if (!ours) return;
   try {
-    unlinkSync(LOCK_PATH);
+    unlinkSync(lockPath);
   } catch {
     /* already removed */
   }
 }
 
-function withLock(fn) {
-  const fd = acquireLock();
+function withLock(lockPath, fn) {
+  const fd = acquireLock(lockPath);
   try {
     return fn();
   } finally {
-    releaseLock(fd);
+    releaseLock(fd, lockPath);
   }
 }
 
-export function readState() {
+// Resolve the state file for a session. No id → the legacy global state.json
+// (single-session and back-compat). With an id → a per-session file, so
+// concurrent sessions stop clobbering each other's status/tools/tokens and the
+// daemon can pick which one to show. The id is a Claude Code session UUID;
+// sanitize defensively for the filename regardless.
+export function statePathFor(sessionId) {
+  if (!sessionId) return STATE_PATH;
+  const safe = String(sessionId).replace(/[^A-Za-z0-9_-]/g, '').slice(0, 64) || 'unknown';
+  return join(STATE_DIR, `state-${safe}.json`);
+}
+
+export function readState(sessionId) {
   ensureDir();
-  if (!existsSync(STATE_PATH)) return { ...DEFAULT_STATE };
+  const path = statePathFor(sessionId);
+  if (!existsSync(path)) return { ...DEFAULT_STATE };
   try {
-    const raw = readFileSync(STATE_PATH, 'utf8');
+    const raw = readFileSync(path, 'utf8');
     return { ...DEFAULT_STATE, ...JSON.parse(raw) };
   } catch {
     return { ...DEFAULT_STATE };
   }
 }
 
-export function writeState(next) {
+export function writeState(next, sessionId) {
   ensureDir();
-  // Per-process tmp name: two processes writing the shared STATE_PATH + '.tmp'
-  // would clobber each other's tmp before rename. The pid suffix keeps the
+  const path = statePathFor(sessionId);
+  // Per-process tmp name: two processes writing the same <path>.tmp would
+  // clobber each other's tmp before rename. The pid suffix keeps the
   // atomic-rename guarantee intact even on the best-effort lockless path.
-  const tmp = `${STATE_PATH}.${process.pid}.tmp`;
+  const tmp = `${path}.${process.pid}.tmp`;
   writeFileSync(tmp, JSON.stringify(next, null, 2));
-  renameSync(tmp, STATE_PATH);
+  renameSync(tmp, path);
 }
 
 // Best-effort sweep of orphaned per-pid tmp files (`state.json.<pid>.tmp`) left
@@ -184,19 +197,62 @@ export function sweepStaleStateTmp(now = Date.now()) {
   } catch { /* STATE_DIR missing / unreadable — nothing to sweep */ }
 }
 
-export function updateState(mutator) {
-  return withLock(() => {
-    const current = readState();
+// All per-session states currently on disk, each tagged with its sessionId
+// (recovered from the `state-<id>.json` filename). The daemon uses this to pick
+// which session to show. Excludes the legacy global state.json (no `-<id>`),
+// and tmp/lock siblings (they don't end in `.json`).
+export function listSessionStates() {
+  ensureDir();
+  const out = [];
+  let names;
+  try { names = readdirSync(STATE_DIR); } catch { return out; }
+  for (const name of names) {
+    const m = /^state-(.+)\.json$/.exec(name);
+    if (!m) continue;
+    try {
+      const parsed = JSON.parse(readFileSync(join(STATE_DIR, name), 'utf8'));
+      out.push({ ...DEFAULT_STATE, ...parsed, sessionId: m[1] });
+    } catch { /* torn/broken file mid-write — skip this tick */ }
+  }
+  return out;
+}
+
+// Remove per-session state files whose last activity is older than maxAgeMs — a
+// session that ended without cleanup, or a crashed one. Called periodically by
+// the daemon; never touches the global state.json. Returns the count removed.
+export function sweepStaleSessionStates(maxAgeMs = 6 * 60 * 60 * 1000, now = Date.now()) {
+  let removed = 0, names;
+  try { names = readdirSync(STATE_DIR); } catch { return 0; }
+  for (const name of names) {
+    if (!/^state-.+\.json$/.test(name)) continue;
+    const full = join(STATE_DIR, name);
+    try {
+      const last = JSON.parse(readFileSync(full, 'utf8')).lastActivity || 0;
+      if (now - last > maxAgeMs) { unlinkSync(full); removed++; }
+    } catch {
+      // Unparseable — age out by file mtime so a corrupt file still clears.
+      try { if (now - statSync(full).mtimeMs > maxAgeMs) { unlinkSync(full); removed++; } }
+      catch { /* gone */ }
+    }
+  }
+  return removed;
+}
+
+export function updateState(mutator, sessionId) {
+  const lockPath = statePathFor(sessionId) + '.lock';
+  return withLock(lockPath, () => {
+    const current = readState(sessionId);
     const next = mutator({ ...current }) ?? current;
-    writeState(next);
+    writeState(next, sessionId);
     return next;
   });
 }
 
-export function resetState(seed = {}) {
-  return withLock(() => {
+export function resetState(seed = {}, sessionId) {
+  const lockPath = statePathFor(sessionId) + '.lock';
+  return withLock(lockPath, () => {
     const fresh = { ...DEFAULT_STATE, sessionStart: Date.now(), lastActivity: Date.now(), ...seed };
-    writeState(fresh);
+    writeState(fresh, sessionId);
     return fresh;
   });
 }

package/src/version.js

@@ -11,7 +11,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { ROOT } from './paths.js';
 
-const BAKED = '0.17.2';
+const BAKED = '0.18.0';
 
 function readPkgVersion() {
   try {