claude-rpc 0.7.4 → 0.8.1

package/package.json

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

@@ -7,6 +7,7 @@ import { scan, readAggregate, findLiveSessions, readSessionTokens } from './scan
 import { detectGithubUrl } from './git.js';
 import { applyPrivacy } from './privacy.js';
 import { loadConfig } from './config.js';
+import { migrateConfig } from './install.js';
 import { CONFIG_PATH, STATE_PATH, PID_PATH, LOG_PATH, STATE_DIR, AGGREGATE_PATH } from './paths.js';
 
 if (!existsSync(STATE_DIR)) mkdirSync(STATE_DIR, { recursive: true });
@@ -51,6 +52,20 @@ function loadConfigWithLog() {
   return loadConfig({ onError: (msg) => log(msg) });
 }
 
+// Bring an existing config.json up to date with the current defaults before
+// we load it. This is how upgrades reach users who just `npm update` + restart
+// the daemon without re-running `claude-rpc setup` — e.g. the v0.8.1 button-URL
+// move. Idempotent: only writes when something actually changes, so steady-state
+// restarts are a no-op and can't loop the config watcher. Best-effort — a
+// migration failure must never stop the daemon from starting.
+try {
+  if (migrateConfig({ silent: true })) {
+    log('config.json migrated to current defaults on startup');
+  }
+} catch (e) {
+  log('startup config migration failed (continuing):', e?.message || String(e));
+}
+
 let config = loadConfigWithLog();
 let aggregate = readAggregate() || null;
 let liveSessions = [];
@@ -282,9 +297,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 +493,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/install.js

@@ -235,12 +235,12 @@ export function seedConfig() {
 // without clobbering the user's customizations. Anything the user already
 // has — including a pre-existing byStatus, custom rotation array, custom
 // appName etc. — is left untouched.
-export function migrateConfig() {
+export function migrateConfig({ silent = false } = {}) {
   if (!existsSync(CONFIG_PATH)) return false;
   let cfg;
   try { cfg = JSON.parse(readFileSync(CONFIG_PATH, 'utf8')); }
   catch (e) {
-    console.warn(`  ! could not read config for migration: ${e.message}`);
+    if (!silent) console.warn(`  ! could not read config for migration: ${e.message}`);
     return false;
   }
   if (!cfg || typeof cfg !== 'object') return false;
@@ -300,13 +300,31 @@ export function migrateConfig() {
     added.push('community (preserved-off)');
   }
 
+  // v0.8.1: the default presence button moved from the Claude Code website
+  // to the project repo. Existing configs carry their own `buttons` array,
+  // which fully REPLACES the default (arrays don't deep-merge) — so the new
+  // default never reaches upgraders just by bumping the package. Rewrite
+  // ONLY a button still pointing at the verbatim old default URL; anything a
+  // user has customized (label or url) is left untouched.
+  const OLD_BTN_URL = 'https://claude.com/claude-code';
+  const NEW_BTN_URL = DEFAULT_CONFIG.presence?.buttons?.[0]?.url;
+  if (NEW_BTN_URL && Array.isArray(cfg.presence?.buttons)) {
+    let changed = false;
+    for (const b of cfg.presence.buttons) {
+      if (b && b.url === OLD_BTN_URL) { b.url = NEW_BTN_URL; changed = true; }
+    }
+    if (changed) added.push('presence.buttons[].url → repo');
+  }
+
   if (added.length === 0) {
-    console.log(`  config up to date → ${CONFIG_PATH}`);
+    if (!silent) console.log(`  config up to date → ${CONFIG_PATH}`);
     return false;
   }
   writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
-  console.log(`  config migrated  → ${CONFIG_PATH}`);
-  console.log(`    added: ${added.join(', ')}`);
+  if (!silent) {
+    console.log(`  config migrated  → ${CONFIG_PATH}`);
+    console.log(`    added: ${added.join(', ')}`);
+  }
   return true;
 }
 

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