thinkpool-pair 0.6.5 → 0.6.7

package/bridge.mjs

@@ -35,6 +35,7 @@ import readline from 'node:readline'
 import { randomUUID } from 'node:crypto'
 import { createClient } from '@supabase/supabase-js'
 import { startClaudeSession } from './claude-session.mjs'
+import { saveSession, flushSession, loadLatest, canResume } from './session-store.mjs'
 
 // Public client creds (the same anon values the web app ships — safe to embed).
 // Override with TP_SUPABASE_URL / TP_SUPABASE_ANON if you ever need to.
@@ -313,25 +314,84 @@ function openTerm({ id, cmd, args = [], attached = false, cols, rows }) {
 // SDK and relay STRUCTURED events. onEvent → broadcast `code-event`;
 // every tool call round-trips through `code-perm-req`/`code-perm` (the
 // risk-tiered permission card). A rolling event log replays to joiners.
-const STRUCTURED_LOG_MAX = 400
-function openStructured({ id, model, resume }) {
+const STRUCTURED_LOG_MAX = 2000
+
+// ── host-local pretty printer — whoever runs the bridge sees the live session
+// in their own terminal too, not only the web reader. Minimal ANSI; mirrors the
+// structured reader's shapes (you / assistant / tool / result / pool / note).
+const A = { dim: '\x1b[2m', rst: '\x1b[0m', cyan: '\x1b[36m', mag: '\x1b[35m', grn: '\x1b[32m', yel: '\x1b[33m', red: '\x1b[31m' }
+const argStr = (i) => { const v = i && (i.command || i.file_path || i.path || i.pattern || i.url || i.query || i.description); return v ? ' ' + String(v).replace(/\s+/g, ' ').slice(0, 100) : '' }
+function printLocal(evt) {
+  const w = (s) => process.stderr.write(s + '\n')
+  switch (evt.kind) {
+    case 'you': return w(`${A.cyan}❯ ${evt.text}${A.rst}${evt.by ? ` ${A.dim}(${evt.by})${A.rst}` : ''}`)
+    case 'chat': return w(`${A.dim}${evt.by}: ${evt.text}${A.rst}`)
+    case 'whisper': return w(`${A.dim}// ${evt.by}: ${evt.text}${A.rst}`)
+    case 'pool': return w(evt.pending ? `${A.cyan}◌ pool synthesizing…${A.rst}` : `${A.cyan}◆ pool → ${evt.text}${A.rst}`)
+    case 'note': return w(`${A.dim}— ${evt.text} —${A.rst}`)
+    case 'clear': return w(`${A.dim}— context cleared —${A.rst}`)
+    case 'usage': { const c = evt.ctx; return c ? w(`${A.dim}  ctx ${c.pct}% · ${Math.round(c.used / 1000)}k/${Math.round(c.max / 1000)}k${evt.costUsd != null ? ` · $${evt.costUsd.toFixed(3)}` : ''}${A.rst}`) : undefined }
+    case 'error': return w(`${A.red}✗ ${evt.message}${A.rst}`)
+    case 'tool_result': {
+      const c = evt.content
+      const t = (typeof c === 'string' ? c : Array.isArray(c) ? c.map((x) => x?.text || '').join(' ') : '').replace(/\s+/g, ' ').slice(0, 120)
+      return w(`  ${evt.isError ? A.red : A.dim}⎿ ${t || (evt.isError ? 'error' : 'ok')}${A.rst}`)
+    }
+    case 'assistant':
+      for (const b of (evt.blocks || [])) {
+        if (b.type === 'text' && b.text?.trim()) w(`${A.grn}⏺${A.rst} ${b.text.trim()}`)
+        else if (b.type === 'thinking' && b.text?.trim()) w(`${A.dim}✶ ${b.text.trim().slice(0, 160)}${A.rst}`)
+        else if (b.type === 'tool_use') w(`  ${A.cyan}${b.name}${A.rst}${argStr(b.input)}`)
+      }
+      return
+    default: return undefined
+  }
+}
+
+// The Phase-2 path: instead of a PTY, run Claude Code through the Agent SDK and
+// relay STRUCTURED events. onEvent → broadcast `code-event` + print locally +
+// persist to the host file; tool calls round-trip through the perm card; the
+// rolling log replays to joiners and survives bridge restarts (session-store).
+function openStructured({ id, model, resume, log }) {
   if (sessions.has(id)) return
-  const entry = { cmd: 'claude', kind: 'structured', log: [], pending: new Map(), session: null }
+  const entry = { cmd: 'claude', kind: 'structured', log: Array.isArray(log) ? log.slice(-STRUCTURED_LOG_MAX) : [], pending: new Map(), session: null, recovered: false }
   sessions.set(id, entry)
+  if (entry.log.length) process.stderr.write(`\n  ◆ restored ${entry.log.length} prior events (${id.slice(0, 8)})${resume ? ' + resuming live context' : ''}.\n`)
+  const persist = () => saveSession(room, id, { sessionId: entry.session?.sessionId || resume || null, log: entry.log })
   entry.session = startClaudeSession({
     cwd: process.cwd(), model, resume,
     onEvent: (evt) => {
-      entry.log.push(evt)
-      if (entry.log.length > STRUCTURED_LOG_MAX) entry.log.shift()
+      // Self-heal a stale resume — the saved SDK session expired. Reopen fresh,
+      // keeping the transcript (scrollback survives; live context is gone).
+      if (resume && !entry.recovered && evt.kind === 'error' && /No conversation found/i.test(evt.message || '')) {
+        entry.recovered = true
+        process.stderr.write(`\n  ◆ saved session expired — starting fresh (transcript kept).\n`)
+        try { entry.session?.end() } catch { /* noop */ }
+        sessions.delete(id)
+        openStructured({ id, model, log: entry.log })
+        return
+      }
+      // Chrome events (mode / usage / clear) are transient state, not transcript —
+      // broadcast + print them, but keep them out of the persisted/replayed log.
+      const chrome = evt.kind === 'mode' || evt.kind === 'usage' || evt.kind === 'clear'
+      if (!chrome) {
+        entry.log.push(evt)
+        if (entry.log.length > STRUCTURED_LOG_MAX) entry.log.shift()
+      }
       bcast('code-event', { term: id, evt })
+      printLocal(evt)
+      if (!chrome) persist()
     },
     requestPermission: (req) => new Promise((resolve) => {
       entry.pending.set(req.id, resolve)
       bcast('code-perm-req', { term: id, id: req.id, toolName: req.toolName, input: req.input, risk: req.risk, plan: req.plan })
+      process.stderr.write(req.risk === 'plan'
+        ? `\n  ${A.mag}◆ plan ready — approve in the room.${A.rst}\n`
+        : `\n  ${A.yel}● permission: ${req.toolName}${argStr(req.input)} — approve in the room.${A.rst}\n`)
     }),
   })
   announce()
-  process.stderr.write(`\n  ◆ structured Claude session (${id.slice(0, 8)}) — driven from the room.\n`)
+  if (!entry.log.length) process.stderr.write(`\n  ◆ structured Claude session (${id.slice(0, 8)}) — driven from the room.\n`)
   return entry
 }
 
@@ -463,6 +523,7 @@ channel
     if (/^\/clear\s*$/.test(text)) {
       echoYou(); s.session.sendTurn(text)
       s.log = []; bcast('code-event', { term: payload.term, evt: { kind: 'clear' } })
+      flushSession(room, payload.term, { sessionId: s.session?.sessionId || null, log: [] })
       return
     }
     s.session.sendTurn(text)
@@ -493,7 +554,13 @@ channel
       channel.track({ name, role: 'bridge' })
       if (attachedCmd && !terms.size && !sessions.size) {
         // Claude + structured mode → Agent SDK session; everything else → PTY.
-        if (wantStructured(attachedCmd)) openStructured({ id: randomUUID() })
+        // On restart, restore the latest saved structured session for this room:
+        // replay its transcript + resume the live SDK context if recent enough.
+        if (wantStructured(attachedCmd)) {
+          const prev = loadLatest(room)
+          if (prev && (prev.log?.length || prev.sessionId)) openStructured({ id: prev.id, resume: canResume(prev) ? prev.sessionId : undefined, log: prev.log })
+          else openStructured({ id: randomUUID() })
+        }
         else openTerm({ id: randomUUID(), cmd: attachedCmd, args: attachedArgs, attached: true })
       }
       announce()

package/claude-session.mjs

@@ -91,6 +91,7 @@ export function startClaudeSession({ cwd, model, resume, onEvent, requestPermiss
   let q = null            // the live Query — control requests (interrupt /
                           // setPermissionMode) route through it once streaming.
   let mode = 'default'    // mirrors Claude Code's ⇧⇥ cycle
+  const alwaysAllow = new Set()  // tool:risk signatures the user chose "don't ask again" for
 
   const emit = (evt) => { try { onEvent?.(evt) } catch { /* never let a consumer throw into the loop */ } }
 
@@ -120,15 +121,21 @@ export function startClaudeSession({ cwd, model, resume, onEvent, requestPermiss
       return { continue: true, hookSpecificOutput: { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: 'The user chose "keep planning" in the ThinkPool room. Do not exit plan mode — keep refining the plan, then call ExitPlanMode again when ready.' } }
     }
     const risk = classifyRisk(toolName, toolInput)
+    // "Don't ask again" is keyed by tool + risk tier, so allowing medium Bash
+    // never silently allows a future destructive one (high always re-asks).
+    const sig = `${toolName}:${risk}`
     const auto =
       risk === 'low' ||
       mode === 'bypassPermissions' ||
-      (mode === 'acceptEdits' && WRITE_TOOLS.has(toolName) && risk !== 'high')
+      (mode === 'acceptEdits' && WRITE_TOOLS.has(toolName) && risk !== 'high') ||
+      alwaysAllow.has(sig)
     let decision = 'allow'
     if (!auto) {
       try {
         decision = await requestPermission?.({ id: randomUUID(), toolName, input: toolInput, risk }) ?? 'allow'
       } catch { decision = 'deny' } // a broken permission path must fail safe (deny)
+      // "Allow & don't ask again" — remember the signature, then allow.
+      if (decision === 'always') { alwaysAllow.add(sig); decision = 'allow' }
     }
     // On deny, permissionDecisionReason IS what the model receives as the
     // tool error — make it a real instruction, not an opaque tag.
@@ -178,6 +185,17 @@ export function startClaudeSession({ cwd, model, resume, onEvent, requestPermiss
           case 'result':
             if (m.session_id) sessionId = m.session_id
             emit({ kind: 'result', subtype: m.subtype, sessionId, costUsd: m.total_cost_usd, usage: m.usage, numTurns: m.num_turns })
+            // Surface a usage/context meter (chrome, not a transcript line). The
+            // context window % comes from the control request; cost is cumulative.
+            ;(async () => {
+              let ctx = null
+              try {
+                const c = await q?.getContextUsage?.()
+                if (c) ctx = { used: c.totalTokens, max: c.maxTokens, pct: Math.round(c.percentage), model: c.model }
+              } catch { /* control req may be unavailable */ }
+              const u = m.usage || {}
+              emit({ kind: 'usage', costUsd: m.total_cost_usd ?? null, tokens: (u.input_tokens || 0) + (u.output_tokens || 0), ctx })
+            })()
             break
           default:
             break

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.6.5",
+  "version": "0.6.7",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   "files": [
     "bridge.mjs",
     "claude-session.mjs",
+    "session-store.mjs",
     "README.md"
   ],
   "scripts": {

package/session-store.mjs

@@ -0,0 +1,57 @@
+/* ─────────────────────────────────────────────────────────────
+   session-store.mjs — durable scrollback for structured Claude
+   sessions, "file now" tier (no DB). Each structured session's
+   event log + its SDK sessionId are written to a per-room file on
+   the host (~/.thinkpool-pair/<ROOM>/<id>.json), debounced. On a
+   bridge restart the latest session is reloaded: the transcript
+   replays immediately, and (if recent) the SDK session resumes so
+   the live context survives too. A DB-backed tier comes later.
+   ───────────────────────────────────────────────────────────── */
+
+import os from 'node:os'
+import fs from 'node:fs'
+import path from 'node:path'
+
+const ROOT = path.join(os.homedir(), '.thinkpool-pair')
+const dir = (room) => path.join(ROOT, room || 'default')
+// Only resume the live SDK context for recent sessions — an expired session id
+// fails ("No conversation found"); past this window we restore transcript only.
+const RESUME_MAX_AGE_MS = 12 * 60 * 60 * 1000
+const KEEP = 8   // newest N session files per room
+
+function ensureDir(room) { try { fs.mkdirSync(dir(room), { recursive: true }) } catch { /* noop */ } }
+function listRecs(room) {
+  try {
+    return fs.readdirSync(dir(room)).filter((f) => f.endsWith('.json'))
+      .map((f) => { try { return JSON.parse(fs.readFileSync(path.join(dir(room), f), 'utf8')) } catch { return null } })
+      .filter(Boolean)
+  } catch { return [] }
+}
+function prune(room) {
+  try {
+    const files = fs.readdirSync(dir(room)).filter((f) => f.endsWith('.json'))
+      .map((f) => { const p = path.join(dir(room), f); let m = 0; try { m = JSON.parse(fs.readFileSync(p, 'utf8')).savedAt || 0 } catch { /* noop */ } return { p, m } })
+      .sort((a, b) => b.m - a.m)
+    files.slice(KEEP).forEach((x) => { try { fs.unlinkSync(x.p) } catch { /* noop */ } })
+  } catch { /* noop */ }
+}
+
+const timers = new Map()
+function write(room, id, data) {
+  try { ensureDir(room); fs.writeFileSync(path.join(dir(room), `${id}.json`), JSON.stringify({ ...data, id, savedAt: Date.now() })); prune(room) } catch { /* noop */ }
+}
+// Debounced — events arrive in bursts; one write per ~1.5s is plenty.
+export function saveSession(room, id, data) {
+  clearTimeout(timers.get(id))
+  timers.set(id, setTimeout(() => write(room, id, data), 1500))
+}
+export function flushSession(room, id, data) { clearTimeout(timers.get(id)); write(room, id, data) }
+
+// Most-recently-saved structured session for the room (drives attached restore).
+export function loadLatest(room) {
+  const recs = listRecs(room).sort((a, b) => (b.savedAt || 0) - (a.savedAt || 0))
+  return recs[0] || null
+}
+export function canResume(rec) {
+  return !!(rec && rec.sessionId && rec.savedAt && (Date.now() - rec.savedAt) < RESUME_MAX_AGE_MS)
+}