claude-rpc 1.3.0 → 1.3.1

package/SECURITY.md

@@ -304,6 +304,12 @@ untrusted or remote input into a shell:
   (`src/git.js`).
 - `gh repo view --json isPrivate` — auto-hide GitHub-private repos from the card
   (`src/privacy.js`); 1.5s timeout, silent skip if `gh` is absent.
+- `ps -eo comm=,args=` (macOS/Linux) / `powershell.exe Get-CimInstance
+  Win32_Process` filtered to `claude|node|bun|deno` (Windows) — the daemon's
+  60-second "is Claude Code still running?" liveness poll (`src/claude-proc.js`),
+  so an open-but-quiet session shows *idle* instead of vanishing. Read-only, the
+  result is one boolean, nothing is logged or sent anywhere; disable with
+  `processDetection: false`.
 - `gh gist` / `gh --version` — gist badge publishing, only under 3b
   (`src/gist.js`).
 - `npm root -g` / `npm install -g` — resolve / promote the global install during

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-rpc",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "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/claude-proc.js

@@ -0,0 +1,97 @@
+// "Is Claude Code actually running?" — process-level liveness detection.
+//
+// The daemon's only passive signals for "Claude Code is open" were hook
+// freshness (state.lastActivity) and transcript mtimes (findLiveSessions).
+// Both go quiet the moment the user stops typing: a session left open at the
+// prompt writes NOTHING to disk, so after staleSessionMin the daemon concluded
+// "Claude Code not running" and cleared the card — even with idleWhenOpen:true,
+// whose staleMs backstop exists precisely because transcript silence was
+// previously indistinguishable from a closed terminal. Asking the OS whether a
+// Claude Code process exists removes that ambiguity: alive → the card stays up
+// as 'idle' indefinitely; gone → the existing stale paths clear it.
+//
+// Detection is deliberately conservative about what counts as Claude Code:
+//   - a process literally named `claude` / `claude.exe` (native installer)
+//   - a runtime (node/bun/deno) whose command line points into the
+//     `@anthropic-ai/claude-code` package (npm/npx installs)
+//   - a binary run from the native installer's version store
+//     (~/.local/share/claude/versions/<v>)
+// It must NOT match claude-rpc itself (this daemon is `node .../claude-rpc/
+// src/daemon.js` — a bare /claude/ substring test would make the daemon see
+// itself as Claude Code and the card would never clear). Every pattern below
+// therefore requires a word boundary right after "claude".
+//
+// Adopted from the Teksya fork's groundwork (fork commit 46b62a5).
+import { execFile } from 'node:child_process';
+
+// One process-table query per call is the whole cost model; the daemon calls
+// on a slow timer (see CLAUDE_PROC_POLL_MS in daemon.js), so no caching here.
+const EXEC_TIMEOUT_MS = 15_000;
+
+// Does this (name, command line) pair look like a Claude Code process?
+// Exported for tests. `name` is the executable name where the platform gives
+// us one (Win32_Process.Name / ps comm); `cmdline` is the full command line.
+export function looksLikeClaudeCode(name, cmdline) {
+  const n = String(name || '').toLowerCase();
+  const c = String(cmdline || '').replace(/\\/g, '/').toLowerCase();
+  // The Claude DESKTOP app's binary is ALSO named claude(.exe) — Windows
+  // installs under …/AnthropicClaude/, macOS ships as Claude.app. It is not
+  // Claude Code; matching it would pin the card up whenever the chat app is
+  // open. Path check comes first so nothing below can re-admit it.
+  if (c.includes('anthropicclaude') || c.includes('claude.app/')) return false;
+  // npm / npx install: node …/node_modules/@anthropic-ai/claude-code/cli.js
+  if (c.includes('@anthropic-ai/claude-code/')) return true;
+  // Native-install version store: …/.local/share/claude/versions/<v>
+  if (c.includes('/share/claude/versions/')) return true;
+  // A command-line token that IS `claude` / `claude.exe` — bare (as typed in a
+  // shell, argv[0] preserved) or as the tail of a path. The boundary required
+  // right after "claude" is what keeps claude-rpc from matching.
+  if (/(^|[/"'])claude(\.exe)?["']?(\s|$)/.test(c)) return true;
+  // No command line to inspect (platform hid it) — fall back to the process
+  // name alone. Only safe here because the desktop-app exclusion above could
+  // not run; a bare-name match is still far likelier Code than the chat app
+  // being unreadable.
+  if (!c && (n === 'claude' || n === 'claude.exe')) return true;
+  return false;
+}
+
+function execText(file, args) {
+  return new Promise((resolve) => {
+    execFile(file, args, { timeout: EXEC_TIMEOUT_MS, windowsHide: true, maxBuffer: 8 * 1024 * 1024 },
+      (err, stdout) => resolve(err ? null : String(stdout || '')));
+  });
+}
+
+// Resolve to true/false when the platform answered, null when the query itself
+// failed (missing tool, timeout, unsupported platform) — null means "unknown"
+// and callers must fall back to the old transcript-only behavior. Never throws.
+export async function detectClaudeProcess() {
+  if (process.platform === 'win32') {
+    // Only the names that can host Claude Code — a full process dump with
+    // command lines is much slower than this filtered CIM query.
+    const script = "Get-CimInstance Win32_Process -Filter \"Name='claude.exe' OR Name='node.exe' OR Name='bun.exe' OR Name='deno.exe'\" | ForEach-Object { $_.Name + [char]9 + $_.CommandLine }";
+    const out = await execText('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', script]);
+    if (out === null) return null;
+    for (const line of out.split('\n')) {
+      const tab = line.indexOf('\t');
+      const name = tab === -1 ? line.trim() : line.slice(0, tab).trim();
+      const cmd = tab === -1 ? '' : line.slice(tab + 1);
+      if (looksLikeClaudeCode(name, cmd)) return true;
+    }
+    return false;
+  }
+  // macOS / Linux. comm is the executable name (first token); args follows.
+  const out = await execText('ps', ['-eo', 'comm=,args=']);
+  if (out === null) return null;
+  for (const line of out.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const sp = trimmed.indexOf(' ');
+    const comm = sp === -1 ? trimmed : trimmed.slice(0, sp);
+    const args = sp === -1 ? '' : trimmed.slice(sp + 1);
+    // comm may be a path on some ps builds — compare its basename.
+    const base = comm.slice(comm.lastIndexOf('/') + 1);
+    if (looksLikeClaudeCode(base, args)) return true;
+  }
+  return false;
+}

package/src/daemon.js

@@ -7,6 +7,7 @@ import { readState, sweepStaleStateTmp, listSessionStates, sweepStaleSessionStat
 import { makeRotationCursor, pickFrames, selectFrame, resolveLargeImageKey, shouldShowGithubButton, pickActiveSession, throttleDecision } from './presence.js';
 import { buildVars, fillTemplate, framePasses, applyIdle, applyShipped, applyTrigger } from './format.js';
 import { scan, readAggregate, findLiveSessions, readSessionTokens, readSessionModel } from './scanner.js';
+import { detectClaudeProcess } from './claude-proc.js';
 import { detectGithubUrl } from './git.js';
 import { applyPrivacy } from './privacy.js';
 import { pauseUntil } from './pause.js';
@@ -100,6 +101,12 @@ try {
 let config = loadConfigWithLog();
 let aggregate = readAggregate() || null;
 let liveSessions = [];
+// OS-level "a Claude Code process exists" flag (see claude-proc.js). Injected
+// into every resolved state so applyIdle can tell "open but quiet" (→ idle)
+// from "actually closed" (→ stale) — transcript mtimes alone can't, which is
+// why an untouched-but-open session used to clear the card after staleSessionMin.
+// null = unknown (never checked / detection unavailable) → old behavior.
+let claudeProcAlive = null;
 let client = null;
 let connected = false;
 let connecting = false; // login() in flight — see the watchdog note in connect()
@@ -147,6 +154,10 @@ const rotationCursor = makeRotationCursor();
 // Which concurrent session's card we're currently showing. pickActiveSession
 // keeps it sticky — see resolvePresence.
 let displayedSessionId = null;
+// sessionId → transcript path, remembered from the last tick the session was
+// inside the live window. Lets token enrichment keep reading the (mtime-
+// cached) transcript after it goes quiet instead of zeroing the card's count.
+const sessionPathMemo = new Map();
 // 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.
@@ -216,6 +227,10 @@ function resolvePresence(opts = {}) {
   // 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;
+  // Same injection pattern for OS-level process liveness — standalone callers
+  // (preview/api) that pass an explicit state simply leave it undefined and
+  // get the historical transcript-only behavior.
+  if (state.claudeProcessAlive === undefined) state.claudeProcessAlive = claudeProcAlive;
   state = applyIdle(state, config);
   // Shipped overlay sits on top of idle/working/thinking — but never over
   // stale (we don't celebrate when Claude isn't running).
@@ -228,18 +243,43 @@ function resolvePresence(opts = {}) {
   // 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);
+  // Matching is by SESSION ID first: the transcript file is named
+  // <sessionId>.jsonl, so this is exact. The old cwd-only match silently
+  // broke whenever the two cwd notions diverged — state.cwd follows the
+  // hooks (UserPromptSubmit re-stamps it after every in-session `cd`) while
+  // the live-session cwd is read from the transcript HEAD (fixed at session
+  // start) — leaving the card's token count stuck at 0. The id→path memo
+  // keeps enrichment alive after the transcript ages out of the live window
+  // (>90s quiet), so an idle card keeps its final token count instead of
+  // dropping to zero. cwd remains the fallback for borrowed states (whose
+  // sessionId belongs to the QUIET session, not the transcript we adopted)
+  // and legacy id-less states.
+  if (state.status !== 'stale') {
+    const live = state.liveSessions || [];
+    let tpath = null;
+    if (state.sessionId && !state.borrowed) {
+      const bySid = live.find((s) => basename(s.path || '', '.jsonl') === state.sessionId);
+      if (bySid) {
+        tpath = bySid.path;
+        if (!sessionPathMemo.has(state.sessionId) && sessionPathMemo.size >= 64) {
+          sessionPathMemo.delete(sessionPathMemo.keys().next().value);
+        }
+        sessionPathMemo.set(state.sessionId, tpath);
+      } else {
+        tpath = sessionPathMemo.get(state.sessionId) || null;
+      }
+    }
+    if (!tpath && state.cwd) {
+      const cwdLower = state.cwd.toLowerCase();
+      tpath = live.find((s) => (s.cwd || '').toLowerCase() === cwdLower)?.path || null;
+    }
+    if (tpath) {
+      const t = readSessionTokens(tpath);
       if (t) state.tokens = t;
       // The hook only learns the model at SessionStart; a mid-session /model
       // switch is visible only in the transcript. Render-time override — the
       // state file stays hook-owned.
-      const liveModel = readSessionModel(match.path);
+      const liveModel = readSessionModel(tpath);
       if (liveModel) state.model = liveModel;
     }
   }
@@ -769,6 +809,45 @@ function refreshLiveSessions() {
 refreshLiveSessions();
 setInterval(refreshLiveSessions, 30_000);
 
+// OS-level Claude Code liveness poll (see claude-proc.js). This is what lets
+// an open-but-untouched session stay 'idle' forever instead of being declared
+// stale after staleSessionMin — hook state and transcript mtimes both go
+// silent when the user merely stops typing, but the process table doesn't lie.
+// 60s cadence: one filtered process-table query per minute is negligible, and
+// a card lingering up to a minute after Claude truly exits is fine (the same
+// order as the transcript-based paths). Kill switch: processDetection:false.
+// A single failed query keeps the last known answer (a transient PowerShell/ps
+// hiccup must not flash the card off); two consecutive failures degrade to
+// null = unknown, which restores the old transcript-only behavior.
+const CLAUDE_PROC_POLL_MS = 60_000;
+let claudeProcFailStreak = 0;
+async function refreshClaudeProc() {
+  if (config.processDetection === false) { claudeProcAlive = null; return; }
+  try {
+    const alive = await detectClaudeProcess();
+    if (alive === null) {
+      claudeProcFailStreak += 1;
+      if (claudeProcFailStreak >= 2 && claudeProcAlive !== null) {
+        log('claude-proc: detection unavailable — falling back to transcript-only liveness');
+        claudeProcAlive = null;
+      }
+      return;
+    }
+    claudeProcFailStreak = 0;
+    if (alive !== claudeProcAlive) {
+      log(`claude-proc: Claude Code process ${alive ? 'detected' : 'gone'}`);
+      claudeProcAlive = alive;
+      resetTransmit();
+      pushPresence();
+    }
+  } catch (e) {
+    log('claude-proc poll failed:', e.message);
+  }
+}
+refreshClaudeProc();
+const claudeProcTimer = setInterval(refreshClaudeProc, CLAUDE_PROC_POLL_MS);
+if (claudeProcTimer.unref) claudeProcTimer.unref();
+
 // ── Connection watchdog (auto-heal) ──────────────────────────────────────────
 // The reconnect path is event-driven (the 'disconnected' handler + login
 // failures + setActivity errors). But a connection can rot in ways that emit

package/src/default-config.js

@@ -54,6 +54,12 @@ export const DEFAULT_CONFIG = {
   // up through short pauses, at the cost of a closed terminal showing idle for
   // up to staleSessionMin minutes before clearing).
   idleWhenOpen: false,
+  // OS-level "is a Claude Code process running?" check (src/claude-proc.js,
+  // polled every 60s). When it affirmatively finds one, a quiet-but-open
+  // session stays 'idle' instead of going stale — the transcript-silence
+  // guesswork above only applies when detection is off, unavailable, or the
+  // process is confirmed gone. Set false to disable the process-table query.
+  processDetection: true,
   // When true, the daemon CLEARS Discord activity entirely once the state
   // goes stale — your profile shows nothing instead of an "Away" frame.
   hideWhenStale: true,

package/src/format.js

@@ -885,6 +885,15 @@ export function applyIdle(state, cfg = {}) {
   const idleMs = (cfg.idleThresholdSec || 60) * 1000;
   const staleMs = Math.max(60_000, (cfg.staleSessionMin || 5) * 60 * 1000);
   const notificationMs = (cfg.notificationWindowSec || 8) * 1000;
+  // OS-level liveness (set by the daemon from claude-proc.detectClaudeProcess,
+  // like liveSessions): true = a Claude Code process definitely exists right
+  // now. Transcripts and hooks both go silent when the user just stops typing,
+  // so without this every quiet-but-open session eventually read as "closed"
+  // and the card was cleared mid-use. Only an affirmative true changes
+  // behavior — false/null/absent (detection failed, unsupported platform,
+  // standalone preview/API callers) keeps the historical transcript-only
+  // logic, so this can only ever KEEP a card up, never strand one.
+  const procAlive = state.claudeProcessAlive === true;
   // Closing the terminal kills Claude Code without firing SessionEnd, so the
   // only passive "is it gone?" signal is "no transcript is being written".
   // DEFAULT (false): clear the card within ~90-120s of the transcript going
@@ -927,7 +936,24 @@ export function applyIdle(state, cfg = {}) {
   }
 
   // Truly dormant: no live transcripts AND local state is old → stale.
-  if (ageMs > staleMs && liveAgeMs > staleMs) return staleWipe(state);
+  // Unless the OS says a Claude Code process is still running — then the user
+  // simply walked away from an open session, which is 'idle', not 'stale'.
+  // The current-activity slots are wiped like the idle transition below so a
+  // long-dormant card can't keep showing an hours-old tool/file.
+  if (ageMs > staleMs && liveAgeMs > staleMs) {
+    if (procAlive) {
+      return {
+        ...state,
+        status: 'idle',
+        currentTool: null,
+        currentFile: null,
+        filesOpened: [],
+        filesEdited: [],
+        filesRead: [],
+      };
+    }
+    return staleWipe(state);
+  }
 
   // Local state is stale but a live transcript exists somewhere on disk.
   // Borrow the most-recent live session as our "active" context, since the
@@ -944,7 +970,9 @@ export function applyIdle(state, cfg = {}) {
     // clears the card within ~90-120s of the last write. Opt in with
     // idleWhenOpen:true to keep showing 'idle' through short pauses; the
     // staleMs dormancy backstop above still clears it if Claude is truly gone.
-    if (liveSessions.length === 0 && !idleWhenOpen) return staleWipe(state);
+    // A confirmed-alive Claude Code process overrides the heuristic entirely —
+    // the process being up IS the answer the transcript silence was guessing at.
+    if (liveSessions.length === 0 && !idleWhenOpen && !procAlive) return staleWipe(state);
     return state;
   }
   if (ageMs > idleMs) {
@@ -954,8 +982,9 @@ export function applyIdle(state, cfg = {}) {
     // Hooks quiet AND no live transcripts. By default (idleWhenOpen=false)
     // treat Claude as gone and go stale now. With idleWhenOpen:true the
     // session is treated as open-but-paused and drops to idle; the staleMs
-    // backstop above clears it later if Claude actually exited.
-    if (liveSessions.length === 0 && !idleWhenOpen) return staleWipe(state);
+    // backstop above clears it later if Claude actually exited. A confirmed
+    // Claude Code process short-circuits the guess — drop to idle instead.
+    if (liveSessions.length === 0 && !idleWhenOpen && !procAlive) return staleWipe(state);
     // Going idle — wipe "current activity" indicators so rotation frames
     // gated on filesEdited / currentFile / currentTool stop showing stale
     // active-session data. Keep the session counters (messages/tools/tokens)

package/src/install.js

@@ -284,10 +284,18 @@ export async function addStartupEntry(exePath) {
   // daemon. Launch through a tiny .vbs shim via wscript (window style 0) so the
   // unattended startup path is windowless, like every other launch path. We
   // avoid schtasks deliberately — SECURITY.md advertises "no scheduled task".
-  let runCmd = `"${exePath}" daemon`;
+  // The command comes from daemonLaunch like the mac/linux branches — the old
+  // hardcoded `"<exe>" daemon` form assumed packaged mode, so npm installs got
+  // a Run entry of `"node.exe" daemon` (no script path) and login-autostart
+  // silently launched nothing.
+  const launch = daemonLaunch(exePath);
+  let runCmd = [launch.exe, ...launch.args].map((p) => `"${p}"`).join(' ');
   try {
     mkdirSync(CANONICAL_INSTALL_DIR, { recursive: true });
-    writeFileSync(STARTUP_VBS, `CreateObject("WScript.Shell").Run """${exePath}"" daemon", 0, False\r\n`);
+    // In a VBS string literal a doubled quote is an escaped quote, so each
+    // `""x""` below reaches the shell as `"x"`.
+    const vbsCmd = [launch.exe, ...launch.args].map((p) => `""${p}""`).join(' ');
+    writeFileSync(STARTUP_VBS, `CreateObject("WScript.Shell").Run "${vbsCmd}", 0, False\r\n`);
     runCmd = `wscript.exe "${STARTUP_VBS}"`;
   } catch { /* couldn't write the shim — fall back to the direct (windowed) entry */ }
   await regCommand([

package/src/presence.js

@@ -76,10 +76,13 @@ export function pickActiveSession(states, displayedId, now, idleMs) {
   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];
+  // Otherwise show the most-recently-active live session — or, if none are
+  // live, the most-recent NOT-closed session (a window sitting idle beats one
+  // that fired SessionEnd: the closed session's fresher lastActivity would
+  // otherwise drag the card stale while a sibling is still open), and only
+  // then the most-recent overall so the card follows the last session into
+  // idle/stale rather than blanking.
+  const chosen = byRecent.find(isLive) || byRecent.find((s) => !s.claudeClosed) || byRecent[0];
   return { state: chosen, sessionId: chosen.sessionId, liveCount };
 }
 

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 = '1.3.0';
+const BAKED = '1.3.1';
 
 function readPkgVersion() {
   try {