thinkpool-pair 0.7.127 → 0.7.129

package/bridge.mjs

@@ -34,6 +34,7 @@ import path from 'node:path'
 import readline from 'node:readline'
 import { spawn, execSync, execFileSync } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
+import { createRequire } from 'node:module'
 import { randomUUID } from 'node:crypto'
 import { createClient } from '@supabase/supabase-js'
 import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk'
@@ -82,7 +83,7 @@ const flowRedispatch = new Map()
 const flowBudgets = new Map()
 import { formatPeek, PEEK, siblingsOf, resolveSibling, crossPostDecision, CROSSPOST, spawnDecision, CROSSROOM, formatPairRoster, crossRoomPostDecision } from './cross-terminal.mjs'
 import { turnInFlight } from './update-gate.mjs'
-import { saveSession, flushSession, deleteSession, loadAll, canResume, loadPtyId, savePtyId, loadNames, saveNames, appendDurableEvents, seedDurableEvents, readDurablePage, readDurableOldestSeq } from './session-store.mjs'
+import { saveSession, flushSession, deleteSession, loadAll, canResume, loadPtyId, savePtyId, loadNames, saveNames, appendDurableEvents, seedDurableEvents, readDurablePage, readDurableOldestSeq, loadSummary, saveSummary } from './session-store.mjs'
 import { stampEvent, makeSeqCounter, maxSeq, seqable, capReplayEvents, chunkReplayEvents, boundEventForBroadcast, inlineImageBlocks } from './event-id.mjs'
 import { makeThrottledTrack } from './presence.mjs'
 
@@ -303,6 +304,51 @@ if ((!argv[0] || argv[0] === 'setup') && process.stdin.isTTY) {
   process.exit(0)
 }
 
+// ── agent-SDK compatibility gate ────────────────────────────────────────────
+// The SDK tracks a caret (^0.3.x), so a restart can auto-pull a NEW SDK, and its
+// interrupt/turn API has broken between 0.3.x minors before. Smoke-test the API
+// surface (offline, no tokens) the FIRST time a given SDK version is seen, so a
+// bad one is caught + surfaced loudly (stderr + the announce banner) instead of
+// silently breaking turns. sdkStatus feeds the announce. Fully guarded — a check
+// error never blocks serving.
+const SMOKE_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), 'sdk-smoke.mjs')
+let sdkStatus = { ok: null, version: 'unknown', reason: '' }
+function currentSdkVersion() {
+  try {
+    const req = createRequire(import.meta.url)
+    let d = path.dirname(req.resolve('@anthropic-ai/claude-agent-sdk'))
+    for (let i = 0; i < 8; i++) {
+      try { const p = JSON.parse(fs.readFileSync(path.join(d, 'package.json'), 'utf8')); if (p.name === '@anthropic-ai/claude-agent-sdk') return p.version } catch { /* keep walking */ }
+      const up = path.dirname(d); if (up === d) break; d = up
+    }
+  } catch { /* unresolved */ }
+  return 'unknown'
+}
+function runSmoke() {
+  try { return execFileSync(process.execPath, [SMOKE_PATH], { encoding: 'utf8', timeout: 22000, stdio: ['ignore', 'pipe', 'ignore'] }).trim() }
+  catch (e) { return (e.stdout || '').toString().trim() || `SMOKE:FAIL:${currentSdkVersion()}:${e.code === 'ETIMEDOUT' ? 'timeout' : (e.message || 'run error').slice(0, 80)}` }
+}
+if (argv[0] === 'verify-sdk') {
+  const out = runSmoke(); console.log(out); process.exit(/^SMOKE:PASS/.test(out) ? 0 : 1)
+}
+function checkSdkCompat() {
+  const dir = path.join(os.homedir(), '.thinkpool-pair'); const okFile = path.join(dir, 'sdk-ok')
+  const version = currentSdkVersion(); sdkStatus.version = version
+  let known = ''; try { known = fs.readFileSync(okFile, 'utf8').trim() } catch { /* none */ }
+  if (known && known === version) { sdkStatus.ok = true; return }   // this exact SDK already verified
+  const m = runSmoke().match(/^SMOKE:(PASS|FAIL):([^:\n]*)(?::(.*))?$/m)
+  if (m && m[1] === 'PASS') {
+    sdkStatus = { ok: true, version: m[2] || version, reason: '' }
+    try { fs.mkdirSync(dir, { recursive: true }); fs.writeFileSync(okFile, sdkStatus.version) } catch { /* noop */ }
+    process.stderr.write(`\n  ◆ agent SDK v${sdkStatus.version} passed the compatibility smoke test.\n`)
+  } else {
+    sdkStatus = { ok: false, version: (m && m[2]) || version, reason: (m && m[3]) || 'unknown' }
+    try { fs.mkdirSync(dir, { recursive: true }); fs.writeFileSync(path.join(dir, 'sdk-bad'), `${sdkStatus.version}: ${sdkStatus.reason}`) } catch { /* noop */ }
+    process.stderr.write(`\n  ⚠⚠ agent SDK v${sdkStatus.version} FAILED the compatibility smoke test — ${sdkStatus.reason}.\n  ⚠⚠ turns may misbehave. Pin a known-good SDK + restart:\n     bridge/package.json → "@anthropic-ai/claude-agent-sdk": "<good version>", then republish + Restart & update.\n`)
+  }
+}
+try { checkSdkCompat() } catch (e) { process.stderr.write(`  ⚠ SDK smoke check skipped: ${e.message}\n`) }
+
 if (!argv[0] || argv[0].startsWith('-')) { const { runAccount } = await import('./account.mjs'); await runAccount(SUPABASE_URL, SUPABASE_ANON) }
 
 const room = (argv[0] || '').toUpperCase().trim()
@@ -694,6 +740,9 @@ let roomModels = null
 const announce = () =>
   bcast('bridge', {
     v: 2, name, repo: repoLabel, branch: readBranch(),
+    // sdkWarn: the auto-pulled agent SDK failed its boot compatibility smoke test —
+    // surfaced so the room can show a banner (turns may misbehave; pin a good SDK).
+    ...(sdkStatus.ok === false ? { sdkWarn: `${sdkStatus.version}: ${sdkStatus.reason}` } : {}),
     // models: the SDK's supported-model list, so the /model picker shows the real
     // set (incl. Fable + version labels) on every device without hardcoding.
     models: roomModels || undefined,
@@ -2164,6 +2213,13 @@ channel
   // re-open within a page load).
   .on('broadcast', { event: 'code-summarize' }, async ({ payload }) => {
     const by = payload?.by || null
+    // Peek — any device opening the panel fetches the cached recap (cross-device +
+    // cross-restart persistence) WITHOUT spending a model call. No cache → silent.
+    if (payload?.peek) {
+      const cached = loadSummary(room)
+      if (cached && cached.text) bcast('code-summary', { status: 'done', ...cached })
+      return
+    }
     bcast('code-summary', { status: 'generating', by })
     try {
       // Pull assistant/user text out of a transcript-event array, keep the tail.
@@ -2204,18 +2260,23 @@ channel
         ? `\n\nThere are also ${closedIds.length} CLOSED terminal(s). Recent excerpts (do NOT name them individually):\n${(closedDigests.join('\n---\n') || '(no retained detail)').slice(0, 1400)}`
         : ''
 
-      const prompt = `Write a concise recap of this multi-terminal coding session for someone glancing at it. Rules:
-- NAME each LIVE terminal and say whether it is working or done, and briefly what it is doing/did.
-- Do NOT name the CLOSED terminals individually — fold them into ONE aggregate clause ("plus N closed lanes that handled …").
-- 2 to 4 sentences total, plain prose, no markdown, no headers, no bullet lists.
+      const prompt = `Summarize this multi-terminal coding session as a STRUCTURED LIST. Output ONLY these lines, nothing else:
+- ONE line per LIVE terminal, EXACTLY: <terminal name> | <working or done> | <one clause, max 12 words, no trailing period>
+- If there are CLOSED terminals, ONE final line, EXACTLY: CLOSED | <count> | <one aggregate clause about what they handled — do NOT name them>
+Use the pipe "|" as the separator. No headers, no markdown, no bullets, no extra prose. Example:
+Bridge Whip | working | SDK 0.7.128, detection gates live
+Reddit | done | GTM strategy mapped
+CLOSED | 52 | flow-trigger churn and @pool integration
 
 ${liveBlock}${closedBlock}
 
-Recap:`
+Output:`
 
       const res = await oneShotSummary({ prompt, env: env || process.env, cwd: cwd || process.cwd() })
       if (!res || !res.text) { bcast('code-summary', { status: 'error', error: 'Summary model unavailable on this provider.', by }); return }
-      bcast('code-summary', { status: 'done', text: res.text, model: res.model, generatedAt: Date.now(), by })
+      const summary = { text: res.text, model: res.model, generatedAt: Date.now() }
+      try { saveSummary(room, summary) } catch { /* cache is best-effort */ }
+      bcast('code-summary', { status: 'done', ...summary, by })
       process.stderr.write(`\n  ◆ session summary generated (${res.model}) for ${by || 'someone'}.\n`)
     } catch (e) {
       bcast('code-summary', { status: 'error', error: String(e?.message || e).slice(0, 140), by })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.127",
+  "version": "0.7.129",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -8,6 +8,7 @@
   },
   "files": [
     "bridge.mjs",
+    "sdk-smoke.mjs",
     "launcher.mjs",
     "byok-detect.mjs",
     "claude-session.mjs",

package/sdk-smoke.mjs

@@ -0,0 +1,60 @@
+// sdk-smoke.mjs — agent-SDK compatibility smoke test.
+//
+// The bridge tracks @anthropic-ai/claude-agent-sdk on a caret (^0.3.x), so a
+// restart can auto-pull a NEW SDK. Our own history (feedback_bridge_sdk_pin_no_bundle)
+// is that the SDK's interrupt/turn API has broken between 0.3.x minors. This verifies
+// the API SURFACE the bridge depends on — BEFORE the bridge commits to serving with a
+// freshly-pulled SDK — so a bad one is caught + surfaced instead of silently breaking
+// every turn.
+//
+// Deliberately CHEAP + OFFLINE: no Claude key, no network, no token spend. It only
+// checks that the SDK imports, query() constructs, and the control methods the bridge
+// calls (interrupt / setModel / setPermissionMode / supportedModels) exist as
+// functions. It does NOT run a real turn (that would cost tokens + need auth). A
+// surface break — a removed/renamed method — is the failure mode this guards; a subtle
+// behavioural break still needs a live turn (out of scope for a boot gate).
+//
+// Runs as a SHORT-LIVED SUBPROCESS with a hard timeout, so a hung SDK import/construct
+// = FAIL, never a hung bridge. One line to stdout: `SMOKE:PASS:<version>` /
+// `SMOKE:FAIL:<version>:<reason>`. Exit 0 = pass, 1 = incompatible, 2 = timeout.
+
+import { createRequire } from 'node:module'
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+const HARD_TIMEOUT_MS = Math.max(4000, parseInt(process.env.TP_SDK_SMOKE_TIMEOUT, 10) || 12000)
+const guard = setTimeout(() => { emit('FAIL', ver(), 'timeout importing/constructing the SDK'); process.exit(2) }, HARD_TIMEOUT_MS)
+
+function emit(status, version, reason) {
+  try { process.stdout.write(`SMOKE:${status}:${version || 'unknown'}${reason ? ':' + reason : ''}\n`) } catch { /* noop */ }
+}
+// Resolve the SDK's real version from wherever node just resolved the package (the
+// caret pick), by walking up from its entry to the package.json with the right name.
+function ver() {
+  try {
+    const require = createRequire(import.meta.url)
+    let d = dirname(require.resolve('@anthropic-ai/claude-agent-sdk'))
+    for (let i = 0; i < 8; i++) {
+      try { const p = JSON.parse(readFileSync(join(d, 'package.json'), 'utf8')); if (p.name === '@anthropic-ai/claude-agent-sdk') return p.version } catch { /* keep walking */ }
+      const up = dirname(d); if (up === d) break; d = up
+    }
+  } catch { /* unresolved */ }
+  return 'unknown'
+}
+
+const version = ver()
+try {
+  const sdk = await import('@anthropic-ai/claude-agent-sdk')
+  if (typeof sdk.query !== 'function') { emit('FAIL', version, 'query is not a function'); clearTimeout(guard); process.exit(1) }
+  async function* noInput() { return }   // ends immediately — never blocks the construct
+  const q = sdk.query({ prompt: noInput(), options: { permissionMode: 'default' } })
+  const need = ['interrupt', 'setModel', 'setPermissionMode', 'supportedModels']
+  const missing = need.filter((m) => typeof q?.[m] !== 'function')
+  try { q?.interrupt?.() } catch { /* don't leave it running */ }
+  if (missing.length) { emit('FAIL', version, `missing methods: ${missing.join('/')}`); clearTimeout(guard); process.exit(1) }
+  emit('PASS', version)
+  clearTimeout(guard); process.exit(0)
+} catch (e) {
+  emit('FAIL', version, `import/construct threw: ${(e?.message || e).toString().slice(0, 120)}`)
+  clearTimeout(guard); process.exit(1)
+}

package/session-store.mjs

@@ -191,3 +191,14 @@ export function loadNames(room) {
 export function saveNames(room, names) {
   try { ensureDir(room); fs.writeFileSync(namesFile(room), JSON.stringify(names || {})) } catch { /* noop */ }
 }
+
+// Session recap cache (2026-07-02, Session Info panel). The last on-demand summary,
+// stored as a dotfile (NOT *.json → never in loadAll) so it survives a bridge restart
+// and any device that opens the panel can fetch it (persists across devices). One per room.
+const summaryFile = (room) => path.join(dir(room), '.summary')
+export function loadSummary(room) {
+  try { return JSON.parse(fs.readFileSync(summaryFile(room), 'utf8')) || null } catch { return null }
+}
+export function saveSummary(room, summary) {
+  try { ensureDir(room); fs.writeFileSync(summaryFile(room), JSON.stringify(summary || null)) } catch { /* noop */ }
+}