thinkpool-pair 0.7.127 → 0.7.128

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'
@@ -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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.127",
+  "version": "0.7.128",
   "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)
+}