claude-rpc 0.17.2 → 0.19.1

package/src/state.js

@@ -13,6 +13,7 @@ import {
 } from 'node:fs';
 import { basename, join } from 'node:path';
 import { STATE_PATH, STATE_DIR } from './paths.js';
+import { pickActiveSession } from './presence.js';
 
 const DEFAULT_STATE = {
   sessionStart: null,
@@ -68,8 +69,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 +86,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 +112,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 +121,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 +133,64 @@ 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) {
+// The session a one-shot reader (status / serve / tui) should display. The
+// daemon resolves per-session state with cross-tick stickiness; one-shot readers
+// have no cursor, so they pass displayedId=null and get the most-recently-active
+// session — exactly what the daemon settles on. Falls back to the legacy global
+// state.json when no per-session files exist (e.g. a hook payload without an id).
+export function readActiveState({ now = Date.now(), idleMs = 60_000 } = {}) {
+  const sessions = listSessionStates();
+  if (!sessions.length) return readState();
+  return pickActiveSession(sessions, null, now, idleMs).state || readState();
+}
+
+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 +209,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/tui.js

@@ -6,8 +6,9 @@
 
 import process from 'node:process';
 import { readFileSync, existsSync } from 'node:fs';
-import { readState } from './state.js';
-import { readAggregate, findLiveSessions, dayKey, weekKey } from './scanner.js';
+import { readActiveState } from './state.js';
+import { readAggregate, findLiveSessions, weekKey } from './scanner.js';
+import { weekGrid } from './week.js';
 import { buildVars, applyIdle, humanProject } from './format.js';
 import { loadConfig } from './config.js';
 import { PID_PATH } from './paths.js';
@@ -51,7 +52,7 @@ let exiting = false;
 
 // ── Data ────────────────────────────────────────────────────────────────────
 function loadSnapshot() {
-  let state = readState();
+  let state = readActiveState();
   state.liveSessions = findLiveSessions({ thresholdMs: 90_000 });
   const config = loadConfig();
   state = applyIdle(state, config);
@@ -186,22 +187,7 @@ function tabWeek(_, data) {
   if (agg.byDay) {
     out.push('');
     out.push(`${C.dim}daily breakdown${C.reset}`);
-    const now = new Date();
-    now.setHours(0, 0, 0, 0);
-    const monday = new Date(now);
-    monday.setDate(monday.getDate() - ((monday.getDay() + 6) % 7));
-    const days = [];
-    for (let i = 0; i < 7; i++) {
-      const d = new Date(monday);
-      d.setDate(d.getDate() + i);
-      const k = dayKey(d.getTime());
-      const dayName = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'][d.getDay()];
-      const ms = agg.byDay[k]?.activeMs || 0;
-      const isFuture = d > now;
-      const isToday = k === dayKey(now.getTime());
-      days.push({ label: `${dayName} ${k.slice(5)}`, ms, isFuture, isToday });
-    }
-    const maxMs = Math.max(...days.map((d) => d.ms)) || 1;
+    const { days, maxMs } = weekGrid(agg.byDay);
     for (const { label, ms, isFuture, isToday } of days) {
       if (isFuture) {
         out.push(`${C.dim}${label.padEnd(11)}${' '.repeat(18)}     —${C.reset}`);

package/src/usage.js

@@ -75,7 +75,7 @@ export function normalizeUsage(json) {
 
 export async function fetchUsage({ fetchImpl = globalThis.fetch, creds = readClaudeCredentials(), now = Date.now() } = {}) {
   if (!creds?.accessToken) return { ok: false, reason: 'no-credentials' };
-  if (creds.expiresAt && now > creds.expiresAt) return { ok: false, reason: 'token-expired' };
+  if (creds.expiresAt && now > creds.expiresAt - 30_000) return { ok: false, reason: 'token-expired' }; // 30s skew margin — skip a request we know will 401
   let res;
   try {
     res = await fetchImpl(USAGE_ENDPOINT, {
@@ -112,7 +112,11 @@ export function writeUsageCache(usage, path = USAGE_CACHE_PATH) {
 export function readUsageCache({ path = USAGE_CACHE_PATH, maxAgeMs = USAGE_STALE_MS, now = Date.now() } = {}) {
   try {
     const u = JSON.parse(readFileSync(path, 'utf8'));
-    if (!u?.fetchedAt || now - u.fetchedAt > maxAgeMs) return null;
+    if (!u?.fetchedAt) return null;
+    const age = now - u.fetchedAt;
+    // Stale, or future-dated (corrupt write / clock skew) — a future fetchedAt
+    // would otherwise read as fresh forever.
+    if (age > maxAgeMs || age < -60_000) return null;
     return u;
   } catch { return null; }
 }

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.19.1';
 
 function readPkgVersion() {
   try {

package/src/week.js

@@ -0,0 +1,33 @@
+// Shared Monday-anchored current-week grid. cli.js (showWeek) and tui.js
+// (tabWeek) render it with different ANSI widths but compute the same seven
+// days, future/today flags, and peak — extracted here so the date math can't
+// drift between the two and is unit-testable against a fixed clock.
+
+import { dayKey } from './scanner.js';
+
+const DAY_NAMES = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+
+// Returns { days: [{ label, ms, isFuture, isToday }], maxMs } for the ISO week
+// (Mon -> Sun) containing `now`. `label` is e.g. "Wed 06-17"; future days have
+// ms 0 and isFuture true. maxMs is floored at 1 so callers divide safely.
+export function weekGrid(byDay = {}, now = new Date()) {
+  const today = new Date(now);
+  today.setHours(0, 0, 0, 0);
+  const monday = new Date(today);
+  monday.setDate(monday.getDate() - ((monday.getDay() + 6) % 7));
+  const todayKey = dayKey(today.getTime());
+  const days = [];
+  for (let i = 0; i < 7; i++) {
+    const d = new Date(monday);
+    d.setDate(d.getDate() + i);
+    const k = dayKey(d.getTime());
+    days.push({
+      label: `${DAY_NAMES[d.getDay()]} ${k.slice(5)}`,
+      ms: byDay?.[k]?.activeMs || 0,
+      isFuture: d > today,
+      isToday: k === todayKey,
+    });
+  }
+  const maxMs = Math.max(...days.map((x) => x.ms)) || 1;
+  return { days, maxMs };
+}