thinkpool-pair 0.7.68 → 0.7.70

package/bridge.mjs

@@ -39,7 +39,7 @@ import { createClient } from '@supabase/supabase-js'
 import { startClaudeSession } from './claude-session.mjs'
 import { turnInFlight } from './update-gate.mjs'
 import { saveSession, flushSession, deleteSession, loadAll, canResume, loadPtyId, savePtyId, loadNames, saveNames } from './session-store.mjs'
-import { stampEvent, makeSeqCounter, maxSeq, seqable, capReplayEvents } from './event-id.mjs'
+import { stampEvent, makeSeqCounter, maxSeq, seqable, capReplayEvents, chunkReplayEvents } from './event-id.mjs'
 import { makeThrottledTrack } from './presence.mjs'
 
 // Public client creds (the same anon values the web app ships — safe to embed).
@@ -462,24 +462,37 @@ const webPeerPresent = () => {
 // still delivers instead of taking the channel down. capReplayEvents bounds bulk
 // replays before they reach here; this catches the single-event case + is the alarm.
 const FRAME_SOFT_LIMIT = 200000
+// Truncate the bulky string fields of ONE event in place (a giant tool_result / cat of
+// a big file / mockup blob). Keeps a head + a marker so the transcript stays readable.
+const truncEventFields = (evt) => {
+  if (!evt || typeof evt !== 'object') return
+  for (const k of ['text', 'content', 'output', 'stdout', 'stderr', 'input']) {
+    const v = evt[k]
+    if (typeof v === 'string' && v.length > 20000) {
+      evt[k] = v.slice(0, 20000) + `\n…[truncated ${v.length - 20000} bytes — too large to broadcast]`
+    }
+  }
+}
 const defendFrame = (event, payload) => {
   let json
   try { json = JSON.stringify(payload) } catch { return payload }
   if (!json || json.length <= FRAME_SOFT_LIMIT) return payload
-  process.stderr.write(`\n  ⚠ oversized ${event} frame: ${json.length}B (term ${String(payload?.term || '?').slice(0, 8)}) — truncating to fit so delivery isn't dropped\n`)
-  try {
-    const p = JSON.parse(json)
-    const evt = p.evt
-    if (evt && typeof evt === 'object') {
-      for (const k of ['text', 'content', 'output', 'stdout', 'stderr']) {
-        if (typeof evt[k] === 'string' && evt[k].length > 20000) {
-          const orig = evt[k].length
-          evt[k] = evt[k].slice(0, 20000) + `\n…[truncated ${orig - 20000} bytes — too large to broadcast]`
-        }
-      }
-    }
-    return p
-  } catch { return payload }
+  process.stderr.write(`\n  ⚠ oversized ${event} frame: ${json.length}B (term ${String(payload?.term || '?').slice(0, 8)}) — defanging so Realtime doesn't drop it\n`)
+  let p
+  try { p = JSON.parse(json) } catch { return payload }
+  // single live event (code-event)
+  if (p.evt && typeof p.evt === 'object') truncEventFields(p.evt)
+  // replay batch (code-replay): truncate each event's bulky fields…
+  if (Array.isArray(p.events)) {
+    p.events.forEach(truncEventFields)
+    // …and if a frame is STILL over the limit (bulk hidden in fields we don't truncate),
+    // drop the OLDEST events until it fits — keep the newest so the client's seqHi still
+    // advances to current. classifyReplay accepts the resulting seq jump; older events are
+    // covered by the DB transcript snapshot.
+    let guard = 0
+    while (p.events.length > 1 && JSON.stringify(p).length > FRAME_SOFT_LIMIT && guard++ < 10000) p.events.shift()
+  }
+  return p
 }
 
 const bcast = (event, payload) => {
@@ -1021,11 +1034,22 @@ channel
     for (const [id, s] of sessions) {
       if (!s.log.length) continue
       const from = Number(payload?.cursors?.[id]) || 0
-      const tail = from > 0 ? s.log.filter((e) => e.seq == null || e.seq > from) : s.log
-      // Cap to a frame-safe size — the full log on a fresh-reload (empty cursor) is
-      // multi-MB and gets dropped by Realtime, freezing the terminal. See capReplayEvents.
-      const events = capReplayEvents(tail)
-      bcast('code-replay', { to: payload?.to ?? null, term: id, events })
+      const mx = maxSeq(s.log)
+      // Cursor-sanity (B-safety): if the client's cursor is AHEAD of our highest seq, the
+      // bridge restarted BEHIND the client (lost unflushed events) or a /clear reset the
+      // counter — our live seqs would all read as "already seen" and be dropped forever
+      // (the seq-divergence freeze). Replay the full recent tail and flag `reset` so the
+      // client rebuilds its cursor from our authoritative log instead of trusting its own.
+      const ahead = from > mx
+      const tail = (from > 0 && !ahead) ? s.log.filter((e) => e.seq == null || e.seq > from) : s.log
+      // Chunk the tail into ORDERED under-budget frames (A): the full log on a fresh reload
+      // (empty cursor) is multi-MB and a single frame would be dropped by Realtime, freezing
+      // the terminal. chunkReplayEvents splits it so nothing in the recent window is lost;
+      // classifyReplay applies the chunks in arrival order. Older history beyond the chunk
+      // budget is covered by the client's DB transcript snapshot.
+      for (const events of chunkReplayEvents(tail)) {
+        bcast('code-replay', { to: payload?.to ?? null, term: id, events, ...(ahead ? { reset: true } : {}) })
+      }
     }
     // Re-send any still-pending permission/question cards. They ride a one-shot
     // code-perm-req broadcast (NOT the replayed event log), so a reconnect/refresh

package/event-id.mjs

@@ -93,3 +93,34 @@ export function capReplayEvents(events, budget = REPLAY_BYTE_BUDGET) {
   }
   return i === 0 ? events : events.slice(i)
 }
+
+// A (2026-06-26 follow-up): chunk the replay tail into ORDERED, under-budget frames so
+// no event in the recent window is lost (capReplayEvents truncates; this doesn't). Each
+// returned chunk is broadcast as its own `code-replay` — seqDedup.classifyReplay applies
+// them in order (each chunk is contiguous and seq > seqHi), so the client rebuilds the
+// whole window across frames. We keep the MOST RECENT `maxChunks * budget` bytes (older
+// history is the DB transcript snapshot's job) so a giant log doesn't fan out 30+ frames.
+// Returns an array of event-arrays, oldest chunk first; [] when there's nothing to send.
+export const REPLAY_MAX_CHUNKS = 6
+export function chunkReplayEvents(events, budget = REPLAY_BYTE_BUDGET, maxChunks = REPLAY_MAX_CHUNKS) {
+  if (!Array.isArray(events) || events.length === 0) return []
+  // Walk newest→oldest accumulating into the current chunk; start a new chunk when the
+  // next event would overflow the budget. Stop once we have maxChunks. A lone event
+  // larger than the whole budget still gets its own chunk (so seqHi can advance).
+  const chunksRev = []   // newest chunk first while building
+  let cur = [], curBytes = 0
+  for (let i = events.length - 1; i >= 0; i--) {
+    const sz = JSON.stringify(events[i]).length + 1
+    if (cur.length && curBytes + sz > budget) {
+      chunksRev.push(cur)
+      if (chunksRev.length >= maxChunks) { cur = null; break }
+      cur = [], curBytes = 0
+    }
+    cur.push(events[i])   // reversed within the chunk for now
+    curBytes += sz
+  }
+  if (cur && cur.length) chunksRev.push(cur)
+  // chunksRev is newest-chunk-first, each chunk newest-event-first → reverse both axes
+  // to oldest-first so classifyReplay applies them contiguously in arrival order.
+  return chunksRev.reverse().map((c) => c.reverse())
+}

package/package.json

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