claude-rpc 0.7.4 → 0.8.0

package/package.json

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

@@ -282,9 +282,33 @@ async function pushPresence() {
     log('Presence updated:', activity.details || '-', '|', activity.state || '-');
   } catch (e) {
     log('setActivity failed:', e.message, '|', e.stack?.split('\n').slice(0, 3).join(' | '));
+    // A failed setActivity usually means the IPC pipe died WITHOUT the client
+    // emitting a 'disconnected' event (Discord restart, socket reset, OS
+    // sleep). Left alone, `connected` stays true and the daemon goes silently
+    // dark forever. Tear the client down and force a backoff reconnect so we
+    // self-heal. Guarded to connection-shaped errors so a one-off API hiccup
+    // doesn't needlessly bounce a healthy socket.
+    if (isConnectionError(e)) {
+      log('setActivity error looks connection-level — forcing reconnect');
+      connected = false;
+      lastPayloadHash = '';
+      try { client?.destroy(); } catch { /* already gone */ }
+      scheduleReconnect('setActivity failed');
+    }
   }
 }
 
+// Heuristic: does this error indicate the IPC transport itself is dead
+// (vs. a transient/application-level failure)? Matches the common broken-pipe
+// / closed-socket shapes from @xhayper/discord-rpc and the underlying net
+// socket so we only force a reconnect when the connection is actually gone.
+function isConnectionError(e) {
+  const code = (e && e.code) || '';
+  if (['EPIPE', 'ECONNRESET', 'ENOENT', 'ECONNREFUSED', 'ERR_STREAM_WRITE_AFTER_END'].includes(code)) return true;
+  const m = String((e && e.message) || '').toLowerCase();
+  return /closed|reset|broken pipe|not connected|disconnect|write after end|socket|econnreset|epipe|connection/.test(m);
+}
+
 async function connect() {
   if (reconnectTimer) { clearTimeout(reconnectTimer); reconnectTimer = null; }
   client = new Client({ clientId: config.clientId, transport: { type: 'ipc' } });
@@ -454,6 +478,36 @@ function refreshLiveSessions() {
 refreshLiveSessions();
 setInterval(refreshLiveSessions, 30_000);
 
+// ── 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
+// no event at all: a half-open client where `connected` is still true but the
+// user handle is gone, or a state where we're down with no retry in flight.
+// This periodic check guarantees the daemon always converges back to a live
+// connection instead of silently staying dark — the single most common
+// "it just stopped showing up" failure users hit.
+const HEALTH_CHECK_MS = 30_000;
+setInterval(() => {
+  try {
+    // Half-open: flag says connected but there's no usable user handle.
+    if (connected && !client?.user) {
+      log('Watchdog: connected but no user handle — forcing reconnect');
+      connected = false;
+      try { client?.destroy(); } catch { /* already gone */ }
+      scheduleReconnect('watchdog: half-open');
+      return;
+    }
+    // Down with nothing scheduled to bring us back. scheduleReconnect is a
+    // no-op when a timer is already pending, so this can't stack retries.
+    if (!connected && !reconnectTimer) {
+      log('Watchdog: disconnected with no reconnect pending — forcing reconnect');
+      scheduleReconnect('watchdog: no retry pending');
+    }
+  } catch (e) {
+    log('Watchdog tick failed:', e.message);
+  }
+}, HEALTH_CHECK_MS);
+
 // Community-totals flush. Disabled by default; turns on via
 // `claude-rpc community on`. Best-effort — flushCommunity swallows every
 // failure mode, so a flaky endpoint or no network just means the deltas

package/src/default-config.js

@@ -21,6 +21,12 @@ export const DEFAULT_CONFIG = {
   // when Claude isn't open, the Discord presence should disappear quickly.
   // The SessionEnd hook short-circuits this — see hook.js + format.applyIdle.
   staleSessionMin: 5,
+  // When the Claude Code session is still open but its transcript has gone
+  // quiet (you paused, stepped away briefly), show 'idle' rather than
+  // clearing the card. Only an authoritative SessionEnd or the full
+  // staleSessionMin dormancy window drops to stale. Set false to restore the
+  // old behavior (clear ~90-120s after the last transcript write).
+  idleWhenOpen: 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,
@@ -119,7 +125,7 @@ export const DEFAULT_CONFIG = {
     },
 
     buttons: [
-      { label: "Claude Code", url: "https://claude.com/claude-code" },
+      { label: "Claude Code", url: "https://github.com/rar-file/claude-rpc" },
     ],
   },
   statusIcons: {

package/src/format.js

@@ -682,6 +682,12 @@ 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;
+  // When the Claude Code session is still open (no authoritative SessionEnd)
+  // but its transcript has gone quiet, prefer 'idle' over clearing the card.
+  // Only an explicit close (claudeClosed) or the staleMs dormancy backstop
+  // drops us to stale. Default on; set idleWhenOpen:false to restore the old
+  // aggressive ~90-120s clear when no transcript is being written.
+  const idleWhenOpen = cfg.idleWhenOpen !== false;
 
   // Authoritative close signal from the SessionEnd hook — trust it instead
   // of waiting on staleSessionMin. Any other hook clears the flag, so a
@@ -730,24 +736,26 @@ export function applyIdle(state, cfg = {}) {
 
   // Local state is fresh.
   if (state.status === 'idle') {
-    // Fast-path stale: if there are NO transcripts being written anywhere
-    // on disk, Claude Code isn't running. SessionEnd may not have fired
-    // (force-quit, OS sleep, crash). Going stale here clears Discord
-    // within ~90-120s of close instead of waiting the full staleMs (5min)
-    // — keeps the user's cwd off the card when they're away from their
-    // machine. The 5min legacy fallback below still catches the case
-    // where transcript mtime is fresh but the hook channel is silent.
-    if (liveSessions.length === 0) return staleWipe(state);
+    // No transcripts being written anywhere on disk — Claude Code may have
+    // closed without a SessionEnd hook (force-quit, OS sleep, crash). With
+    // idleWhenOpen (default) we keep showing 'idle': the session hasn't been
+    // authoritatively closed and the staleMs dormancy backstop above will
+    // still clear it if Claude is truly gone. Set idleWhenOpen:false to go
+    // straight to stale here — clears Discord ~90-120s after the last write,
+    // at the cost of dropping the card whenever you pause for a couple
+    // minutes with the session still open.
+    if (liveSessions.length === 0 && !idleWhenOpen) return staleWipe(state);
     return state;
   }
   if (ageMs > idleMs) {
     // Hook channel is quiet, but a live transcript was modified recently?
     // Keep "working" instead of dropping to "idle".
     if (liveAgeMs <= idleMs) return state;
-    // Hooks quiet AND no live transcripts → Claude is closed, not paused.
-    // Skip idle, go straight to stale. Same privacy reasoning as the
-    // idle-state fast-path above.
-    if (liveSessions.length === 0) return staleWipe(state);
+    // Hooks quiet AND no live transcripts. With idleWhenOpen (default) the
+    // session is treated as open-but-paused and drops to idle; the staleMs
+    // backstop above clears it if Claude is actually gone. Set
+    // idleWhenOpen:false to go straight to stale here (old behavior).
+    if (liveSessions.length === 0 && !idleWhenOpen) 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/version.js

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