@claudecollab/cli 0.1.0

package/packages/cli/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@claude-share/cli",
+  "version": "0.0.0",
+  "license": "MIT",
+  "private": true,
+  "type": "module",
+  "main": "src/renderer.js",
+  "bin": {
+    "claude-share": "bin/claude-share.js"
+  },
+  "dependencies": {
+    "node-pty": "^1.1.0",
+    "ssh2": "^1.17.0"
+  }
+}

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

@@ -0,0 +1,157 @@
+// The join context card — a joiner's private preamble, printed once into their
+// own scrollback before they attach to the live mirror (spec §join context card).
+// It is assembled instantly from structured brain state (participants, mode) and
+// the attributed log (recent prompts, files touched, Claude's state) — no AI, no
+// latency. The wiring sends it with relay.sendTo(id, card) on admit.
+//
+// Layout (spec frame):
+//   ┌ session so far ── 42 min ─────────────────────┐
+//   │ people   ian★ james✎ · you join as siddh✎     │
+//   │ mode     accept-edits                         │
+//   │ recent prompts                                │
+//   │   ian   → "refactor the navbar"       (32m)   │
+//   │ files    src/Nav.tsx · src/auth.test.ts · +3  │
+//   │ claude   ✻ brewing — on ian's last prompt     │
+//   └───────────────────────────────────────────────┘
+//   ── you're live ──
+
+import { ROLE_GLYPH, stringWidth, truncateToWidth } from '../renderer.js';
+
+// Keep the box comfortably inside an 80-col floor: content ≤ 74 ⇒ box ≤ 78.
+const MAX_INNER = 74;
+
+const CLAUDE_DESC = Object.freeze({
+  busy: '✻ brewing',
+  idle: '● idle',
+  ask: '⚠ permission ask pending',
+});
+
+// Relative minutes, coarsened to hours past 60m ("32m", "2h").
+function relAgo(ms) {
+  const m = Math.round(ms / 60000);
+  return m < 60 ? `${m}m` : `${Math.round(m / 60)}h`;
+}
+
+const glyph = (role) => ROLE_GLYPH[role] ?? '';
+
+// Pad a plain string to a visible width (truncating first if it's too wide).
+function padTo(str, width) {
+  const t = truncateToWidth(str, width);
+  return t + ' '.repeat(Math.max(0, width - stringWidth(t)));
+}
+
+/**
+ * Build the join context card as a multi-line string.
+ * @param {import('./state.js').RoomState} state
+ * @param {import('./log.js').Log} log
+ * @param {object} opts
+ * @param {string} opts.joinerId          the arriving participant's id
+ * @param {() => number} [opts.now]       clock (defaults to Date.now)
+ * @param {'busy'|'idle'|'ask'} [opts.claudeState]  Claude's current state
+ * @param {number} [opts.maxPrompts=3]    recent prompts to show
+ * @param {number} [opts.maxFiles=3]      files to show before "+N"
+ * @returns {string}
+ */
+export function build(state, log, {
+  joinerId,
+  now = () => Date.now(),
+  claudeState = 'idle',
+  maxPrompts = 3,
+  maxFiles = 3,
+} = {}) {
+  const ageMin = Math.round((now() - state.startedAt) / 60000);
+  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)}` : '';
+
+  const rows = [];
+  rows.push(`people   ${peopleStr}${joinStr ? ` · ${joinStr}` : ''}`);
+  rows.push(`mode     ${state.mode}`);
+  rows.push('recent prompts');
+  const recent = log.recentPrompts(maxPrompts);
+  if (recent.length === 0) {
+    rows.push('  (none yet)');
+  } else {
+    for (const p of recent) rows.push(`  ${p.author} → "${p.text}" (${relAgo(now() - p.at)})`);
+  }
+  const files = log.files;
+  const shown = files.slice(0, maxFiles);
+  const overflow = files.length - shown.length;
+  const filesStr = files.length
+    ? shown.join(' · ') + (overflow > 0 ? ` · +${overflow}` : '')
+    : '(none)';
+  rows.push(`files    ${filesStr}`);
+  const lastAuthor = log.lastPromptAuthor();
+  const cdesc = CLAUDE_DESC[claudeState] ?? claudeState;
+  rows.push(`claude   ${cdesc}${lastAuthor ? ` — on ${lastAuthor}'s last prompt` : ''}`);
+
+  const title = `session so far ── ${ageMin} min`;
+  const innerWidth = Math.min(MAX_INNER, Math.max(stringWidth(title) + 2, ...rows.map(stringWidth)));
+
+  const titleTrunc = truncateToWidth(title, innerWidth);
+  const dashes = Math.max(0, innerWidth - stringWidth(titleTrunc));
+
+  const out = [];
+  out.push(`┌ ${titleTrunc} ${'─'.repeat(dashes)}┐`);
+  for (const r of rows) out.push(`│ ${padTo(r, innerWidth)} │`);
+  out.push(`└${'─'.repeat(innerWidth + 2)}┘`);
+  out.push("── you're live ──");
+  return out.join('\n');
+}
+
+// Word-wrap plain prose to `width` cells, honoring the text's own newlines and
+// hard-splitting any single token longer than the width so a box can never
+// overflow. Returns at least one (possibly empty) line.
+function wrapPlain(text, width) {
+  const out = [];
+  const w = Math.max(1, width);
+  for (const para of String(text).split('\n')) {
+    let line = '';
+    for (let word of para.split(/\s+/).filter(Boolean)) {
+      // Break a pathologically long token across rows.
+      while (stringWidth(word) > w) {
+        const head = truncateToWidth(word, w);
+        if (line) {
+          out.push(line);
+          line = '';
+        }
+        out.push(head);
+        word = word.slice(head.length);
+      }
+      const cand = line ? `${line} ${word}` : word;
+      if (stringWidth(cand) > w && line) {
+        out.push(line);
+        line = word;
+      } else {
+        line = cand;
+      }
+    }
+    out.push(line);
+  }
+  return out.length ? out : [''];
+}
+
+/**
+ * Frame a /recap summary as a titled box for the SHARED screen (spec §join-context-
+ * card: "/recap … posts the summary to the shared screen"). Unlike a band toast,
+ * this keeps the FULL prose — wrapped to `cols` so everyone, guests included, can
+ * read the whole thing. Pure; the wiring broadcasts the result to host + guests.
+ *
+ * @param {string} by                who ran /recap (display name)
+ * @param {string} summary           the prose returned by `claude -p`
+ * @param {{cols?:number}} [opts]    shared-view width (defaults to the 80 floor)
+ * @returns {string} multi-line block ('\n'-separated; the caller CRLF-izes)
+ */
+export function recapCard(by, summary, { cols = 80 } = {}) {
+  const width = Math.max(20, Math.min(MAX_INNER, cols - 2));
+  const body = wrapPlain(String(summary ?? '').trim() || '(empty recap)', width);
+  const title = `recap · by ${by}`;
+  const titleTrunc = truncateToWidth(title, width);
+  const dashes = Math.max(0, width - stringWidth(titleTrunc));
+  const out = [`┌ ${titleTrunc} ${'─'.repeat(dashes)}┐`];
+  for (const l of body) out.push(`│ ${padTo(l, width)} │`);
+  out.push(`└${'─'.repeat(width + 2)}┘`);
+  return out.join('\n');
+}

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

@@ -0,0 +1,122 @@
+// claude-share commands — the `/…` verbs the host (and, for /recap, prompters)
+// type into a draft and send (spec §host controls, §per-role input table). This
+// module is pure: it PARSES a sent draft into a command descriptor and answers
+// "is this role allowed to run it?". The wiring in bin/claude-share.js performs
+// the side effects (mutating RoomState, telling the relay to drop/ban a guest,
+// spawning `claude -p` for /recap, running the two-step /end confirmation).
+//
+// It deliberately does NOT own Claude's own slash commands (/clear, /model, …)
+// or the `!` bash prefix — those are Claude's, gated by gate.js and forwarded to
+// the PTY. COMMAND_NAMES is the single list gate.classifySend consults to tell a
+// claude-share command apart from a Claude slash command.
+
+import { atLeast } from './state.js';
+
+/** The claude-share command verbs (without the leading slash). */
+export const COMMAND_NAMES = new Set(['role', 'kick', 'pause', 'resume', 'recap', 'end', 'queue']);
+
+/** Roles /role can assign (never host — the host seat is fixed). */
+const ASSIGNABLE_ROLES = new Set(['prompter', 'viewer']);
+const ROLE_USAGE = 'usage: /role @name prompter|viewer';
+const KICK_USAGE = 'usage: /kick @name';
+const QUEUE_USAGE = 'usage: /queue del <n> | /queue edit <n> <text>';
+
+// Pull the bare name out of an @mention token (`@siddh` → `siddh`). A leading @
+// is optional so `/kick bob` also works. Returns null for anything unnameable.
+function parseMention(token) {
+  if (!token) return null;
+  const m = String(token).match(/^@?([\p{L}\p{N}_-]+)$/u);
+  return m ? m[1] : null;
+}
+
+/**
+ * Parse a sent draft into a claude-share command descriptor.
+ * @param {string} text the sent draft text
+ * @returns {null | {name:string, mention?:string, role?:string, error?:string}}
+ *   null if it is not one of our commands; otherwise `{name, …args}` or
+ *   `{name, error}` when the arguments don't parse.
+ */
+export function parse(text) {
+  const t = String(text).trim();
+  if (!t.startsWith('/')) return null;
+  const parts = t.slice(1).split(/\s+/).filter(Boolean);
+  const name = (parts[0] ?? '').toLowerCase();
+  if (!COMMAND_NAMES.has(name)) return null;
+
+  switch (name) {
+    case 'role': {
+      const mention = parseMention(parts[1]);
+      const role = (parts[2] ?? '').toLowerCase();
+      if (!mention || !ASSIGNABLE_ROLES.has(role)) return { name, error: ROLE_USAGE };
+      return { name, mention, role };
+    }
+    case 'kick': {
+      const mention = parseMention(parts[1]);
+      if (!mention) return { name, error: KICK_USAGE };
+      return { name, mention };
+    }
+    case 'queue': {
+      // /queue del <n>  → delete item n (author, or the host on any item)
+      // /queue edit <n> <text> → rewrite item n (author only). n is 1-based, matching
+      // the queue block the renderer numbers.
+      const sub = (parts[1] ?? '').toLowerCase();
+      const n = Number(parts[2]);
+      if (sub === 'del' || sub === 'delete' || sub === 'rm') {
+        if (!Number.isInteger(n) || n < 1) return { name, error: QUEUE_USAGE };
+        return { name, sub: 'del', index: n };
+      }
+      if (sub === 'edit') {
+        const text = parts.slice(3).join(' ');
+        if (!Number.isInteger(n) || n < 1 || !text) return { name, error: QUEUE_USAGE };
+        return { name, sub: 'edit', index: n, text };
+      }
+      return { name, error: QUEUE_USAGE };
+    }
+    default:
+      // pause | resume | recap | end — no arguments
+      return { name };
+  }
+}
+
+/**
+ * Is `role` allowed to run command `name`? (spec §per-role input table)
+ *   • /recap /queue                        → prompter and up
+ *   • /role /kick /pause /resume /end      → host only
+ * /queue defers per-item permission (author vs host) to the Queue methods;
+ * this only gates who may attempt a queue edit/delete at all (spec §queue).
+ * @param {string} name
+ * @param {string} role
+ * @returns {boolean}
+ */
+export function permitted(name, role) {
+  switch (name) {
+    case 'recap':
+    case 'queue':
+      return atLeast(role, 'prompter');
+    case 'role':
+    case 'kick':
+    case 'pause':
+    case 'resume':
+    case 'end':
+      return atLeast(role, 'host');
+    default:
+      return false;
+  }
+}
+
+/**
+ * Resolve an @mention to a participant id via room state (case-insensitive name
+ * match). The @-autocomplete makes typos unlikely, but names are still claimed by
+ * guests, so a miss returns null and the wiring reports "no one called <name>".
+ * @param {import('./state.js').RoomState} state
+ * @param {string} mention  bare name (no @)
+ * @returns {string|null} participant id
+ */
+export function resolveMention(state, mention) {
+  if (!mention) return null;
+  const want = String(mention).toLowerCase();
+  for (const p of state.list()) {
+    if (p.name && p.name.toLowerCase() === want) return p.id;
+  }
+  return null;
+}