@claudecollab/cli 0.1.2 → 0.2.0

package/packages/cli/src/brain/card.js

@@ -16,6 +16,7 @@
 //   ── you're live ──
 
 import { ROLE_GLYPH, stringWidth, truncateToWidth } from '../renderer.js';
+import { stripControls } from './log.js';
 
 // Keep the box comfortably inside an 80-col floor: content ≤ 74 ⇒ box ≤ 78.
 const MAX_INNER = 74;
@@ -63,8 +64,11 @@ export function build(state, log, {
   const joiner = state.get(joinerId);
   const others = state.list().filter((p) => p.id !== joinerId);
 
-  const peopleStr = others.map((p) => `${p.name}${glyph(p.role)}`).join(' ');
-  const joinStr = joiner ? `you join as ${joiner.name}${glyph(joiner.role)}` : '';
+  // Names and prompt snippets are UNTRUSTED (a pasted name/prompt could carry raw
+  // ESC/OSC) and this card is printed straight into every joiner's terminal —
+  // sanitize each display copy before it lands in the box.
+  const peopleStr = others.map((p) => `${stripControls(p.name)}${glyph(p.role)}`).join(' ');
+  const joinStr = joiner ? `you join as ${stripControls(joiner.name)}${glyph(joiner.role)}` : '';
 
   const rows = [];
   rows.push(`people   ${peopleStr}${joinStr ? ` · ${joinStr}` : ''}`);
@@ -74,7 +78,7 @@ export function build(state, log, {
   if (recent.length === 0) {
     rows.push('  (none yet)');
   } else {
-    for (const p of recent) rows.push(`  ${p.author} → "${p.text}" (${relAgo(now() - p.at)})`);
+    for (const p of recent) rows.push(`  ${stripControls(p.author)} → "${stripControls(p.text)}" (${relAgo(now() - p.at)})`);
   }
   const files = log.files;
   const shown = files.slice(0, maxFiles);

package/packages/cli/src/brain/commands.js

@@ -72,8 +72,12 @@ export function parse(text) {
       }
       return { name, error: QUEUE_USAGE };
     }
+    case 'end':
+      // /end saves session.md by default; /end nosave honors the browser's
+      // "Just end" (and any host who typed it) so nothing is written to disk.
+      return { name, save: (parts[1] ?? '').toLowerCase() !== 'nosave' };
     default:
-      // pause | resume | recap | end — no arguments
+      // pause | resume | recap — no arguments
       return { name };
   }
 }

package/packages/cli/src/brain/history.js

@@ -0,0 +1,72 @@
+// The room's turn history — every prompt sent to Claude, attributed to the person
+// who sent it, paired with Claude's response. This is what each person's window
+// shows: "who typed what", and what Claude answered.
+//
+// A turn opens when a queued prompt is actually written to Claude (the drain edge)
+// and closes when Claude finishes (the Stop hook), at which point the response text
+// is attached. At most one turn is open at a time — Claude runs one prompt per idle.
+//
+// The log lives only for the session (matches how rooms already work: a relay
+// restart ends them). Only a bounded tail is kept so the state snapshot the browser
+// polls can never grow without limit.
+
+const MAX_TURNS = 60;
+
+export class History {
+  /** @type {{id:number, author:string, prompt:string, response:string, running:boolean, at:number}[]} */
+  #turns = [];
+  #openId = null; // id of the turn awaiting a response, or null
+  #seq = 0;
+  #now;
+
+  /** @param {object} [opts] @param {() => number} [opts.now] injectable clock */
+  constructor({ now = () => Date.now() } = {}) {
+    this.#now = now;
+  }
+
+  /**
+   * Open a turn: a prompt has just gone to Claude. Returns the turn id.
+   * @param {string} author  participant id who sent it
+   * @param {string} prompt  the prompt text
+   */
+  start(author, prompt) {
+    const id = ++this.#seq;
+    this.#turns.push({ id, author, prompt: String(prompt ?? ''), response: '', running: true, at: this.#now() });
+    if (this.#turns.length > MAX_TURNS) this.#turns.shift();
+    this.#openId = id;
+    return id;
+  }
+
+  /** Is a turn currently awaiting its response? */
+  get open() {
+    return this.#openId != null;
+  }
+
+  /**
+   * Close the open turn with Claude's response text. No-op if nothing is open
+   * (e.g. a prompt typed straight into Claude, not from a window).
+   * @param {string} response
+   */
+  finish(response) {
+    if (this.#openId == null) return false;
+    const turn = this.#turns.find((t) => t.id === this.#openId);
+    if (turn) {
+      turn.response = String(response ?? '');
+      turn.running = false;
+    }
+    this.#openId = null;
+    return true;
+  }
+
+  /** Renderer-facing serialisation: plain objects, oldest→newest. */
+  snapshot() {
+    return this.#turns.map((t) => ({
+      id: t.id,
+      author: t.author,
+      prompt: t.prompt,
+      response: t.response,
+      running: t.running,
+      at: t.at,
+    }));
+  }
+}

package/packages/cli/src/brain/log.js

@@ -11,6 +11,24 @@
 
 import fs from 'node:fs';
 
+// Escape-injection guard: display copies only — pty-bound text stays raw (Claude
+// must receive real bytes, including newlines). Pasted prompts land verbatim in
+// join cards, the shared log, and session.md; a raw ESC/OSC/BEL there would inject
+// terminal escapes into every guest's terminal and the saved file. This strips
+// ANSI/OSC sequences wholesale, then any remaining C0 controls + DEL — but keeps
+// \n and \t so multi-line prompts and tabs survive as plain text.
+const ANSI = /\x1b(?:\[[0-?]*[ -\/]*[@-~]|\][^\x07\x1b]*(?:\x07|\x1b\\)?|[@-Z\\-_])/g;
+
+/**
+ * Remove terminal control/escape sequences from a string, keeping printable text
+ * plus newlines and tabs. Safe to run on any untrusted display string.
+ * @param {string} s
+ * @returns {string}
+ */
+export function stripControls(s) {
+  return String(s).replace(ANSI, '').replace(/[\x00-\x08\x0b-\x1f\x7f]/g, '');
+}
+
 export class Log {
   #entries = [];
   #files = [];
@@ -23,16 +41,16 @@ export class Log {
     this.#startedAt = now();
   }
 
-  /** Record an attributed prompt. */
+  /** Record an attributed prompt (sanitized for display — the raw text still went to the pty). */
   prompt(author, text, at = this.#now()) {
-    const e = { kind: 'prompt', author, text: String(text), at };
+    const e = { kind: 'prompt', author: stripControls(author), text: stripControls(text), at };
     this.#entries.push(e);
     return e;
   }
 
   /** Record a room event (join/leave/role/kick/mode/pause). */
   event(text, at = this.#now()) {
-    const e = { kind: 'event', text: String(text), at };
+    const e = { kind: 'event', text: stripControls(text), at };
     this.#entries.push(e);
     return e;
   }

package/packages/cli/src/brain/state.js

@@ -33,6 +33,19 @@ export function atLeast(role, min) {
 export const FLOOR_COLS = 80;
 export const FLOOR_ROWS = 24;
 
+/**
+ * A scaled viewer reports the sentinel size 0×0 — "I scale, ignore my size". A
+ * browser tab below the 80×24 floor sends this instead of its real (tiny) size so
+ * the host renders the shared view zoomed on it rather than shrinking the room to
+ * fit or parking it on a "make your terminal bigger" hint (mobile room view). Such
+ * a participant is excluded from the clamp and is a mirror target, never a spectator.
+ * @param {{cols?:number, rows?:number}} p
+ * @returns {boolean}
+ */
+export function isScaledViewer(p) {
+  return p != null && p.cols === 0 && p.rows === 0;
+}
+
 // Stable participant colors for the browser overlay (spec §roles: "color is a
 // bonus — colorblind-safe by not being load-bearing"; name tags carry identity).
 // Eight distinct hues, assigned by the brain per fingerprint so a returning key
@@ -189,7 +202,11 @@ export class RoomState {
     return true;
   }
 
-  /** Record a participant's terminal size (host or guest). */
+  /**
+   * Record a participant's terminal size (host or guest). The sentinel 0×0 is legal
+   * and means "scaled viewer" (see isScaledViewer): it is excluded from the clamp
+   * and never parks — a below-floor browser tab reports it instead of its real size.
+   */
   setSize(id, cols, rows) {
     const p = this.participants.get(id);
     if (!p) return false;
@@ -198,10 +215,14 @@ export class RoomState {
     return true;
   }
 
-  /** True if this participant's terminal is below the 80×24 floor (they spectate). */
+  /**
+   * True if this participant's terminal is below the 80×24 floor (they spectate). A
+   * scaled viewer (sentinel 0×0) is never below the floor — it renders zoomed instead.
+   */
   belowFloor(id) {
     const p = this.participants.get(id);
     if (!p) return false;
+    if (isScaledViewer(p)) return false;
     return (p.cols != null && p.cols < FLOOR_COLS) || (p.rows != null && p.rows < FLOOR_ROWS);
   }
 
@@ -229,6 +250,7 @@ export class RoomState {
     let cols = Infinity;
     let rows = Infinity;
     for (const p of this.participants.values()) {
+      if (isScaledViewer(p)) continue; // "I scale, ignore my size" — never constrains the room
       if (this.belowFloor(p.id)) continue;
       if (p.cols != null) cols = Math.min(cols, p.cols);
       if (p.rows != null) rows = Math.min(rows, p.rows);

package/packages/cli/src/brain/transcript.js

@@ -0,0 +1,65 @@
+// Pull Claude's latest response text out of its session transcript.
+//
+// Claude Code writes a JSONL transcript (one message object per line) and hands
+// every hook the path to it (`transcript_path`). We never scrape the repainting
+// TUI for the response — we read the transcript at the Stop edge and take the
+// assistant text produced since the last HUMAN prompt. That's the clean turn.
+//
+// The format has drifted across Claude versions, so every accessor is defensive:
+// content may be a plain string or an array of typed blocks; a "user" line may be
+// a real human prompt OR a tool_result being fed back to the model (which must NOT
+// count as a turn boundary). Anything unparseable is skipped.
+
+/** The text of an assistant message, or null if `obj` isn't one. */
+function assistantText(obj) {
+  if (!obj || obj.type !== 'assistant') return null;
+  const content = obj.message?.content ?? obj.content;
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    const text = content
+      .filter((b) => b && b.type === 'text' && typeof b.text === 'string')
+      .map((b) => b.text)
+      .join('');
+    return text || null;
+  }
+  return null;
+}
+
+/** True only for a real human prompt (not a tool_result fed back as a user turn). */
+function isHumanPrompt(obj) {
+  if (!obj || obj.type !== 'user') return false;
+  const content = obj.message?.content ?? obj.content;
+  if (typeof content === 'string') return true;
+  if (Array.isArray(content)) {
+    if (content.some((b) => b && b.type === 'tool_result')) return false;
+    return content.some((b) => b && b.type === 'text' && typeof b.text === 'string');
+  }
+  return false;
+}
+
+/**
+ * Extract the assistant text produced after the last human prompt in a transcript.
+ * @param {string} jsonl  the raw JSONL transcript contents (a tail is fine — a
+ *                        truncated leading line is skipped)
+ * @returns {string} the response text (may be ''); never throws
+ */
+export function extractLatestResponse(jsonl) {
+  const objs = [];
+  for (const line of String(jsonl ?? '').split('\n')) {
+    const t = line.trim();
+    if (!t) continue;
+    try {
+      objs.push(JSON.parse(t));
+    } catch {
+      /* a partial/broken line (common when reading a tail) — skip it */
+    }
+  }
+  let lastPrompt = -1;
+  for (let i = 0; i < objs.length; i++) if (isHumanPrompt(objs[i])) lastPrompt = i;
+  const parts = [];
+  for (let i = lastPrompt + 1; i < objs.length; i++) {
+    const txt = assistantText(objs[i]);
+    if (txt) parts.push(txt);
+  }
+  return parts.join('\n\n').trim();
+}

package/packages/cli/src/ctl-client.js

@@ -0,0 +1,119 @@
+// `collab go|off|status` — the subcommands the wrapped Claude runs INSIDE a session
+// to drive it (spec phase 5a: the plugin's hands). Each reads CLAUDE_SHARE_CTL from
+// the environment, sends one JSON-line request to the control socket, and prints the
+// single reply as human-readable lines Claude can quote straight back to the user.
+//
+//   live — room brave-otter
+//   invite: https://claudecollab.org/brave-otter
+//
+// No --json flag: the text IS the interface. Not inside a collab session (no
+// CLAUDE_SHARE_CTL) → a friendly stderr hint + exit 2. A relay/handler failure →
+// stderr the error + exit 1. Success → the lines above + exit 0.
+
+import net from 'node:net';
+
+/** Map `collab go` flags to request overrides the host validates. */
+function parseGoArgs(args) {
+  const req = {};
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--guests') req.guests = args[++i];
+    else if (a === '--max-guests') req.max = Number(args[++i]);
+    else if (a === '--room-password') req.pass = args[++i];
+  }
+  return req;
+}
+
+/**
+ * Send one request line to the control socket and resolve with the parsed reply
+ * line. Rejects on connect error, malformed reply, or timeout.
+ * @param {string} sockPath  the CLAUDE_SHARE_CTL unix socket
+ * @param {object} req       the request object (must carry v:1)
+ * @param {number} ms        reply timeout
+ */
+export function sendCtl(sockPath, req, ms = 5000) {
+  return new Promise((resolve, reject) => {
+    const conn = net.connect(sockPath, () => conn.write(JSON.stringify(req) + '\n'));
+    let buf = '';
+    const timer = setTimeout(() => {
+      conn.destroy();
+      reject(new Error('control socket timed out'));
+    }, ms);
+    timer.unref?.();
+    conn.on('data', (d) => {
+      buf += d.toString('utf8');
+      const nl = buf.indexOf('\n');
+      if (nl === -1) return;
+      clearTimeout(timer);
+      conn.end();
+      try {
+        resolve(JSON.parse(buf.slice(0, nl)));
+      } catch (err) {
+        reject(err);
+      }
+    });
+    conn.on('error', (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+/** Human-readable rendering of a successful reply, per subcommand. */
+export function formatReply(sub, reply) {
+  if (sub === 'off') return 'sharing stopped';
+  if (reply.room) {
+    const lines = [`live — room ${reply.room}`];
+    if (reply.inviteUrl) lines.push(`invite: ${reply.inviteUrl}`);
+    return lines.join('\n');
+  }
+  return 'not live — run `collab go` to share this session';
+}
+
+/**
+ * The testable core: returns an exit code and writes via injected out/err so tests
+ * never call process.exit. `ctlMain` is the thin process wrapper below.
+ * @param {object} opts
+ * @param {'go'|'off'|'status'} opts.sub
+ * @param {string[]} [opts.args]
+ * @param {NodeJS.ProcessEnv} [opts.env]
+ * @param {(s:string)=>void} opts.out
+ * @param {(s:string)=>void} opts.err
+ * @returns {Promise<number>} exit code
+ */
+export async function runCtl({ sub, args = [], env = process.env, out, err }) {
+  const sockPath = env.CLAUDE_SHARE_CTL;
+  if (!sockPath) {
+    err('not inside a collab session — start one with: collab\n');
+    return 2;
+  }
+  const req = { v: 1, t: sub, ...(sub === 'go' ? parseGoArgs(args) : {}) };
+  // `go` may dial the relay, which the host bounds at 15s — wait past that for the
+  // authoritative verdict; the instant ops (off/status) keep the short timeout.
+  const timeout = sub === 'go' ? 20000 : 5000;
+  let reply;
+  try {
+    reply = await sendCtl(sockPath, req, timeout);
+  } catch (e) {
+    err(`collab: ${e.message}\n`);
+    return 1;
+  }
+  if (!reply || reply.ok !== true) {
+    err(`collab: ${reply?.error || 'request failed'}\n`);
+    return 1;
+  }
+  out(formatReply(sub, reply) + '\n');
+  return 0;
+}
+
+/** The process entry point the `collab` bin dispatches `go|off|status` to. */
+export async function ctlMain(sub, args) {
+  const code = await runCtl({
+    sub,
+    args,
+    env: process.env,
+    out: (s) => process.stdout.write(s),
+    err: (s) => process.stderr.write(s),
+  });
+  process.exit(code);
+}

package/packages/cli/src/ctl.js

@@ -0,0 +1,97 @@
+// The control socket — how the wrapped Claude drives its OWN session from the
+// inside (spec phase 5a: `collab go|off|status`). A unix socket at CLAUDE_SHARE_CTL,
+// 0600 (same-user only), speaking JSON-lines. Every request carries `v:1`; a wrong
+// or absent version is refused machine-readably so a future protocol bump can't be
+// silently misread. One reply line per request line.
+//
+// The transport is deliberately dumb: it version-gates, dispatches to a handler by
+// request type, and writes the handler's reply. All product logic (go/off/status
+// against the room lifecycle) lives in the handlers the caller passes — this file
+// never touches the relay or the brain.
+
+import net from 'node:net';
+import fs from 'node:fs';
+import { Decoder } from '../../shared/protocol.js';
+
+/** The control-socket protocol version. Every request must carry `v` equal to this. */
+export const CTL_V = 1;
+
+/**
+ * Start the control-socket server.
+ *
+ * @param {object} opts
+ * @param {string} opts.path                     unix socket path (unlinked on close)
+ * @param {Record<string, (req:object)=>any>} opts.handlers
+ *        map of request type → async handler returning the reply object. Unknown
+ *        types get a generic error; a handler that throws becomes an error reply.
+ * @returns {{ close():void }}
+ */
+export function startCtl({ path: sockPath, handlers = {} } = {}) {
+  // A stale socket file from a crashed prior run would make listen() fail with
+  // EADDRINUSE — clear it first (we own the pid-stamped name).
+  try {
+    fs.unlinkSync(sockPath);
+  } catch {
+    /* nothing there — fine */
+  }
+
+  const reply = (conn, obj) => {
+    try {
+      conn.write(JSON.stringify(obj) + '\n');
+    } catch {
+      /* client already gone */
+    }
+  };
+
+  const handleLine = async (conn, msg) => {
+    // Version gate first — the cheapest, most important check. A wrong or absent
+    // version is refused before any handler runs (a client speaking a different
+    // protocol must not have its fields reinterpreted).
+    if (!msg || typeof msg !== 'object' || msg.v !== CTL_V) {
+      return reply(conn, { ok: false, error: 'version' });
+    }
+    const fn = handlers[msg.t];
+    if (typeof fn !== 'function') return reply(conn, { ok: false, error: `unknown request: ${msg.t}` });
+    let res;
+    try {
+      res = await fn(msg);
+    } catch (err) {
+      res = { ok: false, error: String(err?.message || err) };
+    }
+    reply(conn, res ?? { ok: false, error: 'no reply' });
+  };
+
+  const server = net.createServer((conn) => {
+    const dec = new Decoder(); // reused: buffers partial lines, drops malformed JSON
+    conn.on('data', (chunk) => {
+      for (const msg of dec.push(chunk)) handleLine(conn, msg);
+    });
+    conn.on('error', () => {}); // a client reset must never crash the host
+  });
+  server.on('error', () => {}); // post-listen socket errors are non-fatal
+
+  server.listen(sockPath, () => {
+    // Same-user only: the socket carries session control, so lock it to 0600 as
+    // soon as it exists (listen created the file with the process umask).
+    try {
+      fs.chmodSync(sockPath, 0o600);
+    } catch {
+      /* best-effort — a chmod failure must not take the session down */
+    }
+  });
+
+  return {
+    close() {
+      try {
+        server.close();
+      } catch {
+        /* already closing */
+      }
+      try {
+        fs.unlinkSync(sockPath);
+      } catch {
+        /* already gone */
+      }
+    },
+  };
+}

package/packages/cli/src/first-run.js

@@ -0,0 +1,166 @@
+// The first-run screen — shown once, on the first interactive `collab`. It states the
+// core (the /collab plugin), offers the connector picker for link delivery, and
+// carries the relay footer. Copy is Ian-approved (revised 2026-07-15) — do NOT
+// rewrite it. Pure I/O injection: input/output are passed in, so the whole screen is
+// testable by feeding byte sequences (no real TTY).
+//
+// A hand-rolled raw-mode picker (no dependency): ↑/↓ move the cursor, space toggles
+// the highlighted connector, enter starts claude. No alt-screen — it prints in place,
+// redrawing by moving the cursor up and clearing to the end of the screen.
+
+/** The connectors offered for link delivery. Slack only for now (Ian, 2026-07-15). */
+export const DEFAULT_CONNECTORS = [
+  { key: 'slack', label: 'Slack', hint: 'DM the join link to a teammate', checked: true },
+];
+
+// ── styling (the approved mock's visual layer: orange accent = the band's color,
+// green ✓, dim grays, a highlighted selection row, kbd chips). NO_COLOR disables
+// every code; the words themselves never change — tests match on stripped text.
+const useColor = !process.env.NO_COLOR;
+const sgr = (code, s) => (useColor ? `\x1b[${code}m${s}\x1b[0m` : s);
+const o = (s) => sgr('1;38;5;214', s); // orange, bold — the band accent
+const g = (s) => sgr('1;32', s); // green — the "already done" checkmark
+const d = (s) => sgr('38;5;245', s); // dim gray — secondary copy
+const b = (s) => sgr('1', s); // bold
+const chip = (s) => (useColor ? `\x1b[48;5;236m\x1b[38;5;252m${s}\x1b[0m` : s); // kbd key chip (no padding — stripped text stays byte-equal to the approved copy)
+const selRow = (s) => (useColor ? `\x1b[48;5;236m${s}\x1b[0m` : s); // highlighted picker row
+
+// ── the CLAUDE COLLAB wordmark (the skills-installer look: chunky block glyphs with
+// a light→dark gray gradient per row). 5-row bitmap font, only the letters we need.
+// Width: "CLAUDE COLLAB" renders 75 cols incl. indent — under the 80-col floor; a
+// narrower terminal gets the plain one-line title instead of wrapped soup.
+const FONT = {
+  A: ['█████', '█   █', '█████', '█   █', '█   █'],
+  B: ['████ ', '█   █', '████ ', '█   █', '████ '],
+  C: ['█████', '█    ', '█    ', '█    ', '█████'],
+  D: ['████ ', '█   █', '█   █', '█   █', '████ '],
+  E: ['█████', '█    ', '███  ', '█    ', '█████'],
+  L: ['█    ', '█    ', '█    ', '█    ', '█████'],
+  O: ['█████', '█   █', '█   █', '█   █', '█████'],
+  U: ['█   █', '█   █', '█   █', '█   █', '█████'],
+  ' ': ['  ', '  ', '  ', '  ', '  '],
+};
+const GRADIENT = ['223', '216', '215', '214', '208']; // light → deep orange (the band accent family)
+function wordmark(text) {
+  const rows = [];
+  for (let r = 0; r < 5; r++) {
+    const line = [...text].map((ch) => FONT[ch]?.[r] ?? '     ').join(' ');
+    rows.push(useColor ? `\x1b[38;5;${GRADIENT[r]}m${line}\x1b[0m` : line);
+  }
+  return rows;
+}
+
+/**
+ * Render the first-run screen and drive the picker.
+ * @param {object} opts
+ * @param {NodeJS.ReadableStream} [opts.input]   raw key source (default process.stdin)
+ * @param {{write:(s:string)=>void}} [opts.output] screen sink (default process.stdout)
+ * @param {Array} [opts.connectors]              connector rows (default DEFAULT_CONNECTORS)
+ * @returns {Promise<{connectors:string[]}>}     the checked connector keys, in order
+ */
+export function runFirstRun({ input = process.stdin, output = process.stdout, connectors = DEFAULT_CONNECTORS } = {}) {
+  const items = connectors.map((c) => ({ ...c }));
+  let cursor = 0;
+  let lastLines = 0;
+  let pending = ''; // a partial escape sequence straddling two chunks
+
+  const frame = () => {
+    const rows = items.map((it, i) => {
+      const sel = i === cursor;
+      const arrow = sel ? o('▸') : ' ';
+      const box = it.checked ? o('[x]') : '[ ]';
+      const body = ` ${box} ${b(it.label.padEnd(10))}${d(it.hint)} `;
+      return `${arrow}${sel ? selRow(body) : body}`;
+    });
+    // The wordmark needs ~75 cols; a narrower terminal gets the plain title so the
+    // blocks never wrap into soup. Injected test outputs have no .columns → wordmark.
+    const wide = output.columns === undefined || output.columns >= 76;
+    const mark = wordmark('CLAUDE COLLAB');
+    const title = wide ? mark.map((l) => `  ${l}`) : [`  ${o('✦ claudecollab')}`];
+    // The rule spans exactly the wordmark's width (strip the color codes to measure).
+    const ruleWidth = wide ? mark[0].replace(/\x1b\[[0-9;]*m/g, '').length : 58;
+    return [
+      '',
+      ...title,
+      `  ${sgr('38;5;208', '─'.repeat(ruleWidth))}`,
+      '',
+      `  ${g('✓')} /collab will be added to Claude Code`,
+      `       ${b('claude')}    ${d('← start like you always do')}`,
+      `       ${b('/collab')}   ${d('← run /collab to turn it multiplayer!')}`,
+      '',
+      `  ${d("Select Claude's connectors:")}`,
+      '',
+      ...rows,
+      '',
+      `  ${d('want your own server? `collab relay` (guide in the README).')} ${o('♥')}`,
+      '',
+      `  ${chip('↑↓')} ${d('move ·')} ${chip('space')} ${d('toggle ·')} ${chip('enter')} ${d('start claude')}`,
+    ];
+  };
+
+  const paint = () => {
+    const lines = frame();
+    let out = '';
+    if (lastLines > 0) out += `\x1b[${lastLines}A`; // back up over the previous frame
+    out += '\x1b[0J'; // clear from the cursor to the end of the screen
+    out += lines.join('\r\n') + '\r\n';
+    lastLines = lines.length;
+    output.write(out);
+  };
+
+  return new Promise((resolve) => {
+    let finished = false;
+    const finish = () => {
+      if (finished) return;
+      finished = true;
+      input.removeListener('data', onData);
+      try {
+        input.setRawMode?.(false);
+      } catch {}
+      resolve({ connectors: items.filter((it) => it.checked).map((it) => it.key) });
+    };
+
+    const onData = (chunk) => {
+      let buf = pending + (typeof chunk === 'string' ? chunk : chunk.toString('utf8'));
+      pending = '';
+      while (buf.length) {
+        if (buf[0] === '\x1b') {
+          if (buf.startsWith('\x1b[A') || buf.startsWith('\x1bOA')) {
+            cursor = (cursor - 1 + items.length) % items.length;
+            buf = buf.slice(3);
+            paint();
+            continue;
+          }
+          if (buf.startsWith('\x1b[B') || buf.startsWith('\x1bOB')) {
+            cursor = (cursor + 1) % items.length;
+            buf = buf.slice(3);
+            paint();
+            continue;
+          }
+          if (buf.length < 3) {
+            pending = buf; // incomplete escape — wait for the rest of the sequence
+            return;
+          }
+          buf = buf.slice(1); // an escape we don't handle — drop the ESC, keep going
+          continue;
+        }
+        const ch = buf[0];
+        buf = buf.slice(1);
+        if (ch === ' ') {
+          items[cursor].checked = !items[cursor].checked;
+          paint();
+        } else if (ch === '\r' || ch === '\n' || ch === '\x03') {
+          // Enter starts claude; Ctrl-C also proceeds (never leaves the user stuck).
+          return finish();
+        }
+      }
+    };
+
+    try {
+      input.setRawMode?.(true);
+    } catch {}
+    input.resume?.();
+    input.on('data', onData);
+    paint();
+  });
+}