thinkpool-pair 0.7.57 → 0.7.59

package/bridge.mjs

@@ -222,6 +222,29 @@ if (argv[0] === 'serve') {
   process.exit(0)
 }
 
+// `npx thinkpool-pair cmux-doctor` — explain why the cmux service tier did/didn't engage.
+// Detection is env-based (CMUX_WORKSPACE_ID/SURFACE_ID); the socket is only needed for the
+// actual surface spawn. This prints both so a "it didn't detect cmux" report is one command.
+if (argv[0] === 'cmux-doctor') {
+  const cmux = await import('./cmux.mjs')
+  const env = process.env
+  const w = (s) => process.stderr.write(s + '\n')
+  const reachable = cmux.cmuxReachable()
+  w('\n  thinkpool-pair · cmux doctor')
+  w(`    CMUX_WORKSPACE_ID : ${env.CMUX_WORKSPACE_ID || '(unset)'}`)
+  w(`    CMUX_SURFACE_ID   : ${env.CMUX_SURFACE_ID || '(unset)'}`)
+  w(`    CMUX_SOCKET_PATH  : ${env.CMUX_SOCKET_PATH || '(unset)'}`)
+  w(`    cmux on PATH      : ${onPath('cmux')}`)
+  w(`    inCmux()          : ${cmux.inCmux()}`)
+  w(`    cmux ping         : ${reachable ? 'ok' : 'FAILED (socket unreachable)'}`)
+  w(`    detectCmux()      : ${cmux.detectCmux()}   ${cmux.detectCmux() ? '→ cmux-surface offered' : '→ falls back to OS service'}`)
+  w(`    cmux service set  : ${cmux.isCmuxServiceInstalled()}`)
+  if (!cmux.inCmux()) w('\n  ⚠ not launched from cmux (no CMUX_WORKSPACE_ID/SURFACE_ID). Run this INSIDE a cmux\n    terminal surface — a plain Terminal/iTerm window will not be detected.')
+  else if (!reachable) w('\n  ⚠ in cmux, but the automation socket is unreachable. detectCmux() is env-based so\n    the surface is still offered, but the actual spawn needs the socket — if install\n    falls back to the OS service, enable cmux automation/socket access in cmux settings.')
+  else w('\n  ✓ cmux detected and drivable — the cmux-surface service tier is available.')
+  process.exit(0)
+}
+
 // One-command launcher: a bare invocation on a TTY (or the `setup` alias) opens the
 // interactive menu instead of going straight to account mode. The menu only ASSEMBLES
 // existing commands — it re-execs `<ROOM>`, or calls installService / runLogin /
@@ -262,12 +285,31 @@ if ((!argv[0] || argv[0] === 'setup') && process.stdin.isTTY) {
       if (room === null && cmux.isCmuxServiceInstalled()) { cmux.restartCmuxService(); process.stderr.write('\n  ◆ restarted the cmux-hosted account service — sessions resume in place.\n') }
       else svc.restartService(room)
     },
+    // "Restart & update the bridge" — re-pin the service to THIS launcher's version
+    // (you launched via @latest, so it's the newest publish) and restart. The cmux
+    // surface re-pins + respawns; the OS service is reinstalled (rewrites the plist/unit
+    // to the new version and reloads). Pinned throughout — no auto-roll.
+    restartUpdateService: ({ room = null } = {}) => {
+      if (room === null && cmux.isCmuxServiceInstalled()) {
+        cmux.restartCmuxService({ version: PKG_VERSION })
+        process.stderr.write(`\n  ◆ updated the cmux account service to v${PKG_VERSION} and restarted it — sessions resume in place.\n`)
+      } else {
+        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
+      }
+    },
     // Account service hosted as a cmux surface — offered only inside cmux, with its
-    // weaker-persistence caveat shown first (launcher.mjs serveAccount).
+    // weaker-persistence caveat shown first (launcher.mjs serveAccount). Falls back to
+    // the OS service if the cmux socket can't actually be driven (detection is env-based).
     detectCmux: () => cmux.detectCmux(),
     installAccountCmux: () => {
-      const rec = cmux.installCmuxService({ version: PKG_VERSION })
-      process.stderr.write(`\n  ◆ account service now runs as a cmux surface ("${cmux.WS_NAME}") — visible and killable.\n  ◆ it restarts itself on crash; stop it with:  npx thinkpool-pair uninstall-service\n  ◆ pinned to v${rec.version}.\n\n`)
+      try {
+        const rec = cmux.installCmuxService({ version: PKG_VERSION })
+        process.stderr.write(`\n  ◆ account service now runs as a cmux surface ("${cmux.WS_NAME}") — visible and killable.\n  ◆ it restarts itself on crash; stop it with:  npx thinkpool-pair uninstall-service\n  ◆ pinned to v${rec.version}.\n\n`)
+      } catch (e) {
+        process.stderr.write(`\n  ⚠ couldn't spawn a cmux surface (${e.message || e}). The cmux automation socket may be\n    disabled — run 'npx thinkpool-pair cmux-doctor' to check. Falling back to the system service.\n`)
+        svc.installService(null, [])
+      }
     },
     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

@@ -343,6 +343,9 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
       'Bias strongly toward DOING the work, not planning it. For a normal "add / fix / change / build X" request, just make the change directly.',
       'Do NOT enter plan mode, do NOT call ExitPlanMode, and do NOT auto-invoke a brainstorming/planning skill UNLESS the user has switched the room into Plan mode or explicitly asks you to plan, design, or brainstorm first.',
       'Any host-global instruction that says you must always brainstorm or plan before creative work does NOT apply here — this room is the exception.',
+      '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.',
     ].join(' '),
     // Needed for live thinking-token progress (SDKThinkingTokensMessage) to
     // flow during a turn. We ignore the fine-grained stream_event partials in

package/cmux.mjs

@@ -55,9 +55,14 @@ export function cmuxReachable(run = cmux) {
   try { run(['ping'], { timeout: 4000 }); return true } catch { return false }
 }
 
-// Use the cmux tier only when BOTH hold: cmux spawned us AND the socket answers.
-export function detectCmux(env = process.env, run = cmux) {
-  return inCmux(env) && cmuxReachable(run)
+// Detection keys ONLY on the env cmux injects into every surface it spawns — NOT on
+// whether the socket answers. The socket ping proved flaky (it needs CMUX_SOCKET_PASSWORD
+// and can broken-pipe even from a real surface), and gating detection on it silently
+// killed the cmux offer in 0.7.57. If the env says cmux we offer the cmux tier; if the
+// actual new-workspace spawn then can't reach the socket, installCmuxService throws and
+// the caller falls back to the OS service. (cmuxReachable stays exported for cmux-doctor.)
+export function detectCmux(env = process.env) {
+  return inCmux(env)
 }
 
 export function readRecord(recordFile = RECORD) {
@@ -119,11 +124,15 @@ export function installCmuxService({ version, cwd = HOME, run = cmux, recordFile
 
 // Restart = close the surface + spawn a fresh one. The account supervisor restores
 // every active session from disk (session-store crash-resume), so sessions resume
-// in place — same contract as an OS-service restart.
-export function restartCmuxService({ run = cmux, recordFile = RECORD } = {}) {
+// in place — same contract as an OS-service restart. Passing `version` re-pins the
+// surface command to that version first (the "Restart & update the bridge" path):
+// the command stays PINNED (never @latest — no auto-roll), just bumped to the version
+// the user explicitly launched.
+export function restartCmuxService({ run = cmux, recordFile = RECORD, version } = {}) {
   const rec = readRecord(recordFile)
   if (!rec) return false
   closeSurface(run, rec)
+  if (version) { rec.version = version; rec.command = serviceCommand(version) }
   rec.workspace = spawnSurface(run, rec.command)
   rec.installedAt = new Date().toISOString()
   fs.writeFileSync(recordFile, JSON.stringify(rec, null, 2))

package/launcher.mjs

@@ -192,7 +192,7 @@ export async function runLauncher({ actions, io, state = detectState(), refresh
       const pick = await askChoice('\n  change', [
         { label: 'LLM provider', hint: `current: ${state.provider}` },
         { label: 'Account', hint: state.loggedIn ? `linked: ${state.email || 'yes'}` : 'not linked' },
-        { label: 'Restart the background service', hint: state.accountSvc ? 'bounce it now — sessions resume' : 'none installed' },
+        { label: 'Restart & update the bridge', hint: state.accountSvc ? 'pull the newest published version, then restart — sessions resume' : 'none installed' },
         { label: 'Remove the background service', hint: state.accountSvc ? '' : 'none installed' },
         { label: '← Back to main menu', hint: '' },
       ], 5)  // Enter = Back
@@ -200,7 +200,7 @@ export async function runLauncher({ actions, io, state = detectState(), refresh
       if (pick === 0) await providerMenu()
       else if (pick === 1) { await actions.login(); resync(); return }
       else if (pick === 2) {
-        if (state.accountSvc) { await actions.restartService({ room: null }); resync() }
+        if (state.accountSvc) { await actions.restartUpdateService({ room: null }); resync() }
         else io.print('  ' + C.yellow('no background service installed'))
       }
       else {
@@ -225,7 +225,7 @@ export async function runLauncher({ actions, io, state = detectState(), refresh
       { key: 'serve',   label: 'Serve all my sessions', hint: 'account mode — needs login' },
       { key: 'service', label: 'Always-on background service', hint: 'survives reboot, restarts on crash' },
     ]
-    if (state.accountSvc) items.push({ key: 'restart', label: 'Restart the background service', hint: 'bounce it now — sessions resume' })
+    if (state.accountSvc) items.push({ key: 'restart', label: 'Restart & update the bridge', hint: 'pull the newest version + restart — sessions resume' })
     items.push({ key: 'settings', label: 'Settings', hint: 'provider · account · restart · remove service' })
     items.push({ key: 'quit', label: 'Quit', hint: '' })
     const pick = items[await askChoice('choose', items)]
@@ -233,7 +233,7 @@ export async function runLauncher({ actions, io, state = detectState(), refresh
     if (pick.key === 'pair') await pairRoom()
     else if (pick.key === 'serve') await serveAccount()
     else if (pick.key === 'service') await serviceMenu()
-    else if (pick.key === 'restart') { await actions.restartService({ room: null }); resync() }
+    else if (pick.key === 'restart') { await actions.restartUpdateService({ room: null }); resync() }
     else if (pick.key === 'settings') await settingsMenu()
     await io.ask('\n  ' + C.dim('press Enter to return to the menu…'))
   }

package/package.json

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