thinkpool-pair 0.7.285 → 0.7.286

package/account.mjs

@@ -22,6 +22,7 @@ import { resolveServeDir } from './serve-dir.mjs'
 import { pairKeyFor, pairTopic, CROSSROOM_BUS } from './cross-terminal.mjs'
 import { installedAgentCommands } from './agent-detect.mjs'
 import { hostMemoryAdmission } from './host-memory.mjs'
+import { createPairBusBroker, mergePairRoomRoster, pairBusStatusFromRealtime, PAIR_BUS_STATUS } from './pair-bus.mjs'
 
 const VERSION = (() => { try { return JSON.parse(fs.readFileSync(new URL('./package.json', import.meta.url), 'utf8')).version } catch { return null } })()
 
@@ -431,8 +432,7 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
   // relays peek/post requests between a local room child and the partner's supervisor.
   // Spec: docs/specs/2026-06-30-cross-room-pair-bus.md
   const roomPartner = new Map()   // room -> the OTHER participant's uid (the pair partner), for 2-person rooms
-  const pairChannels = new Map()  // partnerUid -> { channel, key } (one bus per distinct partner)
-  const busWaiters = new Map()    // nonce -> { mode:'first'|'collect', resolve, timer, acc? } for OUR outbound bus requests
+  const pairChannels = new Map()  // partnerUid -> { channel, key, status } (one bus per distinct partner)
   const postBucket = new Map()    // partnerUid -> { count, resetAt } inbound cross-room-post rate limit (runaway-cost backstop)
   const POST_BUCKET = { max: 6, windowMs: 60_000 }   // ≤6 inbound cross-room posts / partner / minute
   let applyRequested = false   // a user clicked "apply" in some room (Slice 3)
@@ -706,34 +706,17 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
   }
 
   // ── pair-bus plumbing (function declarations hoist, so order here is free) ──
-  // Resolve one of OUR outbound bus requests. 'first' resolves on the first reply
-  // (peek/post — a single partner answers); 'collect' accumulates every reply within
-  // the window (list — several partners may each answer) and resolves when it closes.
-  const resolveBus = (payload) => {
-    if (!payload?.nonce) return
-    const w = busWaiters.get(payload.nonce)
-    if (!w) return
-    if (w.mode === 'collect') { w.acc.push(payload); return }
-    clearTimeout(w.timer); busWaiters.delete(payload.nonce); w.resolve(payload)
-  }
-  const busSendAll = (event, payload) => {
-    let sent = 0
-    for (const { channel } of pairChannels.values()) { try { channel.send({ type: 'broadcast', event, payload }); sent++ } catch { /* channel down */ } }
-    return sent
+  const pairBus = createPairBusBroker({ channels: pairChannels, randomId: randomUUID })
+  const resolveBus = (payload) => pairBus.resolve(payload)
+  const busRequestFirst = (event, payload, timeoutMs) => pairBus.requestFirst(event, payload, timeoutMs)
+  const busRequestCollect = (event, payload, windowMs) => pairBus.requestCollect(event, payload, windowMs)
+  const authorizedPairRooms = async (sourceRoom) => {
+    try {
+      const listed = await withTimeout(sb.rpc('list_pair_rooms', { p_code: sourceRoom }), 2500, 'paired-room roster')
+      if (listed?.error || !Array.isArray(listed?.data)) return { verified: false, rooms: [] }
+      return { verified: true, rooms: listed.data }
+    } catch { return { verified: false, rooms: [] } }
   }
-  const busRequestFirst = (event, payload, timeoutMs) => new Promise((resolve) => {
-    const nonce = randomUUID()
-    if (!busSendAll(event, { ...payload, nonce })) return resolve(null)
-    const timer = setTimeout(() => { busWaiters.delete(nonce); resolve(null) }, timeoutMs); timer.unref?.()
-    busWaiters.set(nonce, { mode: 'first', resolve, timer })
-  })
-  const busRequestCollect = (event, payload, windowMs) => new Promise((resolve) => {
-    const nonce = randomUUID()
-    if (!busSendAll(event, { ...payload, nonce })) return resolve([])
-    const acc = []
-    const timer = setTimeout(() => { busWaiters.delete(nonce); resolve(acc) }, windowMs); timer.unref?.()
-    busWaiters.set(nonce, { mode: 'collect', acc, resolve, timer })
-  })
   // Inbound cross-room-post rate limit, per partner (a partner's agent posting into
   // MY rooms spends MY tokens — the runaway-cost backstop, on top of the per-turn cap).
   const allowInboundPost = (partnerUid) => {
@@ -787,15 +770,19 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
     if (!partnerUid || pairChannels.has(partnerUid)) return
     const topic = pairTopic(key); if (!topic) return
     const ch = sb.channel(topic, { config: { private: true, broadcast: { self: false } } })
+    const entry = { channel: ch, key, status: PAIR_BUS_STATUS.JOINING }
     ch.on('broadcast', { event: 'peer-list-req' }, ({ payload }) => onPeerListReq(partnerUid, ch, payload))
       .on('broadcast', { event: 'peer-list-res' }, ({ payload }) => resolveBus(payload))
       .on('broadcast', { event: 'peer-peek-req' }, ({ payload }) => onPeerPeekReq(partnerUid, ch, payload))
       .on('broadcast', { event: 'peer-peek-res' }, ({ payload }) => resolveBus(payload))
       .on('broadcast', { event: 'peer-post-req' }, ({ payload }) => onPeerPostReq(partnerUid, ch, payload))
       .on('broadcast', { event: 'peer-post-res' }, ({ payload }) => resolveBus(payload))
-      .subscribe()
-    pairChannels.set(partnerUid, { channel: ch, key })
-    process.stderr.write(`\n  ◆ pair bus open — cross-machine Ensemble reach with your partner.\n`)
+      .subscribe((status) => {
+        entry.status = pairBusStatusFromRealtime(status)
+        if (status === 'SUBSCRIBED') process.stderr.write(`\n  ◆ pair bus subscribed — cross-machine Ensemble reach with your partner.\n`)
+        else if (status === 'CHANNEL_ERROR' || status === 'TIMED_OUT') process.stderr.write(`\n  ◇ pair bus ${status.toLowerCase().replace('_', ' ')} — partner sessions are offline until it reconnects.\n`)
+      })
+    pairChannels.set(partnerUid, entry)
   }
   // Forward a local child's cross-room request to the bus (Tier 2 peek / Tier 3 post)
   // when the target room is NOT served on this machine. Used inside the child handler.
@@ -923,11 +910,15 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
           ;(async () => {
             if (process.env.TP_CROSSROOM_OFF === '1') { try { child.send({ t: 'pair-list-res', reqId: m.reqId, rooms: [], error: 'Cross-session reach is turned off on this bridge.' }) } catch { /* child gone */ } return }
             const local = [...children.keys()].filter((r) => r !== room).map((r) => ({ code: r, name: roomNames.get(r) || null }))
-            let remote = []
-            if (process.env.TP_PAIRBUS_OFF !== '1' && pairChannels.size) {
-              const replies = await busRequestCollect('peer-list-req', {}, 1200)
-              remote = replies.flatMap((p) => (Array.isArray(p?.rooms) ? p.rooms : []))
+            let authorized = []; let replies = []
+            if (process.env.TP_PAIRBUS_OFF !== '1') {
+              const result = await Promise.all([
+                authorizedPairRooms(room),
+                pairChannels.size ? busRequestCollect('peer-list-req', {}, 1200) : Promise.resolve([]),
+              ])
+              authorized = result[0].rooms; replies = result[1]
             }
+            const remote = mergePairRoomRoster({ authorized, replies, myUid: session.user.id, localCodes: children.keys() })
             try { child.send({ t: 'pair-list-res', reqId: m.reqId, rooms: [...local, ...remote] }) } catch { /* child gone */ }
           })()
         }
@@ -946,7 +937,14 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
               return
             }
             // REMOTE target — ask the pair bus(es).
-            if (process.env.TP_PAIRBUS_OFF === '1' || !pairChannels.size) return reply({ error: `Session ${target} is not running on this machine, and no pair bus is open to reach it.` })
+            if (process.env.TP_PAIRBUS_OFF === '1') return reply({ error: 'Cross-session reach is turned off on this bridge.' })
+            const [authorized, live] = await Promise.all([
+              authorizedPairRooms(room),
+              pairChannels.size ? busRequestCollect('peer-list-req', {}, 800) : Promise.resolve([]),
+            ])
+            if (authorized.verified && !authorized.rooms.some((r) => r?.code === target && r?.owner_id !== session.user.id)) return reply({ error: `Room ${target} is not shared with this pair.` })
+            if (!pairChannels.size) return reply({ error: authorized.verified ? `Room ${target} is paired with you, but its host bridge is offline.` : `Session ${target} is not running on this machine, and no pair bus is open to reach it.` })
+            if (!live.some((p) => p?.rooms?.some((r) => r?.code === target))) return reply({ error: `Room ${target} is paired with you, but its host bridge is offline.` })
             const res = await busPeek(target, m.terminal, m.lines)
             if (!res) return reply({ error: `Room ${target} did not respond — it may be offline, or not shared with you.` })
             reply({ text: res.text, error: res.error })
@@ -966,8 +964,16 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
               catch { pairPending.delete(reqId); reply({ error: `Could not reach session ${target}.` }) }
               return
             }
-            // REMOTE target — over the pair bus.
-            if (!pairChannels.size) return reply({ error: `Room ${target} is not on this machine, and no pair bus is open to reach it.` })
+            // REMOTE target — prove the partner's bridge is currently answering
+            // before starting a 180s human-approval wait. The DB-backed roster may
+            // legitimately list an offline paired room; reachability comes from the bus.
+            const [authorized, live] = await Promise.all([
+              authorizedPairRooms(room),
+              pairChannels.size ? busRequestCollect('peer-list-req', {}, 1200) : Promise.resolve([]),
+            ])
+            if (authorized.verified && !authorized.rooms.some((r) => r?.code === target && r?.owner_id !== session.user.id)) return reply({ error: `Room ${target} is not shared with this pair.` })
+            if (!pairChannels.size) return reply({ error: authorized.verified ? `Room ${target} is paired with you, but its host bridge is offline.` : `Room ${target} is not on this machine, and no pair bus is open to reach it.` })
+            if (!live.some((p) => p?.rooms?.some((r) => r?.code === target))) return reply({ error: `Room ${target} is paired with you, but its host bridge is offline — no recipient approval card can be raised yet.` })
             const res = await busPost(target, m.terminal, m.text, room, m.fromTerminalName)
             if (!res) return reply({ error: `Room ${target} did not respond to the hand-off in time.` })
             reply({ ok: res.ok, ref: res.ref, error: res.error })
@@ -1101,6 +1107,7 @@ export async function runAccount(SUPABASE_URL, SUPABASE_ANON) {
     keepFresh.cancel()
     releaseSingleton()
     for (const c of children.values()) { try { c.kill(sig || 'SIGTERM') } catch { /* noop */ } }
+    pairBus.close()
     for (const { channel } of pairChannels.values()) { try { sb.removeChannel(channel) } catch { /* noop */ } }   // tear down pair buses (Tier 2/3)
     // Flush the presence LEAVE before exiting so the dashboard flips to
     // "not connected" in realtime (don't fire-and-forget the untrack).

package/bridge.mjs

@@ -113,7 +113,7 @@ const flowRedispatch = new Map()
 // wave BEFORE overrun. Lives bridge-side because waves dispatch across separate
 // broadcasts; without persistent state the cap can never bite.
 const flowBudgets = new Map()
-import { formatPeek, PEEK, siblingsOf, resolveSibling, crossPostDecision, CROSSPOST, spawnDecision, SPAWN, CROSSROOM, formatPairRoster, crossRoomPostDecision, formatRoomNow, formatClosableHint, closeLaneDecision, laneStatusOf, nativeClaudeFallbackHint, buildDispatchPreview, authorizeDirectDispatch } from './cross-terminal.mjs'
+import { formatPeek, PEEK, siblingsOf, resolveSibling, crossPostDecision, CROSSPOST, spawnDecision, SPAWN, CROSSROOM, CROSSROOM_BUS, formatPairRoster, crossRoomPostDecision, formatRoomNow, formatClosableHint, closeLaneDecision, laneStatusOf, nativeClaudeFallbackHint, buildDispatchPreview, authorizeDirectDispatch } from './cross-terminal.mjs'
 import { dispatchPendingRecap, recoverInterruptedTurn, recoverMissingResumeOnce, sendInterruptedContinue, shouldAttemptNativeResume, supersedeInterruptedResume } from './interrupted-resume.mjs'
 import { supersedeDispatchLease } from './dispatch-lease.mjs'
 import { turnInFlight } from './update-gate.mjs'
@@ -2306,7 +2306,7 @@ function openStructured({ id, runtime = 'claude', model, models, effort, resume,
           if (target === room) return okText('That is this room — use read_terminal for terminals in your own room.')
           entry.pairPeekCount = (entry.pairPeekCount || 0) + 1
           if (entry.pairPeekCount > CROSSROOM.peekPerTurnCap) return okText(`Cross-session read limit reached for this turn (${CROSSROOM.peekPerTurnCap}). Continue with what you have.`)
-          const res = await pairRequest('pair-peek-req', { targetRoom: target, terminal: args?.terminal, lines: args?.lines })
+          const res = await pairRequest('pair-peek-req', { targetRoom: target, terminal: args?.terminal, lines: args?.lines }, CROSSROOM_BUS.busTimeoutMs + 2_000)
           if (res?.error) return okText(res.error)
           return okText(res?.text || `Room ${target} returned nothing.`)
         },

package/cross-terminal.mjs

@@ -644,7 +644,7 @@ export const formatPairRoster = (rooms, { thisRoom, error } = {}) => {
   // `host` is set for a Tier-2 cross-MACHINE room (it lives on a partner's Mac,
   // reached over the pair bus); a same-machine Tier-1 room has none. Rendering the
   // host tells the agent (and the people) which rooms are "over there".
-  const rows = list.map((r) => `- ${r.code}${r.name ? ` · "${r.name}"` : ''}${r.host ? ` · on ${r.host}` : ''}`)
+  const rows = list.map((r) => `- ${r.code}${r.name ? ` · "${r.name}"` : ''}${r.host ? ` · on ${r.host}` : ''}${r.online === false ? ' · partner bridge offline' : ''}`)
   return `Your other ThinkPool Code sessions (call read_session with a room code to look inside one):\n${rows.join('\n')}`
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.285",
+  "version": "0.7.286",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -55,6 +55,7 @@
     "session-store.mjs",
     "side-lane.mjs",
     "cross-terminal.mjs",
+    "pair-bus.mjs",
     "lane-lifecycle.mjs",
     "interrupted-resume.mjs",
     "dispatch-lease.mjs",

package/pair-bus.mjs

@@ -0,0 +1,98 @@
+// Deterministic request broker for the cross-machine pair bus.
+//
+// Supabase channel.send() is asynchronous and a channel is not usable until its
+// subscription callback reports SUBSCRIBED. Keeping those facts in one tested
+// primitive prevents a joining/dead channel from impersonating a reachable peer
+// and prevents a fast reply from arriving before its waiter exists.
+
+export const PAIR_BUS_STATUS = Object.freeze({
+  JOINING: 'joining',
+  SUBSCRIBED: 'subscribed',
+  ERROR: 'error',
+  CLOSED: 'closed',
+})
+
+export const pairBusStatusFromRealtime = (status) => {
+  if (status === 'SUBSCRIBED') return PAIR_BUS_STATUS.SUBSCRIBED
+  if (status === 'CLOSED') return PAIR_BUS_STATUS.CLOSED
+  if (status === 'CHANNEL_ERROR' || status === 'TIMED_OUT') return PAIR_BUS_STATUS.ERROR
+  return PAIR_BUS_STATUS.JOINING
+}
+
+export const subscribedPairChannels = (channels) =>
+  [...(channels?.values?.() || [])].filter((entry) =>
+    entry?.status === PAIR_BUS_STATUS.SUBSCRIBED && entry?.channel?.send)
+
+export async function sendPairBroadcast (channels, event, payload) {
+  const results = await Promise.all(subscribedPairChannels(channels).map(async ({ channel }) => {
+    try { return (await channel.send({ type: 'broadcast', event, payload })) === 'ok' }
+    catch { return false }
+  }))
+  return results.filter(Boolean).length
+}
+
+export function createPairBusBroker ({ channels, randomId, setTimer = setTimeout, clearTimer = clearTimeout } = {}) {
+  if (!channels?.values || typeof randomId !== 'function') throw new TypeError('channels and randomId are required')
+  const waiters = new Map()
+
+  const resolve = (payload) => {
+    if (!payload?.nonce) return false
+    const waiter = waiters.get(payload.nonce)
+    if (!waiter) return false
+    if (waiter.mode === 'collect') { waiter.acc.push(payload); return true }
+    clearTimer(waiter.timer); waiters.delete(payload.nonce); waiter.finish(payload)
+    return true
+  }
+
+  const requestFirst = (event, payload = {}, timeoutMs) => new Promise((finish) => {
+    const nonce = randomId()
+    const timer = setTimer(() => { waiters.delete(nonce); finish(null) }, timeoutMs)
+    timer?.unref?.()
+    waiters.set(nonce, { mode: 'first', finish, timer })
+    void sendPairBroadcast(channels, event, { ...payload, nonce }).then((sent) => {
+      if (sent || !waiters.has(nonce)) return
+      clearTimer(timer); waiters.delete(nonce); finish(null)
+    })
+  })
+
+  const requestCollect = (event, payload = {}, windowMs) => new Promise((finish) => {
+    const nonce = randomId()
+    const acc = []
+    const timer = setTimer(() => { waiters.delete(nonce); finish(acc) }, windowMs)
+    timer?.unref?.()
+    waiters.set(nonce, { mode: 'collect', acc, finish, timer })
+    void sendPairBroadcast(channels, event, { ...payload, nonce }).then((sent) => {
+      if (sent || !waiters.has(nonce)) return
+      clearTimer(timer); waiters.delete(nonce); finish(acc)
+    })
+  })
+
+  const close = () => {
+    for (const [nonce, waiter] of waiters) {
+      clearTimer(waiter.timer)
+      waiter.finish(waiter.mode === 'collect' ? waiter.acc : null)
+      waiters.delete(nonce)
+    }
+  }
+
+  return Object.freeze({ resolve, requestFirst, requestCollect, close, pendingCount: () => waiters.size })
+}
+
+// The database is the authorization/discovery source; bus replies are the live
+// reachability source. Paired rooms remain visible while their host bridge is
+// offline and become online only when that host actually answers on the bus.
+export function mergePairRoomRoster ({ authorized = [], replies = [], myUid, localCodes = [] } = {}) {
+  const local = new Set(localCodes)
+  const rooms = new Map()
+  for (const row of authorized) {
+    if (!row?.code || row.owner_id === myUid || local.has(row.code)) continue
+    rooms.set(row.code, { code: row.code, name: row.name || null, online: false })
+  }
+  for (const reply of replies) {
+    for (const row of Array.isArray(reply?.rooms) ? reply.rooms : []) {
+      if (!row?.code || local.has(row.code)) continue
+      rooms.set(row.code, { code: row.code, name: row.name || rooms.get(row.code)?.name || null, host: row.host || null, online: true })
+    }
+  }
+  return [...rooms.values()]
+}