thinkpool-pair 0.7.78 → 0.7.80

package/README.md

@@ -7,6 +7,11 @@ no copy/paste.
 > A web page can't read your terminal directly (browser security). This tiny
 > helper is the bridge: it runs CLIs in PTYs and streams them to the room.
 
+> **Don't want it tied to your laptop?** Run this same bridge on an always-on box
+> you control (a cheap VM, a home server, a Raspberry Pi) so the agent stays live
+> with your laptop closed. It's outbound-only — no ports, no public IP. See
+> [**Run it in the cloud**](#run-it-in-the-cloud-remote-host--vm--container) below.
+
 ## Run it (one command)
 
 ```bash
@@ -63,9 +68,20 @@ cd /path/to/your/repo
 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.
+- **Auth** — two ways to sign in on a box with no browser. Both are your own
+  account on your own hardware, so both are fine:
+  - **API key** — `export ANTHROPIC_API_KEY=sk-ant-...` from your Anthropic
+    Console. Simplest, pay-per-token, cleanest cost tracking.
+  - **Your Claude subscription** — a server has no browser, so mint a long-lived
+    token *on a machine that does*: run `claude setup-token` there (prints a
+    ~1-year `CLAUDE_CODE_OAUTH_TOKEN`), then `export CLAUDE_CODE_OAUTH_TOKEN=...`
+    on the box. Uses your existing Pro/Max plan — no per-token bill.
+
+  The Agent SDK reads either one automatically and runs its bundled `claude`, so
+  you don't need Claude Code installed separately. (Note: this is *you* running
+  *your* login on *your* machine. Handing a subscription token to a third-party
+  host to run for you is what Anthropic's terms forbid — that's why a future
+  "we host it for you" option would require an API key, not your subscription.)
 - **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.

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

@@ -361,6 +361,9 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
       'LINKS & ARTIFACTS (hard rule for ThinkPool Code rooms): the room is driven from a phone or browser, and the bridge runs on the host machine — so a local filesystem path, a file:// URL, or a localhost address only opens on the host and is useless to the room (a partner literally cannot open it).',
       'Whenever you produce an HTML artifact (a demo, mockup, preview, report, or page) or surface ANY link meant to be opened or shared, NEVER hand the room a local path, a file:// URL, or a localhost/127.0.0.1 address. Publish it to a GitHub-shareable URL that renders in a browser — push the HTML to a GitHub repo and give its GitHub Pages URL (or an equivalent raw-HTML URL that actually renders, not raw.githubusercontent.com which serves HTML as plain text) — so anyone in the room can open it. The same applies to any other link you surface: it must be one the room can reach, not a host-only path.',
       'If you cannot publish a shareable link, say so and ask how to proceed — do not fall back to handing over a local path.',
+      'SHOW YOUR WORK, do not just describe it: the room is watched live from a phone, where a wall of text is painful to read. Whenever you build, change, or fix anything visual — a UI, a page, an HTML artifact, a chart, a diagram, a rendered result — capture a screenshot and surface the PNG (for example, read the image file into your turn) so it appears inline in the room. The room auto-uploads any image you surface. Default to showing a picture of the result over narrating it; err toward more screenshots, not fewer.',
+      'HTML PREVIEWS: for any HTML you produce, give the room something it can actually open, by whichever path is available. (a) IN-ROOM PREVIEW: if a mockup render helper is present — one that writes a manifest into the directory named by $TP_MOCKUP_OUTBOX, such as the mockup-iterate render.sh script when the bridge was launched from the thinkpool repo — use it; it surfaces an inline card with desktop and mobile views that the room can expand. (b) SHAREABLE LINK: additionally or otherwise, publish the HTML to a GitHub Pages URL per the LINKS & ARTIFACTS rule above and post the link. Never leave an HTML artifact viewable only as a local path.',
+      'RUN IT, DO NOT ASK: verify your own work before calling it done. Actually run or serve what you changed, observe that it behaves correctly, and show the evidence in the room — a screenshot of the running result, the passing test output, or the real response — rather than telling the user "this should work, go test it." If you could not verify something, say exactly what is unverified. This room follows verify-before-claiming: runtime evidence you produced, not assertion.',
     ].join(' '),
     // Needed for live thinking-token progress (SDKThinkingTokensMessage) to
     // flow during a turn. We ignore the fine-grained stream_event partials in

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.78",
+  "version": "0.7.80",
   "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`)