thinkpool-pair 0.7.20 → 0.7.22

package/account.mjs

@@ -223,6 +223,14 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
   // stop. Mirrors the per-room session-deleted guard in bridge.mjs.
   acct.on('broadcast', { event: 'shutdown' }, async () => {
     process.stderr.write('\n  ◇ disconnect requested from the dashboard — stopping bridge.\n')
+    // Hard-exit backstop, armed FIRST — independent of the SIGTERM round-trip,
+    // the realtime socket, and every await below. If the graceful stop() wedges
+    // (2026-06-18: a dashboard disconnect left this supervisor ALIVE holding
+    // account.lock with no presence + service removed — a zombie that showed
+    // "No bridge connected" on /code yet blocked any `npx thinkpool-pair`
+    // restart), force the process down and release the lock so a fresh bridge
+    // can take over. NOT unref'd: it must keep the loop alive until it fires.
+    setTimeout(() => { try { releaseSingleton() } catch { /* noop */ } process.exit(0) }, 2500)
     if (process.env.THINKPOOL_PAIR_AUTOUPDATE === '1') {
       try { const svc = await import('./service.mjs'); svc.uninstallService(null) } catch { /* noop */ }
     }

package/bridge.mjs

@@ -384,17 +384,22 @@ try {
   process.env.TP_MOCKUP_OUTBOX = MOCKUP_OUTBOX
 } catch { /* mockups stay local if the outbox can't be made */ }
 
-const mockupSeen = new Map()   // slug → mtimeMs of the last manifest we processed
-const handleManifest = async (file) => {
+const mockupSeen = new Map()   // `${term}/${slug}` → mtimeMs of the last manifest processed
+// Push one manifest file into the room, attributed to `term`. The owner is
+// resolved by the WATCHER, not guessed here — each session/terminal writes to
+// its OWN outbox (handed in via TP_MOCKUP_OUTBOX), so the directory the file
+// landed in *is* its provenance. (Before: a per-room outbox + a "first session
+// in the Map" guess meant closing the generating terminal moved the cards to
+// whatever terminal was now first — they leaked into Terminal 1.)
+const handleManifest = async (box, file, term) => {
   if (!file || !file.endsWith('.json')) return
-  const full = path.join(MOCKUP_OUTBOX, file)
+  const full = path.join(box, file)
   let stat
   try { stat = fs.statSync(full) } catch { return }            // tmp/removed mid-write
   const slug = file.replace(/\.json$/, '')
-  if (mockupSeen.get(slug) === stat.mtimeMs) return            // already handled
-  mockupSeen.set(slug, stat.mtimeMs)
-  // A structured Claude session is the natural home; fall back to any terminal.
-  const term = [...sessions.keys()][0] || attachedId || [...terms.keys()][0]
+  const seenKey = `${term}/${slug}`
+  if (mockupSeen.get(seenKey) === stat.mtimeMs) return         // already handled
+  mockupSeen.set(seenKey, stat.mtimeMs)
   if (!term) return                                            // nothing to attach the card to yet
   let m
   try { m = JSON.parse(fs.readFileSync(full, 'utf8')) } catch { return }
@@ -419,9 +424,22 @@ const handleManifest = async (file) => {
     process.stderr.write(`\n  ◇ mockup "${m.slug}" send failed: ${e?.message || e}\n`)
   }
 }
-try {
-  fs.watch(MOCKUP_OUTBOX, (_evt, file) => { handleManifest(file).catch(() => {}) })
-} catch { /* fs.watch unsupported — mockups simply won't auto-surface */ }
+// Watch one outbox dir; `ownerFn()` resolves which terminal owns a manifest
+// dropped there (lazily, per event). Returns the FSWatcher so per-session/term
+// watchers can be torn down when their owner ends. Safe to call repeatedly.
+function watchOutbox(box, ownerFn) {
+  try { fs.mkdirSync(box, { recursive: true }) } catch { return null }
+  try { return fs.watch(box, (_evt, file) => { handleManifest(box, file, ownerFn()).catch(() => {}) }) }
+  catch { return null }   // fs.watch unsupported — mockups simply won't auto-surface
+}
+// A per-owner outbox lives at MOCKUP_OUTBOX/<kind>/<id> and is handed to that
+// owner's subprocess via TP_MOCKUP_OUTBOX (see openStructured / openTerm).
+const ownerOutbox = (kind, id) => path.join(MOCKUP_OUTBOX, kind, id)
+// Room-level outbox: ONLY external renders (a shell that set TP_MOCKUP_ROOM but
+// isn't a bridge child) land directly here now — bridge children write to their
+// own per-owner outbox. An external render's true owner is unknowable, so fall
+// back to the old "first live session/terminal" heuristic for it alone.
+watchOutbox(MOCKUP_OUTBOX, () => [...sessions.keys()][0] || attachedId || [...terms.keys()][0])
 
 // ── shared-PTY geometry ───────────────────────────────────────────
 // The attached PTY is CAPPED at 120×32, never pinned (2026-06-11).
@@ -453,13 +471,16 @@ function openTerm({ id, cmd, args = [], attached = false, cols, rows }) {
     return
   }
   const ad = attached ? attachedDims() : null
+  // This terminal's private mockup outbox — render.sh run inside it writes here,
+  // and the watcher attributes every card to THIS id (not a Map-order guess).
+  const mockupOutbox = ownerOutbox('terms', id)
   const term = pty.spawn(cmd, args, {
     name: 'xterm-256color',
     cols: cols || (attached ? ad.cols : (PIN_COLS || 120)),
     rows: rows || (attached ? ad.rows : (PIN_ROWS || 32)),
-    cwd: process.cwd(), env: process.env,
+    cwd: process.cwd(), env: { ...process.env, TP_MOCKUP_OUTBOX: mockupOutbox },
   })
-  const entry = { term, cmd, attached, scrollback: '', buf: '' }
+  const entry = { term, cmd, attached, scrollback: '', buf: '', mockupWatcher: watchOutbox(mockupOutbox, () => id) }
   terms.set(id, entry)
   if (attached) attachedId = id
   term.onData(d => {
@@ -468,6 +489,7 @@ function openTerm({ id, cmd, args = [], attached = false, cols, rows }) {
     entry.scrollback = (entry.scrollback + d).slice(-SCROLLBACK_MAX)
   })
   term.onExit(() => {
+    try { entry.mockupWatcher?.close() } catch { /* noop */ }
     terms.delete(id)
     if (id === attachedId) { attachedId = null; detachLocal() }
     if (shuttingDown) return
@@ -527,12 +549,18 @@ function openStructured({ id, model, resume, log, commands, mode }) {
   if (sessions.has(id)) return
   const entry = { cmd: 'claude', kind: 'structured', log: Array.isArray(log) ? log.slice(-STRUCTURED_LOG_MAX) : [], pending: new Map(), session: null, recovered: false, commands: Array.isArray(commands) ? commands : undefined, mode }
   sessions.set(id, entry)
+  // This session's private mockup outbox — render.sh writes manifests here (via
+  // TP_MOCKUP_OUTBOX below) and the watcher attributes every card to THIS id, so
+  // they land on this session even after other terminals open/close.
+  const mockupOutbox = ownerOutbox('sessions', id)
+  entry.mockupWatcher = watchOutbox(mockupOutbox, () => id)
   if (entry.log.length) process.stderr.write(`\n  ◆ restored ${entry.log.length} prior events (${id.slice(0, 8)})${resume ? ' + resuming live context' : ''}.\n`)
   // Persist the permission mode alongside the transcript so a bridge restart
   // restores the session in the SAME mode (a bypass room stays bypass on resume).
   const persist = () => saveSession(room, id, { sessionId: entry.session?.sessionId || resume || null, log: entry.log, commands: entry.commands, mode: entry.mode })
   entry.session = startClaudeSession({
     cwd: process.cwd(), model, resume, mode,
+    env: { ...process.env, TP_MOCKUP_OUTBOX: mockupOutbox },
     onEvent: (evt) => {
       // Self-heal a stale resume — the saved SDK session expired. Reopen fresh,
       // keeping the transcript (scrollback survives; live context is gone).
@@ -540,6 +568,7 @@ function openStructured({ id, model, resume, log, commands, mode }) {
         entry.recovered = true
         process.stderr.write(`\n  ◆ saved session expired — starting fresh (transcript kept).\n`)
         try { entry.session?.end() } catch { /* noop */ }
+        try { entry.mockupWatcher?.close() } catch { /* noop */ }
         sessions.delete(id)
         openStructured({ id, model, log: entry.log, commands: entry.commands, mode: entry.mode })
         return
@@ -591,6 +620,7 @@ function endStructured(id) {
   const s = sessions.get(id)
   if (s) {
     try { s.session?.end() } catch { /* noop */ }
+    try { s.mockupWatcher?.close() } catch { /* noop */ }
     sessions.delete(id)
     bcast('term-exit', { id })
   }
@@ -807,7 +837,13 @@ channel
         if (wantStructured(startCmd)) {
           const all = loadAll(room).filter((r) => r.log?.length || r.sessionId)
           if (all.length) for (const rec of all) openStructured({ id: rec.id, resume: canResume(rec) ? rec.sessionId : undefined, log: rec.log, commands: rec.commands, mode: rec.mode })
-          else openStructured({ id: randomUUID() })
+          // Fresh open: ONLY for an explicit `-- <claude>` share. In account mode
+          // (autoAgent set, no attachedCmd) the web's `?new=1` flow opens the first
+          // terminal; opening one here too raced it into TWO terminals — each a
+          // fresh random id, so openStructured's id-dedup couldn't catch it. The
+          // saved-session restore above still runs unconditionally, so a bridge
+          // restart resumes backgrounded sessions regardless of this guard.
+          else if (attachedCmd) openStructured({ id: randomUUID() })
         }
         else {
           // Reuse the prior auto-opened PTY id across restarts so a reconnecting

package/claude-session.mjs

@@ -105,6 +105,10 @@ const simplifyBlocks = (blocks = []) => blocks.map((b) => {
  * @param {string=}  o.cwd               working directory for the agent
  * @param {string=}  o.model             model id (default: host's configured)
  * @param {string=}  o.resume            session id to resume
+ * @param {object=}  o.env               full environment for the agent subprocess
+ *        (REPLACES process.env in the child — spread process.env yourself).
+ *        Used to hand each session its own TP_MOCKUP_OUTBOX so mockup cards
+ *        attribute to the session that generated them, not a Map-order guess.
  * @param {(evt)=>void} o.onEvent        receives normalized structured events
  * @param {(req)=>Promise<'allow'|'deny'>} o.requestPermission
  *        called for EVERY tool call with { id, toolName, input, risk };
@@ -113,7 +117,7 @@ const simplifyBlocks = (blocks = []) => blocks.map((b) => {
  */
 const MODES = new Set(['default', 'acceptEdits', 'plan', 'bypassPermissions'])
 
-export function startClaudeSession({ cwd, model, resume, mode: initialMode = 'default', onEvent, requestPermission }) {
+export function startClaudeSession({ cwd, model, resume, env, mode: initialMode = 'default', onEvent, requestPermission }) {
   const ac = new AbortController()
   const input = makeInputStream()
   let sessionId = resume || null
@@ -283,6 +287,7 @@ export function startClaudeSession({ cwd, model, resume, mode: initialMode = 'de
   if (cwd) opts.cwd = cwd
   if (model) opts.model = model
   if (resume) opts.resume = resume
+  if (env) opts.env = env
 
   ;(async () => {
     try {

package/package.json

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