thinkpool-pair 0.7.59 → 0.7.61

package/account.mjs

@@ -15,6 +15,7 @@ import { createClient } from '@supabase/supabase-js'
 import os from 'node:os'
 import { saveAuth, loadAuth, loadDirs, bindDir } from './auth-store.mjs'
 import { isSafeToRestart } from './update-gate.mjs'
+import { makeThrottledTrack } from './presence.mjs'
 
 const VERSION = (() => { try { return JSON.parse(fs.readFileSync(new URL('./package.json', import.meta.url), 'utf8')).version } catch { return null } })()
 
@@ -223,6 +224,7 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
   // codes + version) on a per-account channel; the dashboard subscribes read-only.
   const machine = os.hostname().replace(/\.local$/, '')
   const acct = sb.channel(`tpacct:${session.user.id}`, { config: { presence: { key: machine }, broadcast: { self: false } } })
+  let restarting = false   // set by the "restart" broadcast → stop() exits non-zero so a supervisor respawns us
   // Dashboard "Disconnect" → broadcast shutdown → clean exit (presence leaves, bar flips live).
   // If we're the auto-restarting background service (launchd KeepAlive / systemd
   // Restart=always sets AUTOUPDATE=1), a bare exit would be respawned ~2s later —
@@ -244,7 +246,26 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
     }
     process.kill(process.pid, 'SIGTERM')
   })
-  const pushPresence = () => { try { acct.track({ name: machine, version: VERSION, rooms: [...children.keys()], ts: Date.now() }) } catch { /* noop */ } }
+  // Dashboard "Restart" → broadcast restart → graceful stop with a NON-ZERO exit so
+  // EVERY supervisor respawns us: launchd KeepAlive / systemd Restart=always respawn
+  // regardless of exit code, and the bridge.mjs --supervise wrappers (cmux tier, room
+  // tier) respawn on non-zero but treat 0 as a clean stop. Children persist + resume
+  // their sessions (session-store), so the bounce is invisible in-room. Unlike shutdown
+  // we do NOT uninstall the service. A plain foreground bridge has no supervisor, so it
+  // just stops — restart is meaningful for the always-on bridge. Old bridges (pre-0.7.60)
+  // don't subscribe to this event, so the dashboard button is a harmless no-op there.
+  acct.on('broadcast', { event: 'restart' }, () => {
+    process.stderr.write('\n  ◇ restart requested from the dashboard — bouncing bridge (sessions resume).\n')
+    restarting = true
+    setTimeout(() => { try { releaseSingleton() } catch { /* noop */ } process.exit(1) }, 2500)
+    process.kill(process.pid, 'SIGTERM')
+  })
+  // Throttled so a realtime reconnect storm can't machine-gun track() into the
+  // per-client presence rate limit (ClientPresenceRateLimitReached → channel closed
+  // → dashboard reads "no bridge" while sessions run; 2026-06-17/-22/-24). The 15s
+  // tick + token-refresh callers are unaffected (their interval exceeds the window).
+  const trackPresence = makeThrottledTrack(acct, { minMs: 5000 })
+  const pushPresence = () => trackPresence({ name: machine, version: VERSION, rooms: [...children.keys()], ts: Date.now() })
   // Re-track on EVERY (re)subscribe, not just the first: a realtime reconnect
   // (network blip, or a token swap mid-flight) rejoins the channel and must
   // re-announce, or the dashboard would read "no bridge" until the next restart.
@@ -319,16 +340,19 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
   await tick()
   const iv = setInterval(tick, 15000)
   let stopping = false
+  // restart-vs-stop is the ONLY difference in exit code: a web "restart" sets this so
+  // we exit non-zero (every supervisor respawns); a normal stop/shutdown exits 0.
   const stop = (sig) => {
     if (stopping) return; stopping = true
+    const code = restarting ? 1 : 0
     clearInterval(iv)
     keepFresh.cancel()
     releaseSingleton()
     for (const c of children.values()) { try { c.kill(sig || 'SIGTERM') } catch { /* noop */ } }
     // Flush the presence LEAVE before exiting so the dashboard flips to
     // "not connected" in realtime (don't fire-and-forget the untrack).
-    ;(async () => { try { await acct.untrack() } catch { /* noop */ } try { await sb.removeChannel(acct) } catch { /* noop */ } process.exit(0) })()
-    setTimeout(() => process.exit(0), 1500)   // hard backstop if the flush hangs
+    ;(async () => { try { await acct.untrack() } catch { /* noop */ } try { await sb.removeChannel(acct) } catch { /* noop */ } process.exit(code) })()
+    setTimeout(() => process.exit(code), 1500)   // hard backstop if the flush hangs
   }
   for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) process.on(sig, () => stop(sig))
 

package/bridge.mjs

@@ -40,6 +40,7 @@ import { startClaudeSession } from './claude-session.mjs'
 import { turnInFlight } from './update-gate.mjs'
 import { saveSession, flushSession, deleteSession, loadAll, canResume, loadPtyId, savePtyId, loadNames, saveNames } from './session-store.mjs'
 import { stampEvent, makeSeqCounter, maxSeq, seqable } from './event-id.mjs'
+import { makeThrottledTrack } from './presence.mjs'
 
 // Public client creds (the same anon values the web app ships — safe to embed).
 // Override with TP_SUPABASE_URL / TP_SUPABASE_ANON if you ever need to.
@@ -476,6 +477,13 @@ const safeName = (n) => String(n || 'file').replace(/[^a-zA-Z0-9._-]/g, '_').sli
 const supabase = createClient(SUPABASE_URL, SUPABASE_ANON, {
   realtime: { params: { eventsPerSecond: 60 } },
 })
+// Throttled presence track() (presence.mjs) — a reconnect storm re-fires SUBSCRIBED and
+// the handler re-track()s; without throttle that spirals into the per-client presence
+// rate limit (ClientPresenceRateLimitReached). Lazy so it binds `channel` (the chain
+// result below) only on first call — always after the async subscribe callback, by which
+// point the const is assigned.
+let _presence = null
+const trackPresence = (payload) => { (_presence ||= makeThrottledTrack(channel, { minMs: 5000 }))(payload) }
 const channel = supabase.channel(`tpcode:${room}`, {
   config: { broadcast: { self: false }, presence: { key: `bridge:${name}` } },
 })
@@ -747,7 +755,7 @@ function printLocal(evt) {
     case 'you': return w(`${A.cyan}❯ ${evt.text}${A.rst}${evt.by ? ` ${A.dim}(${evt.by})${A.rst}` : ''}`)
     case 'chat': return w(`${A.dim}${evt.by}: ${evt.text}${A.rst}`)
     case 'whisper': return w(`${A.dim}// ${evt.by}: ${evt.text}${A.rst}`)
-    case 'pool': return w(evt.pending ? `${A.cyan}◌ pool synthesizing…${A.rst}` : `${A.cyan}◆ pool → ${evt.text}${A.rst}`)
+    case 'pool': return w(evt.pending ? `${A.cyan}◌ pool dispatching…${A.rst}` : `${A.cyan}◆ pool → ${evt.text}${A.rst}`)
     case 'note': return w(`${A.dim}— ${evt.text} —${A.rst}`)
     case 'clear': return w(`${A.dim}— context cleared —${A.rst}`)
     case 'usage': { const c = evt.ctx; return c ? w(`${A.dim}  ctx ${c.pct}% · ${Math.round(c.used / 1000)}k/${Math.round(c.max / 1000)}k${evt.costUsd != null ? ` · $${evt.costUsd.toFixed(3)}` : ''}${A.rst}`) : undefined }
@@ -1091,7 +1099,7 @@ channel
     markActivity()
     const text = String(payload.text)
     // Echo the turn so BOTH readers (and late joiners, via the log) show who
-    // said what — UNLESS silent (an @pool synthesis, which renders its own line).
+    // said what — UNLESS silent (an @pool fire, which renders its own line).
     const echoYou = () => {
       if (payload.silent) return
       // Display the clean body (web sends `body` when the agent `text` carries host
@@ -1181,7 +1189,7 @@ channel
   .subscribe(status => {
     if (status === 'SUBSCRIBED') {
       realtimeHealthy = true; brokenSince = 0
-      channel.track({ name, role: 'bridge' })
+      trackPresence({ name, role: 'bridge' })
       const startCmd = attachedCmd || autoAgent   // autoAgent: account-mode auto-open (headless)
       if (startCmd && !terms.size && !sessions.size) {
         // Claude + structured mode → Agent SDK session; everything else → PTY.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.59",
+  "version": "0.7.61",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -16,6 +16,7 @@
     "session-store.mjs",
     "service.mjs",
     "cmux.mjs",
+    "presence.mjs",
     "account.mjs",
     "auth-store.mjs",
     "provider.mjs",

package/presence.mjs

@@ -0,0 +1,51 @@
+/* ─────────────────────────────────────────────────────────────
+   presence.mjs — a throttled wrapper for Supabase Realtime presence
+   track(), shared by the account supervisor (account.mjs) and every
+   room bridge (bridge.mjs).
+
+   The bug it fixes: supabase-js auto-rejoins a dropped channel and
+   re-fires `SUBSCRIBED`; our subscribe handlers re-`track()` presence
+   on each one. With no throttle a SINGLE drop can spiral —
+     track() → trip the per-client presence rate limit
+            → server closes the channel → auto-rejoin → SUBSCRIBED
+            → track() → trip again → … forever
+   which the server logs as `ClientPresenceRateLimitReached:
+   :client_rate_limit_exceeded`. The supervisor stays alive and keeps
+   relaying sessions, but its presence never re-sticks, so the dashboard
+   reads "No bridge connected" while sessions plainly run (the
+   2026-06-17 / -22 / -24 recurrences).
+
+   makeThrottledTrack coalesces bursts to at most one track() per
+   window: the FIRST call fires immediately (presence appears fast),
+   any further calls inside the window collapse into a single trailing
+   fire with the latest payload. At minMs=5000 that's ≤0.2 track/s —
+   far under any presence rate limit — so a reconnect storm can never
+   trip it, while the steady-state callers (a 15s tick, a token refresh)
+   are unaffected (their interval already exceeds the window).
+   ───────────────────────────────────────────────────────────── */
+
+// channel: a supabase RealtimeChannel (stable across reconnects — supabase-js
+// rejoins the same object, so channel.track stays valid). Returns a function you
+// call with the presence payload anywhere you'd have called channel.track(payload).
+export function makeThrottledTrack(channel, { minMs = 5000 } = {}) {
+  let last = 0
+  let timer = null
+  let pending = null
+  const fire = () => {
+    timer = null
+    last = Date.now()
+    const payload = pending
+    pending = null
+    try { channel.track(payload) } catch { /* presence track is best-effort */ }
+  }
+  return (payload) => {
+    pending = payload
+    const since = Date.now() - last
+    if (since >= minMs) {
+      if (timer) { clearTimeout(timer) }
+      fire()                                   // leading edge — presence appears immediately
+    } else if (!timer) {
+      timer = setTimeout(fire, minMs - since)  // trailing edge — coalesce the burst
+    }
+  }
+}