claude-rpc 0.13.5 → 0.13.7

package/package.json

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

@@ -370,7 +370,9 @@ async function pushPresence() {
 // 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;
+  // ETIMEDOUT: request() now deadlines nonce replies — a half-open pipe that
+  // acks writes but never answers is a dead transport, so reconnect.
+  if (['EPIPE', 'ECONNRESET', 'ENOENT', 'ECONNREFUSED', 'ETIMEDOUT', '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);
 }

package/src/discord-ipc.js

@@ -228,7 +228,11 @@ export class Client extends EventEmitter {
   }
 
   // Send a command frame and resolve when the nonce-matched reply arrives.
-  request(cmd, args) {
+  // Times out after 10s: on a half-open pipe Discord can ack the socket write
+  // but never send the nonce reply, and without a deadline that await would
+  // hang forever — freezing the daemon's presence on a stale frame, with the
+  // watchdog blind because `connected` still reads true.
+  request(cmd, args, timeoutMs = 10_000) {
     return new Promise((resolve, reject) => {
       if (!this.socket) {
         const err = new Error('Not connected');
@@ -237,7 +241,14 @@ export class Client extends EventEmitter {
         return;
       }
       const nonce = randomUUID();
-      this._pending.set(nonce, { resolve, reject });
+      const timer = setTimeout(() => {
+        this._pending.delete(nonce);
+        const err = new Error(`No reply to ${cmd} within ${timeoutMs}ms`);
+        err.code = 'ETIMEDOUT';
+        reject(err);
+      }, timeoutMs);
+      if (timer.unref) timer.unref();
+      this._pending.set(nonce, { resolve, reject, timer });
       this._send(OP_FRAME, { cmd, args, nonce });
     });
   }
@@ -272,7 +283,8 @@ export class Client extends EventEmitter {
 
     // Nonce-matched response to a request() (e.g. SET_ACTIVITY).
     if (msg.nonce && this._pending.has(msg.nonce)) {
-      const { resolve, reject } = this._pending.get(msg.nonce);
+      const { resolve, reject, timer } = this._pending.get(msg.nonce);
+      clearTimeout(timer);
       this._pending.delete(msg.nonce);
       if (msg.evt === 'ERROR') {
         const err = new Error(msg.data?.message || 'Discord RPC error');
@@ -297,7 +309,8 @@ export class Client extends EventEmitter {
   _onClose(reason) {
     const wasConnected = this._connected || !!this.socket;
     // Fail any in-flight requests so awaiters don't hang forever.
-    for (const { reject } of this._pending.values()) {
+    for (const { reject, timer } of this._pending.values()) {
+      clearTimeout(timer);
       const err = new Error(typeof reason === 'string' ? reason : 'Connection closed');
       err.code = 'ECONNRESET';
       reject(err);
@@ -329,6 +342,15 @@ export class Client extends EventEmitter {
     // Best-effort close; don't emit 'disconnected' on an explicit teardown
     // (the daemon calls destroy() itself and manages its own reconnect).
     this._readyResolve = this._readyReject = null;
+    // Reject in-flight requests (mirrors _onClose) — a pushPresence parked on
+    // `await setActivity` when the watchdog tears the client down must settle,
+    // not leak as a forever-pending promise.
+    for (const { reject, timer } of this._pending.values()) {
+      clearTimeout(timer);
+      const err = new Error('Client destroyed');
+      err.code = 'ECONNRESET';
+      reject(err);
+    }
     this._pending.clear();
     this._teardownSocket();
     this._connected = false;

package/src/server/assets/dashboard.client.js

@@ -30,6 +30,12 @@
   let churnSeries = [];   // [{ d: Date, add, rem }] — for the churn-sparkline tooltip
 
   // ── Utilities ───────────────────────────────────────────
+  // Escape before any innerHTML interpolation: project/file/command/model
+  // names come from the aggregate, i.e. ultimately from directory and file
+  // names on disk — a repo named `<img onerror=…>` must render, not run.
+  const esc = (s) => String(s).replace(/[&<>"']/g, (c) => (
+    { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]
+  ));
   const fmtH = (ms) => {
     if (!ms) return '0h';
     const h = ms / 3_600_000;
@@ -232,10 +238,10 @@
       if (r.onClick) tr.classList.add('clickable');
       const ico = r.color ? '<span class="ico" style="background:' + r.color + '"></span>' : '';
       const nameHtml = opts.mono
-        ? '<code style="font-family: JetBrains Mono, monospace; font-size: 12px;">' + ico + r.name + '</code>'
-        : ico + r.name;
+        ? '<code style="font-family: JetBrains Mono, monospace; font-size: 12px;">' + ico + esc(r.name) + '</code>'
+        : ico + esc(r.name);
       tr.innerHTML = '<td class="name">' + nameHtml + '</td>' +
-                     '<td class="val">' + r.val + (r.unit ? '<span class="u">' + r.unit + '</span>' : '') + '</td>';
+                     '<td class="val">' + esc(r.val) + (r.unit ? '<span class="u">' + esc(r.unit) + '</span>' : '') + '</td>';
       if (r.onClick) tr.addEventListener('click', r.onClick);
       tbl.appendChild(tr);
     });
@@ -276,7 +282,7 @@
       const w = Math.max(2, (cost / total) * 100);
       const row = document.createElement('div');
       row.className = 'cost-bar';
-      row.innerHTML = '<span class="name">' + model + '</span>' +
+      row.innerHTML = '<span class="name">' + esc(model) + '</span>' +
         '<span class="track"><span class="fill" style="width:' + w.toFixed(0) + '%"></span></span>' +
         '<span class="val">' + fmtCost(cost) + '</span>';
       bars.appendChild(row);
@@ -303,7 +309,7 @@
       const row = document.createElement('div');
       row.className = 'row';
       row.innerHTML = '<span class="swatch" style="background:' + (LANGS[name] || '#888') + '"></span>' +
-        '<span class="name">' + name + '</span>' +
+        '<span class="name">' + esc(name) + '</span>' +
         '<span class="val">' + fmtN(v.edits) + ' edits · ' + fmtN(v.files) + ' files</span>';
       list.appendChild(row);
     }
@@ -337,7 +343,7 @@
       const isCurrent = i === onAir;
       li.className = isCurrent ? 'current' : f.passes ? 'live' : 'skip';
       const summary = f.passes ? ((f.details || '—') + (f.state ? ' · ' + f.state : '')) : (f.details || '—');
-      li.innerHTML = '<span class="pip"></span><span class="frame-text">' + summary + '</span>';
+      li.innerHTML = '<span class="pip"></span><span class="frame-text">' + esc(summary) + '</span>';
       ul.appendChild(li);
     });
   }

package/src/server/index.js

@@ -30,7 +30,20 @@ function parseUrl(rawUrl) {
   return { path: url.pathname, query: Object.fromEntries(url.searchParams) };
 }
 
+// Loopback-only Host allowlist. Binding to 127.0.0.1 blocks the LAN, but not
+// DNS rebinding: a malicious page can point its own hostname at 127.0.0.1 and
+// become "same-origin" with this server, then read /api/export.json. Rejecting
+// non-local Host headers closes that — browsers always send the page's host.
+function isLocalHost(host) {
+  const h = String(host || '').replace(/:\d+$/, '').replace(/^\[|\]$/g, '').toLowerCase();
+  return h === 'localhost' || h === '127.0.0.1' || h === '::1';
+}
+
 const server = createServer((req, res) => {
+  if (!isLocalHost(req.headers.host)) {
+    res.writeHead(403, JSON_HEADERS).end(JSON.stringify({ error: 'forbidden' }));
+    return;
+  }
   const { path, query } = parseUrl(req.url);
   const key = `${req.method} ${path}`;
 

package/src/state.js

@@ -8,6 +8,7 @@ import {
   closeSync,
   unlinkSync,
   statSync,
+  fstatSync,
 } from 'node:fs';
 import { basename } from 'node:path';
 import { STATE_PATH, STATE_DIR } from './paths.js';
@@ -110,11 +111,24 @@ function acquireLock() {
 
 function releaseLock(fd) {
   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
+  // path (unlink + fresh 'wx' create); deleting that by path would collapse
+  // mutual exclusion for a third writer. Inode equality proves ownership.
+  let ours;
+  try {
+    const a = fstatSync(fd);
+    const b = statSync(LOCK_PATH);
+    ours = a.ino === b.ino && a.dev === b.dev;
+  } catch {
+    ours = false; // lock already gone — nothing to unlink
+  }
   try {
     closeSync(fd);
   } catch {
     /* already closed */
   }
+  if (!ours) return;
   try {
     unlinkSync(LOCK_PATH);
   } catch {

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