thinkpool-pair 0.7.77 → 0.7.79

package/bridge.mjs

@@ -32,7 +32,7 @@ import os from 'node:os'
 import fs from 'node:fs'
 import path from 'node:path'
 import readline from 'node:readline'
-import { spawn } from 'node:child_process'
+import { spawn, execSync } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 import { randomUUID } from 'node:crypto'
 import { createClient } from '@supabase/supabase-js'
@@ -213,12 +213,22 @@ if ((!argv[0] || argv[0] === 'setup') && process.stdin.isTTY) {
     installService: ({ room = null, agentCmd } = {}) => { svc.installService(room, agentCmd ? [agentCmd] : []) },
     uninstallService: ({ room = null } = {}) => { svc.uninstallService(room) },
     restartService: ({ room = null } = {}) => { svc.restartService(room) },
-    // "Restart & update the bridge" — re-pin the OS service to THIS launcher's version
-    // (you launched via @latest, so it's the newest publish) and restart: the service is
-    // reinstalled (rewrites the plist/unit to the new version and reloads). Pinned — no auto-roll.
+    // "Restart & update the bridge" — resolve the NEWEST PUBLISHED version from npm and
+    // re-pin the OS service to it (stale-proof: the rewritten launch wipes the npx cache
+    // each start so it can't re-serve an old build). We must NOT trust PKG_VERSION here:
+    // npx can run a STALE cached launcher, so this very menu may be an old version — that's
+    // the bug that left the bridge stuck on 0.7.75. `npm view` hits the registry live, so it
+    // updates correctly even from a stale launcher. Pinned to the resolved number — no auto-roll.
     restartUpdateService: ({ room = null } = {}) => {
-      process.stderr.write(`\n  ◆ updating the background service to v${PKG_VERSION} and restarting…\n`)
-      svc.installService(room, [])   // rewrites the plist/unit at this version + reloads = update + restart
+      let target = null
+      try { target = execSync('npm view thinkpool-pair version', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() } catch { /* offline / no npm */ }
+      if (!target) {
+        target = PKG_VERSION
+        process.stderr.write(`\n  ⚠ couldn't reach npm to resolve the newest version — re-pinning this launcher's v${PKG_VERSION} (stale-proof) and restarting…\n`)
+      } else {
+        process.stderr.write(`\n  ◆ updating the background service to v${target} (newest published) and restarting…\n`)
+      }
+      svc.installService(room, [], { version: target, staleProof: true })   // rewrites plist/unit at resolved version + reloads = update + restart
     },
     login: async () => { const { runLogin } = await import('./account.mjs'); await runLogin(SUPABASE_URL, SUPABASE_ANON, WEB_BASE) },
     // Provider config is NOT terminal — it writes provider.json and returns to the

package/claude-session.mjs

@@ -177,6 +177,21 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
   // the catch self-heals.
   const FORCE_STOP_MS = Math.max(STALL_MS * 3, parseInt(process.env.TP_FORCE_STOP_MS, 10) || 300000)
   let forceStopped = false
+  // Set while an interrupt is settling. q.interrupt() doesn't end the turn cleanly on this
+  // SDK — it surfaces a REDUNDANT pair of terminal results (subtype `aborted` AND
+  // `error_during_execution`) and re-inits the session. abort() emits the single canonical
+  // aborted boundary itself; this flag tells the result handler to swallow the SDK's extra
+  // teardown results so the web never sees a second turn-end. Without it, the web suppresses
+  // only the first (isAbortEcho) and the second buried the flushed steer — "Stop injects the
+  // queued message but nothing happens". Cleared by the first real (non-teardown) result.
+  // Verified: bridge/test-steer-after-abort.mjs (Maks 2026-06-26). The teardown results
+  // arrive async and can interleave with the NEXT turn (a late error_during_execution can
+  // land after the steer's own output), so the window is bounded by a timer rather than
+  // cleared on the next result — "all teardown has arrived" isn't observable. `success`
+  // results are never swallowed, so the flushed steer's completion always surfaces.
+  let interrupting = false
+  let interruptTimer = null
+  const INTERRUPT_SWALLOW_MS = 6000
   // ── Haiku suggestion fallback ──
   // Claude Code's own `prompt_suggestion` rarely fires in /code — the binary suppresses it
   // per-turn (cache_cold when a turn's tokens > 10k, rate_limit when throttled, first turn).
@@ -504,6 +519,11 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
           }
           case 'result':
             if (m.session_id) sessionId = m.session_id
+            // Swallow the interrupt's redundant teardown results (see `interrupting` above):
+            // abort() already emitted the one canonical aborted boundary. `success` (and any
+            // non-teardown subtype) always emits; only the aborted/error_during_execution pair
+            // the interrupt churns out is dropped, and only inside the timer-bounded window.
+            if (interrupting && (m.subtype === 'aborted' || m.subtype === 'error_during_execution')) { turnActive = false; break }
             turnBaseOut = 0; curMsgOut = 0   // reset the live token count for the next turn
             turnActive = false               // turn settled → stall watchdog stands down
             restartCount = 0                 // a successful turn refills the auto-restart budget
@@ -590,6 +610,15 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
     // Graceful interrupt (Esc / Stop) — stops the current turn but keeps the
     // session alive for the next one. ac.abort() is teardown only (end()).
     async abort() {
+      // Swallow the SDK's redundant interrupt teardown (aborted + error_during_execution +
+      // re-init) — we emit the one canonical boundary below. Set BEFORE interrupt so the
+      // teardown results, which arrive async on the query loop, are caught; the timer bounds
+      // the window so a genuine later turn failure still surfaces.
+      if (turnActive) {
+        interrupting = true
+        clearTimeout(interruptTimer)
+        interruptTimer = setTimeout(() => { interrupting = false }, INTERRUPT_SWALLOW_MS)
+      }
       try { await q?.interrupt?.() } catch { /* noop */ }
       // interrupt() stops the turn but emits NO terminal message. Without one the
       // struct stream ends on a non-terminal event, so on resume the SDK treats the
@@ -599,7 +628,7 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
       // SDK already surfaced one for the interrupt. (restored from 0.7.49)
       if (turnActive) { turnActive = false; emit({ kind: 'result', subtype: 'aborted', sessionId }) }
     },
-    end() { closed = true; clearInterval(stallTimer); input.end(); try { ac.abort() } catch { /* noop */ } },
+    end() { closed = true; clearInterval(stallTimer); clearTimeout(interruptTimer); input.end(); try { ac.abort() } catch { /* noop */ } },
     get sessionId() { return sessionId },
     get mode() { return mode },
     get turnActive() { return turnActive },   // a turn is in flight (gates between-turns update restart — Slice 3 Contract #1)

package/launcher.mjs

@@ -18,6 +18,11 @@ import { execSync } from 'node:child_process'
 const HOME = os.homedir()
 const CFG_DIR = path.join(HOME, '.thinkpool-pair')
 
+// Version of THIS running launcher (read from the package it shipped with). Shown in the
+// header so the running build is visible — and so a stale npx cache is obvious at a glance
+// (header says 0.7.75 while npm @latest is 0.7.78 → time to "Restart & update the bridge").
+const VERSION = (() => { try { return JSON.parse(fs.readFileSync(new URL('./package.json', import.meta.url), 'utf8')).version } catch { return null } })()
+
 export const KNOWN_AGENTS = [
   { label: 'Claude Code', cmd: 'claude', resume: ['--continue'] },
   { label: 'Codex CLI',   cmd: 'codex' },
@@ -75,6 +80,7 @@ export function detectState() {
     agents: KNOWN_AGENTS.filter(a => onPath(a.cmd)),
     accountSvc: serviceLoaded(null),
     cwd: process.cwd(),
+    version: VERSION,
   }
 }
 
@@ -103,7 +109,7 @@ export async function runLauncher({ actions, io, state = detectState(), refresh
 
   const header = () => {
     io.print('')
-    io.print('  ' + C.dim('┌ ') + C.bold('thinkpool-pair') + C.dim(' ' + '─'.repeat(40)))
+    io.print('  ' + C.dim('┌ ') + C.bold('thinkpool-pair') + (state.version ? C.dim(` v${state.version}`) : '') + C.dim(' ' + '─'.repeat(state.version ? 40 - (` v${state.version}`).length : 40)))
     io.print(`  ${C.dim('│ account  ')} ${state.loggedIn ? C.green((state.email || 'linked') + ' ✓') : C.yellow('not linked')}`)
     io.print(`  ${C.dim('│ provider ')} ${state.provider}`)
     io.print(`  ${C.dim('│ agents   ')} ${state.agents.length ? state.agents.map(a => a.label).join(', ') : C.yellow('none on PATH')}`)

package/package.json

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

package/service.mjs

@@ -27,6 +27,14 @@ import { execSync } from 'node:child_process'
 const label = (room) => room ? `io.thinkpool.pair.${room.toLowerCase()}` : 'io.thinkpool.pair.account'
 const slug = (room) => room || 'account'
 const xml = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+const shq = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`
+// Stale-proof launch wrapper: wipe any cached thinkpool-pair in the npx store, then exec
+// the pinned package FRESH. Folds update-local-service.sh into the builder — without this a
+// deliberate "Restart & update" (or any KeepAlive restart) can re-serve a stale npx cache,
+// which is what left Max's account bridge stuck on 0.7.75 while @latest was 0.7.78.
+// `home` is the platform-correct, runtime-expanded home token ("$HOME" on darwin under
+// /bin/bash; "$$HOME" inside a systemd unit so systemd emits a literal $HOME to bash).
+const cacheWipe = (home) => `rm -rf ${home}/.npm/_npx/*/node_modules/thinkpool-pair 2>/dev/null`
 
 // The version installing the service. By DEFAULT the service is pinned to this exact
 // version (not @latest) so a future bad npm publish can't auto-roll to every machine's
@@ -46,7 +54,7 @@ function npxPath(platform) {
 
 // Pure artifact builder — returned shape is testable without side effects.
 // room falsy → ACCOUNT service (bare `thinkpool-pair`, auto-serves all sessions).
-export function buildArtifact(platform, { room = null, cmdArgs = [], autoUpdate = false } = {}) {
+export function buildArtifact(platform, { room = null, cmdArgs = [], autoUpdate = false, version = VERSION, staleProof = false } = {}) {
   const npx = npxPath(platform)
   const cwd = process.cwd()
   const id = slug(room)
@@ -58,14 +66,18 @@ export function buildArtifact(platform, { room = null, cmdArgs = [], autoUpdate
   // PINNED by default to `@${VERSION}` so a KeepAlive restart re-runs the SAME known-good
   // version — a bad publish can't auto-roll here. `autoUpdate` opts into `@latest` tracking
   // (and the in-process self-updater via THINKPOOL_PAIR_AUTOUPDATE below).
-  const verSpec = autoUpdate ? 'thinkpool-pair@latest' : `thinkpool-pair@${VERSION}`
+  const verSpec = autoUpdate ? 'thinkpool-pair@latest' : `thinkpool-pair@${version}`
   const pkgArgs = room ? ['-y', verSpec, room] : ['-y', verSpec]
   // In-process self-update (account.mjs / bridge.mjs) is gated on this env — only on when
   // the user explicitly opted into auto-update.
   const autoUpdateEnv = autoUpdate ? { THINKPOOL_PAIR_AUTOUPDATE: '1' } : {}
 
   if (platform === 'darwin') {
-    const args = [npx, ...pkgArgs, ...tail]   // launchd KeepAlive supervises
+    // launchd KeepAlive supervises. staleProof → wrap in a cache-wiping /bin/bash launch so
+    // every (re)start re-fetches the pinned version fresh (deliberate-update path).
+    const args = staleProof
+      ? ['/bin/bash', '-lc', `${cacheWipe('"$HOME"')}; exec ${[npx, ...pkgArgs, ...tail].map(shq).join(' ')}`]
+      : [npx, ...pkgArgs, ...tail]
     const file = path.join(os.homedir(), 'Library', 'LaunchAgents', `${label(room)}.plist`)
     const content = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -102,12 +114,17 @@ export function buildArtifact(platform, { room = null, cmdArgs = [], autoUpdate
   if (platform === 'linux') {
     const args = [npx, ...pkgArgs, ...tail]   // systemd Restart=always supervises
     const file = path.join(os.homedir(), '.config', 'systemd', 'user', `${label(room)}.service`)
+    // staleProof → cache-wiping /bin/bash launch (same intent as darwin). `$$HOME` so systemd
+    // emits a literal $HOME to bash rather than expanding it itself (empty + warning).
+    const execStart = staleProof
+      ? `/bin/bash -lc "${cacheWipe('$$HOME')}; exec ${[npx, ...pkgArgs, ...tail].join(' ')}"`
+      : args.map((a) => `'${a.replace(/'/g, "'\\''")}'`).join(' ')
     const content = `[Unit]
 Description=ThinkPool Code ${desc}
 After=network-online.target
 
 [Service]
-ExecStart=${args.map((a) => `'${a.replace(/'/g, "'\\''")}'`).join(' ')}
+ExecStart=${execStart}
 Restart=always
 RestartSec=2
 WorkingDirectory=${cwd}
@@ -138,8 +155,14 @@ WantedBy=default.target
   throw new Error(`unsupported platform: ${platform}`)
 }
 
-export function installService(room, cmdArgs = [], { autoUpdate = false } = {}) {
-  const a = buildArtifact(process.platform, { room, cmdArgs, autoUpdate })
+// staleProof defaults ON for every real install: even a FIRST install can be launched from
+// a stale npx cache (the launcher itself is npx-resolved), so without the cache-wiping
+// wrapper a fresh `install-service` could pin a stale build just like the update path did.
+// Pinning still holds (we pin a fixed version number) — staleProof only guarantees that
+// pinned version is fetched fresh on every (re)start. buildArtifact keeps staleProof=false
+// so its unit tests assert the pure pinned shape.
+export function installService(room, cmdArgs = [], { autoUpdate = false, version = VERSION, staleProof = true } = {}) {
+  const a = buildArtifact(process.platform, { room, cmdArgs, autoUpdate, version, staleProof })
   fs.mkdirSync(a.logDir, { recursive: true })
   fs.mkdirSync(path.dirname(a.file), { recursive: true })
   fs.writeFileSync(a.file, a.content)
@@ -155,7 +178,7 @@ export function installService(room, cmdArgs = [], { autoUpdate = false } = {})
     ? (process.platform === 'win32'
         ? 'auto-update ON: a new thinkpool-pair@latest applies on the next login/restart (Windows has no in-process self-update).'
         : `auto-update ON: checks npm ~every 30 min and restarts to apply a new @latest once sessions are idle (≥${idleSecs}s quiet; they resume in place).`)
-    : `PINNED to ${VERSION} (safe default — a bad publish can't auto-roll to this always-on bridge). To update: re-run install-service from a newer thinkpool-pair. Pass --auto-update to track @latest instead.`
+    : `PINNED to ${version}${staleProof ? ' (stale-proof: every restart re-fetches it fresh, never a stale npx cache)' : ''} (safe default — a bad publish can't auto-roll to this always-on bridge). To update: use "Restart & update the bridge" (or re-run install-service from a newer thinkpool-pair). Pass --auto-update to track @latest instead.`
   const removeArg = room ? ` ${room}` : ''
   const what = room ? `room ${room}` : 'your account (auto-serves every session)'
   process.stderr.write(`  ◆ ${what}\n  ◆ ${a.note}\n  ◆ ${updateNote}\n  ◆ logs: ${path.join(a.logDir, `${slug(room)}.log`)}\n  ◆ remove with: thinkpool-pair uninstall-service${removeArg}\n\n`)