thinkpool-pair 0.6.15 → 0.6.17

package/README.md

@@ -58,19 +58,29 @@ tunnel. So a cloud VM, container, devcontainer, or remote dev box can stream its
 Claude Code into the room exactly like a laptop. Run the same command there:
 
 ```bash
-export ANTHROPIC_API_KEY=sk-ant-...          # headless auth (no Keychain login)
+export ANTHROPIC_API_KEY=sk-ant-...                  # headless auth (no Keychain login)
 cd /path/to/your/repo
-npx thinkpool-pair <ROOM> -- claude          # structured Claude, no TTY needed
+npx thinkpool-pair@latest <ROOM> -- claude           # structured Claude, no TTY needed
 ```
 
 - **Auth**: set `ANTHROPIC_API_KEY` (or `CLAUDE_CODE_OAUTH_TOKEN`) in the box's
   env — the Agent SDK reads it automatically. The structured path runs the SDK's
   bundled `claude`, so you don't need Claude Code separately installed.
+- **Use `@latest`**: a bare `npx thinkpool-pair` reuses npx's local cache and can
+  run a stale version across restarts. `@latest` (and the service below) always
+  re-resolve the newest publish.
 - **No TTY required**: the agent picker auto-selects and raw-mode is skipped when
   there's no terminal, so it runs fine under CI / a service / `nohup`.
-- **Always-on**: `npx thinkpool-pair install-service <ROOM> -- claude` installs a
-  systemd `--user` unit (auto-restart + boot-persistent + auto-update). On a
-  server, also run `loginctl enable-linger $USER` so it survives logout.
+- **Always-on + auto-update**: `npx thinkpool-pair@latest install-service <ROOM> -- claude`
+  installs a systemd `--user` unit (auto-restart + boot-persistent). The bridge
+  polls npm for new publishes and **self-restarts at the next idle moment** into
+  the new version — the structured session resumes, so an away/unattended box
+  upgrades itself with nobody losing their place. On a server, also run
+  `loginctl enable-linger $USER` so it survives logout.
+  Tune with `THINKPOOL_PAIR_UPDATE_INTERVAL` (poll seconds, default 1800) and
+  `THINKPOOL_PAIR_UPDATE_IDLE` (idle seconds before restart, default 90). Live
+  auto-update applies to the launchd/systemd service tiers; bare `--supervise`
+  respawns the same version, so it updates only on the next manual/boot restart.
 - **Security**: anyone with the room code can drive the agent (shell-trust by
   design) — on a server that's a real shell, so treat the room code like a secret.
 

package/bridge.mjs

@@ -260,7 +260,14 @@ let shuttingDown = false
 // straight into the host's ATTACHED terminal, shredding the TUI
 // (2026-06-11). Same delivery, explicit path, no warning: httpSend when
 // the socket is down. Loss on total offline is fine — scrollback replays.
+// Activity clock — the most recent moment the room was doing something (agent
+// output or a human driving). Read by the auto-update poll so an update restart
+// only happens when idle, never mid-turn.
+let lastActivity = Date.now()
+const markActivity = () => { lastActivity = Date.now() }
+
 const bcast = (event, payload) => {
+  if (event === 'pty-out' || event === 'code-event') lastActivity = Date.now()
   try {
     if (channel.channelAdapter?.canPush?.() ?? true) {
       channel.send({ type: 'broadcast', event, payload })
@@ -486,6 +493,7 @@ let brokenSince = Date.now()
 channel
   .on('broadcast', { event: 'pty-in' }, ({ payload }) => {
     if (!payload?.data) return
+    markActivity()
     const t = terms.get(payload.term) || (payload.term == null && attachedId ? terms.get(attachedId) : null)
     if (t) t.term.write(payload.data)
   })
@@ -569,6 +577,7 @@ channel
   .on('broadcast', { event: 'code-turn' }, ({ payload }) => {
     const s = payload?.term && sessions.get(payload.term)
     if (!s || payload.text == null) return
+    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).
@@ -652,6 +661,61 @@ setInterval(() => {
   }
 }, 15000).unref()
 
+// ── auto-update (OS-service tier only) ─────────────────────────────────
+// launchd (KeepAlive) and systemd (Restart=always) re-run
+// `npx -y thinkpool-pair@latest` on every (re)start, so a clean exit here makes
+// the supervisor pull the newest publish; session-store then resumes the
+// session, so the update is invisible to both people in the room. Gated to
+// THINKPOOL_PAIR_AUTOUPDATE=1 (set by the service installer) because under bare
+// `--supervise` the supervisor respawns the SAME version (exit 0 there just
+// stops it) — self-exiting would loop or kill the bridge, not update it.
+//   THINKPOOL_PAIR_UPDATE_INTERVAL  registry poll seconds (default 1800)
+//   THINKPOOL_PAIR_UPDATE_IDLE      idle seconds before a restart (default 90)
+if (process.env.THINKPOOL_PAIR_AUTOUPDATE === '1' && VERSION) {
+  const POLL_MS = Math.max(60, parseInt(process.env.THINKPOOL_PAIR_UPDATE_INTERVAL, 10) || 1800) * 1000
+  const IDLE_MS = Math.max(10, parseInt(process.env.THINKPOOL_PAIR_UPDATE_IDLE, 10) || 90) * 1000
+  let pendingUpdate = null   // the newer version string, once seen
+
+  const isIdle = () => {
+    if (Date.now() - lastActivity < IDLE_MS) return false
+    for (const t of terms.values()) if (t.buf) return false   // bytes mid-flush
+    return true
+  }
+  // Newer? Compare the numeric x.y.z core; ignore prerelease tails to stay safe.
+  const isNewer = (latest, cur) => {
+    const core = (v) => String(v).split('-')[0].split('.').map((n) => parseInt(n, 10) || 0)
+    const a = core(latest), b = core(cur)
+    for (let i = 0; i < 3; i++) { if ((a[i] || 0) > (b[i] || 0)) return true; if ((a[i] || 0) < (b[i] || 0)) return false }
+    return false
+  }
+  const fetchLatest = async () => {
+    const ctrl = new AbortController()
+    const to = setTimeout(() => ctrl.abort(), 8000)
+    try {
+      const r = await fetch('https://registry.npmjs.org/thinkpool-pair/latest', { signal: ctrl.signal, headers: { accept: 'application/json' } })
+      if (!r.ok) return null
+      const j = await r.json()
+      return typeof j?.version === 'string' ? j.version : null
+    } catch { return null } finally { clearTimeout(to) }
+  }
+  const applyIfIdle = () => {
+    if (!pendingUpdate || !isIdle()) return
+    process.stderr.write(`\n  ◆ thinkpool-pair ${pendingUpdate} ready (running ${VERSION}) — restarting to update; the session resumes.\n`)
+    process.exit(0)   // service restarts with @latest; session-store resumes
+  }
+  const check = async () => {
+    const latest = await fetchLatest()
+    if (latest && isNewer(latest, VERSION)) {
+      if (!pendingUpdate) process.stderr.write(`\n  ◆ thinkpool-pair ${latest} published — will restart at the next idle moment.\n`)
+      pendingUpdate = latest
+      applyIfIdle()
+    }
+  }
+  setInterval(check, POLL_MS).unref()        // poll the registry
+  setInterval(applyIfIdle, 15000).unref()    // once pending, land it as soon as idle
+  setTimeout(check, 60000).unref()           // first check after the session settles
+}
+
 function shutdown() {
   if (shuttingDown) return
   shuttingDown = true

package/claude-session.mjs

@@ -123,6 +123,7 @@ export function startClaudeSession({ cwd, model, resume, onEvent, requestPermiss
   let mode = 'default'    // mirrors Claude Code's ⇧⇥ cycle
   const alwaysAllow = new Set()  // tool:risk signatures the user chose "don't ask again" for
   const toolStart = new Map()     // tool_use id → start time, for the duration badge
+  let effort = null               // active reasoning effort for the turn (from the hook input)
 
   const emit = (evt) => { try { onEvent?.(evt) } catch { /* never let a consumer throw into the loop */ } }
 
@@ -133,6 +134,11 @@ export function startClaudeSession({ cwd, model, resume, onEvent, requestPermiss
   const preTool = async (hookInput) => {
     const toolName = hookInput.tool_name
     const toolInput = hookInput.tool_input
+    // The hook input carries the turn's active reasoning effort (post any
+    // model downgrade) — the real signal for "thinking with <X> effort".
+    // Surface it to the room when it changes; absent on models without effort.
+    const lvl = hookInput.effort?.level
+    if (lvl && lvl !== effort) { effort = lvl; emit({ kind: 'effort', level: effort }) }
     // ── Plan approval — ExitPlanMode is how the agent presents its plan in
     // plan mode. Render a dedicated plan card (not the generic perm card) with
     // three outcomes: run (exit → default), accept (exit → acceptEdits), keep
@@ -207,6 +213,10 @@ export function startClaudeSession({ cwd, model, resume, onEvent, requestPermiss
     abortController: ac,
     permissionMode: 'default',
     hooks: { PreToolUse: [{ hooks: [preTool] }] },
+    // Needed for live thinking-token progress (SDKThinkingTokensMessage) to
+    // flow during a turn. We ignore the fine-grained stream_event partials in
+    // the loop; only the coarse thinking_tokens system message is surfaced.
+    includePartialMessages: true,
   }
   if (cwd) opts.cwd = cwd
   if (model) opts.model = model
@@ -219,6 +229,13 @@ export function startClaudeSession({ cwd, model, resume, onEvent, requestPermiss
         if (closed) break
         switch (m.type) {
           case 'system':
+            // Live thinking-token progress — the running estimate while the
+            // model reasons, surfaced as the indicator's ↓ N tokens. Coarse,
+            // emitted during extended thinking; not a per-token stream.
+            if (m.subtype === 'thinking_tokens') {
+              emit({ kind: 'thinking_tokens', tokens: m.estimated_tokens, delta: m.estimated_tokens_delta })
+              break
+            }
             if (m.session_id) sessionId = m.session_id
             emit({ kind: 'system', sessionId, model: m.model || model || null })
             break

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.6.15",
+  "version": "0.6.17",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {

package/service.mjs

@@ -51,7 +51,7 @@ export function buildArtifact(platform, { room, cmdArgs = [] }) {
   <key>WorkingDirectory</key><string>${xml(cwd)}</string>
   <key>StandardOutPath</key><string>${xml(log)}</string>
   <key>StandardErrorPath</key><string>${xml(log)}</string>
-  <key>EnvironmentVariables</key><dict><key>PATH</key><string>${xml(process.env.PATH || '')}</string></dict>
+  <key>EnvironmentVariables</key><dict><key>PATH</key><string>${xml(process.env.PATH || '')}</string><key>THINKPOOL_PAIR_AUTOUPDATE</key><string>1</string></dict>
 </dict></plist>\n`
     return { file, content, logDir, post: [`launchctl unload "${file}" 2>/dev/null; launchctl load "${file}"`], note: 'Loaded as a LaunchAgent — starts at login, restarts on crash.' }
   }
@@ -69,6 +69,7 @@ Restart=always
 RestartSec=2
 WorkingDirectory=${cwd}
 Environment=PATH=${process.env.PATH || ''}
+Environment=THINKPOOL_PAIR_AUTOUPDATE=1
 StandardOutput=append:${log}
 StandardError=append:${log}
 
@@ -101,7 +102,10 @@ export function installService(room, cmdArgs = []) {
   for (const cmd of a.post) {
     try { execSync(cmd, { stdio: 'inherit' }) } catch (e) { process.stderr.write(`  ⚠ "${cmd}" failed: ${e.message}\n`) }
   }
-  process.stderr.write(`  ◆ ${a.note}\n  ◆ tracks thinkpool-pair@latest — new versions apply on next restart, no re-install.\n  ◆ logs: ${path.join(a.logDir, `${room}.log`)}\n  ◆ remove with: thinkpool-pair uninstall-service ${room}\n\n`)
+  const autoUpdate = process.platform === 'win32'
+    ? 'tracks thinkpool-pair@latest — new versions apply on next login/restart.'
+    : 'tracks thinkpool-pair@latest — checks for new versions and self-restarts at the next idle moment (session resumes), no re-install.'
+  process.stderr.write(`  ◆ ${a.note}\n  ◆ ${autoUpdate}\n  ◆ logs: ${path.join(a.logDir, `${room}.log`)}\n  ◆ remove with: thinkpool-pair uninstall-service ${room}\n\n`)
 }
 
 export function uninstallService(room) {