thinkpool-pair 0.6.16 → 0.6.18

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).
@@ -578,16 +587,27 @@ channel
       s.log.push(evt); if (s.log.length > STRUCTURED_LOG_MAX) s.log.shift()
       bcast('code-event', { term: payload.term, evt })
     }
-    // Most slash commands (/compact, /clear, …) are processed by the SDK when
-    // sent as a turn. Two need special handling:
-    //  • /model <name> is disabled headless → route to the setModel control.
-    //  • /clear also wipes the on-screen transcript (parity with the CLI).
+    // Session controls (/model, /clear) are NOT agent turns — they change the
+    // shared session config. Emitting a `you` line for them strands the reader's
+    // inferred "working…" state (no turn → no result to clear it; the old bug).
+    // Instead announce a ◆ control line both readers see. /compact + any other
+    // slash still flow through as a real, self-terminating turn.
+    const ctlLine = (ctlText) => {
+      const evt = { kind: 'control', text: ctlText, by: payload.by, cid: payload.cid }
+      s.log.push(evt); if (s.log.length > STRUCTURED_LOG_MAX) s.log.shift()
+      bcast('code-event', { term: payload.term, evt })
+    }
     const mm = text.match(/^\/model\b\s*(\S+)?/)
-    if (mm) { echoYou(); if (mm[1]) s.session.setModel(mm[1]); else s.session.listModels(); return }
+    if (mm) {
+      if (mm[1]) { s.session.setModel(mm[1]); ctlLine(`switched model → ${mm[1]}`) }
+      else { ctlLine('use /model <name> to switch — e.g. opus, sonnet, haiku') }
+      return
+    }
     if (/^\/clear\s*$/.test(text)) {
-      echoYou(); s.session.sendTurn(text)
+      s.session.sendTurn(text)
       s.log = []; bcast('code-event', { term: payload.term, evt: { kind: 'clear' } })
       flushSession(room, payload.term, { sessionId: s.session?.sessionId || null, log: [] })
+      ctlLine('context cleared. You can continue with these answers in mind.')
       return
     }
     s.session.sendTurn(text)
@@ -652,6 +672,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.6.16",
+  "version": "0.6.18",
   "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) {