thinkpool-pair 0.3.6 → 0.5.0

package/bridge.mjs

@@ -7,6 +7,16 @@
      npx thinkpool-pair <ROOM> -- <cmd…>   # share a specific CLI (skip the picker)
      npx thinkpool-pair <ROOM> --headless  # pure relay — terminals open from the web
 
+   v0.5 — continue, don't restart: when the picked agent supports
+   resuming (Claude Code: `--continue` = most recent conversation in
+   THIS directory) and a prior session exists here, the bridge offers to
+   continue it instead of starting fresh — quit your running agent, run
+   the bridge in the same directory, and you're back in the same
+   conversation, now shared. `--continue` / `--fresh` skip the question.
+   (True attach to a live process was ruled out: reptyr-style TTY
+   hijacking is Linux-only and SIP-blocked on macOS.)
+   v0.4 — room file drops: files dropped/pasted in the web room download
+   to a temp dir here (file-put → file-done) so the agent can read them.
    v0.3 — multi-terminal. The bridge is your machine's presence in the
    room; terminals are things you open inside it. Your first agent runs
    ATTACHED (your own terminal, exactly as before). The web's
@@ -47,8 +57,12 @@ catch {
 // Order = display order; Claude Code stays first (the original default). The
 // picker only offers the ones actually installed (PATH probe below). Power
 // users can bypass it entirely with `-- <any command>`.
+// `resume` marks agents where continuing the latest session is a SAFE,
+// verified flag (wrong flags kill the spawn → bridge exits — only add
+// agents after checking the real CLI). probe() must be cheap + read-only;
+// a miss just means "continue" isn't offered.
 const KNOWN_AGENTS = [
-  { label: 'Claude Code', cmd: 'claude' },
+  { label: 'Claude Code', cmd: 'claude', resume: { args: ['--continue'], probe: claudeHasSession } },
   { label: 'Codex CLI',   cmd: 'codex' },
   { label: 'Gemini CLI',  cmd: 'gemini' },
   { label: 'Aider',       cmd: 'aider' },
@@ -60,6 +74,16 @@ const KNOWN_AGENTS = [
   { label: 'Qwen Code',   cmd: 'qwen' },
 ]
 
+// Does Claude Code have a resumable conversation for THIS directory?
+// Sessions live under ~/.claude/projects/<cwd with [/\.:] → '-'> (one
+// subdir per session). Read-only probe; any miss = no "continue" offer.
+function claudeHasSession() {
+  try {
+    const slug = path.resolve(process.cwd()).replace(/[/\\.:]/g, '-')
+    return fs.readdirSync(path.join(os.homedir(), '.claude', 'projects', slug)).length > 0
+  } catch { return false }
+}
+
 // Is `c` on PATH? Pure-Node scan (no `which` subprocess), cross-platform.
 const onPath = (c) => {
   const exts = process.platform === 'win32'
@@ -92,11 +116,23 @@ const pickAgent = (installed) => new Promise((resolve) => {
 
 const argv = process.argv.slice(2)
 const room = (argv[0] || '').toUpperCase().trim()
-if (!room || room.startsWith('-')) { console.error('usage: npx thinkpool-pair <ROOM> [--headless] [-- <command…>]'); process.exit(1) }
+if (!room || room.startsWith('-')) { console.error('usage: npx thinkpool-pair <ROOM> [--headless] [--continue|--fresh] [-- <command…>]'); process.exit(1) }
 const headless = argv.includes('--headless')
 const installedAgents = KNOWN_AGENTS.filter(a => onPath(a.cmd))
 const dashIdx = argv.indexOf('--')
-let attachedCmd = null, attachedArgs = []
+// Own flags are only read from BEFORE `--`; after it, every token belongs
+// to the shared command (`-- claude --continue` must not trip these).
+const ownArgs = dashIdx >= 0 ? argv.slice(0, dashIdx) : argv
+const forceContinue = ownArgs.includes('--continue')
+const forceFresh    = ownArgs.includes('--fresh')
+
+// One yes/no on the bridge's stderr (same channel as the agent picker).
+const askYesNo = (q) => new Promise((resolve) => {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr })
+  rl.question(q, (ans) => { rl.close(); resolve(!/^n/i.test(String(ans).trim())) })
+})
+
+let attachedCmd = null, attachedArgs = [], continuing = false
 if (dashIdx >= 0) {
   ;[attachedCmd, ...attachedArgs] = argv.slice(dashIdx + 1)
 } else if (!headless) {
@@ -105,6 +141,18 @@ if (dashIdx >= 0) {
     process.exit(1)
   }
   attachedCmd = await pickAgent(installedAgents)
+  // Continue the latest session instead of starting fresh — offered only
+  // when the agent supports it AND a prior session exists in this cwd.
+  // --continue forces it (your call even if the probe misses); --fresh
+  // skips the question; non-TTY stays fresh (no surprise in scripts).
+  const agent = KNOWN_AGENTS.find(a => a.cmd === attachedCmd)
+  if (agent?.resume && !forceFresh) {
+    if (forceContinue) continuing = true
+    else if (process.stdin.isTTY && agent.resume.probe()) {
+      continuing = await askYesNo(`\n  Continue your latest ${agent.label} session in this directory? [Y/n] `)
+    }
+    if (continuing) attachedArgs = [...agent.resume.args]
+  }
 }
 const name = process.env.TP_NAME || os.userInfo().username || 'host'
 
@@ -118,6 +166,17 @@ try {
   branch = head.startsWith('ref:') ? head.split('/').pop() : head.slice(0, 7)
 } catch { /* not a git repo — fine */ }
 
+// ── room file drops ────────────────────────────────────────────────
+// Files dropped/pasted in the web room arrive as `file-put { id, name, url }`
+// (a 1h signed Storage URL) — download to a per-room temp dir and answer
+// `file-done { id, path }`. The filename rule <id8>-<safe> is DETERMINISTIC
+// and shared with the web client, which computes host paths from the
+// announced `updir` without waiting on this round-trip. Spec:
+// docs/specs/2026-06-11-code-file-drop.md
+const UPDIR = path.join(os.tmpdir(), 'thinkpool-pair', room)
+const FILE_MAX_BYTES = 10 * 1024 * 1024
+const safeName = (n) => String(n || 'file').replace(/[^a-zA-Z0-9._-]/g, '_').slice(-80)
+
 const supabase = createClient(SUPABASE_URL, SUPABASE_ANON, {
   realtime: { params: { eventsPerSecond: 60 } },
 })
@@ -131,14 +190,33 @@ const terms = new Map()
 let attachedId = null
 let shuttingDown = false
 
+// One send door for every broadcast. supabase-js ≥2.10x deprecation-warns
+// (console.warn) whenever send() silently falls back to REST because the
+// socket can't push — at the flush timer's 28×/s that's a wall of warnings
+// straight into the host's ATTACHED terminal, shredding the TUI
+// (2026-06-11). Same delivery, explicit path, no warning: httpSend when
+// the socket is down. Loss on total offline is fine — scrollback replays.
+const bcast = (event, payload) => {
+  try {
+    if (channel.channelAdapter?.canPush?.() ?? true) {
+      channel.send({ type: 'broadcast', event, payload })
+    } else {
+      channel.httpSend(event, payload).catch(() => { /* offline — replay covers it */ })
+    }
+  } catch { /* noop */ }
+}
+
 const announce = () =>
-  channel.send({ type: 'broadcast', event: 'bridge', payload: {
+  bcast('bridge', {
     v: 2, name, repo: repoLabel, branch,
+    // updir: where room file-drops land (forward-slash normalised — the web
+    // client string-joins host paths onto it; Node accepts `/` on Windows).
+    updir: UPDIR.split(path.sep).join('/'),
     agents: installedAgents,
     // cols/rows: the PTY's one true size — web viewers render this grid and
     // scale it to their own page instead of voting to reflow it.
     terms: [...terms.entries()].map(([id, t]) => ({ id, cmd: t.cmd, alive: true, cols: t.term.cols, rows: t.term.rows })),
-  } })
+  })
 
 // One flush timer batches every terminal's pending bytes (~35ms cadence).
 const flushAll = () => {
@@ -146,7 +224,7 @@ const flushAll = () => {
     if (!t.buf) continue
     const b64 = Buffer.from(t.buf, 'utf8').toString('base64')
     t.buf = ''
-    channel.send({ type: 'broadcast', event: 'pty-out', payload: { term: id, b64 } })
+    bcast('pty-out', { term: id, b64 })
   }
 }
 const flushTimer = setInterval(flushAll, 35)
@@ -194,7 +272,7 @@ function openTerm({ id, cmd, args = [], attached = false, cols, rows }) {
     terms.delete(id)
     if (id === attachedId) { attachedId = null; detachLocal() }
     if (shuttingDown) return
-    try { channel.send({ type: 'broadcast', event: 'term-exit', payload: { id } }) } catch { /* noop */ }
+    bcast('term-exit', { id })
     announce()
     if (terms.size === 0 && !headless) shutdown()
     else process.stderr.write(`\n  ◇ terminal "${cmd}" ended — still relaying ${terms.size} terminal(s). Ctrl-C to stop.\n`)
@@ -259,13 +337,33 @@ channel
     flushAll()
     for (const [id, t] of terms) {
       if (!t.scrollback) continue
-      channel.send({ type: 'broadcast', event: 'pty-replay', payload: {
+      bcast('pty-replay', {
         to: payload?.to ?? null, term: id,
         b64: Buffer.from(t.scrollback, 'utf8').toString('base64'),
-      } })
+      })
     }
     announce()
   })
+  .on('broadcast', { event: 'file-put' }, ({ payload }) => {
+    if (!payload?.id || !payload?.url) return
+    // Multi-bridge rooms: targeted like term-open; untargeted = solo case.
+    if (payload.host && payload.host !== name) return
+    ;(async () => {
+      try {
+        const r = await fetch(payload.url)
+        if (!r.ok) throw new Error(`HTTP ${r.status}`)
+        const buf = Buffer.from(await r.arrayBuffer())
+        if (buf.length > FILE_MAX_BYTES) throw new Error('file too large')
+        fs.mkdirSync(UPDIR, { recursive: true })
+        const fp = path.join(UPDIR, `${String(payload.id).slice(0, 8)}-${safeName(payload.name)}`)
+        fs.writeFileSync(fp, buf)
+        process.stderr.write(`\n  ◆ file from the room: ${fp}\n`)
+        bcast('file-done', { id: payload.id, path: fp.split(path.sep).join('/'), host: name })
+      } catch (e) {
+        process.stderr.write(`\n  ◇ room file download failed (${safeName(payload.name) || payload.id}): ${e.message}\n`)
+      }
+    })()
+  })
   .on('broadcast', { event: 'who' }, announce)
   .subscribe(status => {
     if (status === 'SUBSCRIBED') {
@@ -274,7 +372,7 @@ channel
       announce()
       process.stderr.write(headless
         ? `\n  ◆ thinkpool — relaying room ${room} (headless). Open terminals from the web UI.\n\n`
-        : `\n  ◆ thinkpool — sharing "${attachedCmd}" into room ${room}.  Open the web UI and you're both in.\n\n`)
+        : `\n  ◆ thinkpool — sharing "${attachedCmd}"${continuing ? ' (continuing your latest session)' : ''} into room ${room}.  Open the web UI and you're both in.\n\n`)
     }
   })
 
@@ -284,7 +382,7 @@ function shutdown() {
   clearInterval(flushTimer)
   try {
     const bye = Buffer.from('\r\n[ shared session ended ]\r\n', 'utf8').toString('base64')
-    for (const id of terms.keys()) channel.send({ type: 'broadcast', event: 'pty-out', payload: { term: id, b64: bye } })
+    for (const id of terms.keys()) bcast('pty-out', { term: id, b64: bye })
   } catch { /* noop */ }
   try { supabase.removeChannel(channel) } catch { /* noop */ }
   for (const t of terms.values()) { try { t.term.kill() } catch { /* noop */ } }

package/package.json

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