thinkpool-pair 0.7.69 → 0.7.71

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, chunkReplayEvents } from './event-id.mjs'
+import { stampEvent, makeSeqCounter, maxSeq, seqable, capReplayEvents, chunkReplayEvents, boundEventForBroadcast } from './event-id.mjs'
 import { makeThrottledTrack } from './presence.mjs'
 
 // Public client creds (the same anon values the web app ships — safe to embed).
@@ -466,20 +466,22 @@ 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): bound it (truncates strings, strips oversized
+  // image/content blocks → render-safe placeholder).
+  if (p.evt && typeof p.evt === 'object') p.evt = boundEventForBroadcast(p.evt, 100000)
+  // replay batch (code-replay): bound every event…
+  if (Array.isArray(p.events)) {
+    p.events = p.events.map((e) => boundEventForBroadcast(e, 100000))
+    // …and if a frame is STILL over the limit, 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) => {
@@ -1028,7 +1030,11 @@ channel
       // (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
+      const rawTail = (from > 0 && !ahead) ? s.log.filter((e) => e.seq == null || e.seq > from) : s.log
+      // Bound each event so no single one (e.g. a 592KB inline-image tool_result) can
+      // overflow a frame on its own — chunkReplayEvents only bounds the SUM, not a lone
+      // giant event. boundEventForBroadcast clones+defangs only the oversized ones.
+      const tail = rawTail.map((e) => boundEventForBroadcast(e))
       // 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;

package/event-id.mjs

@@ -124,3 +124,36 @@ export function chunkReplayEvents(events, budget = REPLAY_BYTE_BUDGET, maxChunks
   // to oldest-first so classifyReplay applies them contiguously in arrival order.
   return chunksRev.reverse().map((c) => c.reverse())
 }
+
+// Bound a SINGLE event so it can never overflow a broadcast frame on its own. The worst
+// offenders are tool_results carrying inline base64 IMAGES (a 592KB screenshot block) —
+// these can't ride a size-capped Realtime broadcast at all (live OR replay). Truncate
+// bulky string fields AND replace oversized content blocks (images, huge text) with a
+// compact, render-SAFE text placeholder — preserving identity (kind/seq/cid/ts/toolUseId)
+// so dedup, ordering, seqHi, and turn structure stay intact. Returns the event UNCHANGED
+// (no clone) when it's already small; clones before mutating so the persisted log is never
+// touched. (Proper fix for inline images = upload to storage + broadcast a URL — separate.)
+export const PER_EVENT_CAP = 180000
+const truncStr = (s) => s.slice(0, 20000) + `\n…[truncated ${s.length - 20000} bytes — too large to broadcast]`
+export function boundEventForBroadcast(evt, cap = PER_EVENT_CAP) {
+  if (!evt || typeof evt !== 'object') return evt
+  let json
+  try { json = JSON.stringify(evt) } catch { return evt }
+  if (json.length <= cap) return evt
+  const out = { ...evt }
+  for (const k of ['text', 'output', 'stdout', 'stderr', 'input']) {
+    if (typeof out[k] === 'string' && out[k].length > 20000) out[k] = truncStr(out[k])
+  }
+  if (typeof out.content === 'string' && out.content.length > 20000) out.content = truncStr(out.content)
+  else if (Array.isArray(out.content)) {
+    out.content = out.content.map((b) => {
+      if (!b || typeof b !== 'object') return b
+      if (JSON.stringify(b).length <= 20000) return b
+      if (b.type === 'image') return { type: 'text', text: '[image omitted from replay — too large to broadcast; open the live session to view]' }
+      if (typeof b.text === 'string') return { ...b, text: truncStr(b.text) }
+      return { type: 'text', text: `[${b.type || 'content'} omitted — too large to broadcast]` }
+    })
+  }
+  out._bounded = true
+  return out
+}

package/package.json

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