@claudecollab/cli 0.1.0

package/packages/cli/src/term-chatter.js

@@ -0,0 +1,89 @@
+// Terminal "chatter" vs human typing.
+//
+// Claude Code queries the terminal (device attributes, version) and enables
+// mouse tracking. The terminal ANSWERS on stdin — DA replies, DCS version
+// strings, SGR mouse reports, focus events. Those bytes are machine chatter
+// addressed to Claude, not prompt text; fed into the composer they render as
+// garbage like "[<35;34;4M" (real dogfood bug, 2026-07-09).
+//
+// partitionInput() splits a chunk into { chatter, human, carry }:
+//   chatter — forward to Claude's PTY (host) or drop (guests)
+//   human   — everything else: printable keys + the editing escapes the
+//             composer keymap understands (arrows, home/end, alt-word…)
+//   carry   — an incomplete sequence at the chunk's tail; prepend to the
+//             next chunk before partitioning again.
+
+const ESC = '\x1b';
+
+// Complete chatter sequences, anchored at an ESC.
+// Input-side replies to queries ALWAYS use openers human keys never use:
+// ESC[? (DEC replies: DA1 `c`, DECRQM `$y`, kitty-keyboard `u`, DSR-DEC `n`),
+// ESC[> (DA2/XTMODKEYS replies), ESC[< (SGR mouse). Kitty-protocol KEY events
+// (ESC[97;5u — no `?`) stay human.
+const CHATTER = [
+  /^\x1b\[\?[\d;]*(?:\$[a-zA-Z]|[a-zA-Z])/, // any ESC[?…reply (DECRQM $y caught in dogfood)
+  /^\x1b\[>[\d;]*[a-zA-Z]/, // any ESC[>…reply (DA2 etc.)
+  /^\x1b\[<[\d;]+[Mm]/, // SGR mouse report
+  /^\x1b\[[\d;]*R/, // cursor position report
+  /^\x1b\[48;[\d;]*t/, // in-band size report (mode 2048, e.g. Ghostty)
+  /^\x1b\[[IO]/, // focus in / out
+  /^\x1bP[^\x1b\x07]*(?:\x1b\\|\x07)/, // DCS reply (e.g. XTVERSION: ESC P > | ghostty 1.3.1 ESC \)
+  /^\x1b\][^\x1b\x07]*(?:\x1b\\|\x07)/, // OSC reply (color queries etc.)
+];
+
+// Could this tail still become a chatter sequence with more bytes?
+// Conservative prefix test: ESC alone, or ESC + opener + params with no final.
+const MAYBE_PREFIX = /^\x1b(?:$|\[(?:$|[<>?]?[\d;$]*$)|P[^\x1b\x07]*$|\][^\x1b\x07]*$|P[^\x1b\x07]*\x1b$|\][^\x1b\x07]*\x1b$)/;
+
+export function partitionInput(s) {
+  let chatter = '';
+  let human = '';
+  let carry = '';
+  let i = 0;
+  while (i < s.length) {
+    const esc = s.indexOf(ESC, i);
+    if (esc === -1) {
+      human += s.slice(i);
+      break;
+    }
+    human += s.slice(i, esc);
+    const rest = s.slice(esc);
+    let matched = null;
+    for (const re of CHATTER) {
+      const m = re.exec(rest);
+      if (m) {
+        matched = m[0];
+        break;
+      }
+    }
+    if (matched) {
+      chatter += matched;
+      i = esc + matched.length;
+    } else if (rest === ESC) {
+      // A chunk that is exactly ESC is the Escape KEY (interrupt) — deliver it
+      // now. Chatter sequences never arrive as a bare trailing ESC chunk.
+      human += ESC;
+      break;
+    } else if (MAYBE_PREFIX.test(rest)) {
+      carry = rest; // incomplete — decide when the rest arrives
+      break;
+    } else {
+      // A real escape sequence, but not chatter (arrow key, alt-word, paste
+      // guard…) — the composer keymap owns it. Emit the ESC and move on; the
+      // rest of the sequence flows through as ordinary bytes.
+      human += ESC;
+      i = esc + 1;
+    }
+  }
+  return { chatter, human, carry };
+}
+
+/** Stateful wrapper: feeds carry back in across chunks. */
+export function createPartitioner() {
+  let carry = '';
+  return (chunk) => {
+    const out = partitionInput(carry + chunk.toString('binary'));
+    carry = out.carry;
+    return out;
+  };
+}

package/packages/relay/auth.js

@@ -0,0 +1,18 @@
+// Shared credential comparison for both relay doors (ssh server.js, web web.js).
+
+import { createHash, timingSafeEqual } from 'node:crypto';
+
+/**
+ * Constant-time string comparison via digests (equal-length inputs for
+ * timingSafeEqual, and no length leak from the secret itself). Non-strings
+ * never match. Used for the relay ROOM_SECRET and per-room join passwords.
+ * @param {unknown} a
+ * @param {unknown} b
+ * @returns {boolean}
+ */
+export function secretsMatch(a, b) {
+  if (typeof a !== 'string' || typeof b !== 'string') return false;
+  const da = createHash('sha256').update(a).digest();
+  const db = createHash('sha256').update(b).digest();
+  return timingSafeEqual(da, db);
+}

package/packages/relay/bin/serve.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+// Production entry for a DEPLOYED relay (Fly.io, a VPS, …) — env-driven config:
+//
+//   WEB_PORT    browser door (http + ws)            default 8787 (the CLI's default)
+//   SSH_PORT    ssh door (the host CLI connects)    default 2222
+//   PUBLIC_URL  public https origin for links       e.g. https://claude-share.fly.dev
+//   HOST_KEY    ssh host key, PEM contents          set as a secret; see below
+//   HOST_NAME   name shown in the ssh banner        default "claude-share"
+//   ROOM_SECRET room-creation credential            when set, only CLIs that send it
+//                                                   (--secret / CLAUDE_SHARE_SECRET)
+//                                                   can create rooms; unset = open
+//
+// HOST_KEY should be a PERSISTENT ed25519 private key (e.g. `fly secrets set
+// HOST_KEY="$(node packages/relay/bin/serve.js --make-key)"`). Without one we
+// generate a fresh key per boot — everything works, but ssh guests see a
+// "host identification changed" warning after every restart/redeploy.
+
+import process from 'node:process';
+import { createHash } from 'node:crypto';
+import ssh2 from 'ssh2';
+import { startRelay } from '../server.js';
+
+const { utils } = ssh2;
+
+// `--make-key`: print a fresh ed25519 private key and exit (for the secret).
+if (process.argv.includes('--make-key')) {
+  process.stdout.write(utils.generateKeyPairSync('ed25519').private + '\n');
+  process.exit(0);
+}
+
+const webPort = Number(process.env.WEB_PORT || 8787);
+const sshPort = Number(process.env.SSH_PORT || 2222);
+const publicUrl = process.env.PUBLIC_URL || undefined;
+const hostName = process.env.HOST_NAME || 'claudecollab';
+
+let hostKey = process.env.HOST_KEY;
+if (!hostKey) {
+  console.warn('serve: no HOST_KEY set — generating an EPHEMERAL key (ssh guests will see');
+  console.warn('serve: identity warnings after a restart). Set one: serve.js --make-key');
+  hostKey = utils.generateKeyPairSync('ed25519').private;
+}
+
+const roomSecret = process.env.ROOM_SECRET || undefined;
+if (!roomSecret) {
+  console.warn('serve: no ROOM_SECRET set — ANYONE who finds this relay can create rooms.');
+  console.warn('serve: set one (e.g. `fly secrets set ROOM_SECRET=…`) before sharing the address.');
+}
+
+const relay = await startRelay({
+  host: '0.0.0.0', // containers route external traffic to us; bind everything
+  port: sshPort,
+  webPort,
+  publicUrl,
+  hostKey,
+  hostName,
+  maxRooms: Number(process.env.MAX_ROOMS || 50),
+  roomSecret,
+});
+
+// The public-half fingerprint of our ssh identity. Safe to publish — hosts pin
+// this (--fingerprint / TOFU) to refuse relay impersonators.
+const pubBlob = utils.parseKey(hostKey).getPublicSSH();
+const fp = 'SHA256:' + createHash('sha256').update(pubBlob).digest('base64').replace(/=+$/, '');
+
+console.log(`relay up: ssh :${relay.port} · web :${relay.webPort}${publicUrl ? ` · public ${publicUrl}` : ''}`);
+console.log(`relay ssh fingerprint: ${fp}`);
+
+for (const sig of ['SIGINT', 'SIGTERM']) {
+  process.on(sig, () => {
+    relay.close();
+    process.exit(0);
+  });
+}

package/packages/relay/names.js

@@ -0,0 +1,27 @@
+// Shared display-name sanitizer for BOTH relay doors (ssh + web). A claimed name is
+// untrusted input that the host CLI later writes verbatim to its terminal (join/leave
+// toasts, the attributed log, session.md, /recap) and mirrors to every ssh guest — so
+// a name carrying raw ESC/OSC/BEL bytes is a terminal-escape injection from a URL
+// parameter or a pasted ssh name. The ssh door already filters name bytes to printable
+// ASCII (0x20–0x7e) as it echoes them; the web door read `?name=` straight off the
+// query string and skipped that filter. Both now route through this one function.
+
+const MAX_NAME = 24; // spec: names cap at 24 cells
+
+/**
+ * Reduce a claimed name to printable ASCII, trim, cap at 24, and fall back when empty.
+ * Mirrors the ssh door's per-byte filter (0x20 ≤ c ≤ 0x7e): control bytes (ESC 0x1b,
+ * BEL 0x07, CR/LF, …) and every non-ASCII byte are dropped, so the survivor can only
+ * ever be a plain one-line label — never an escape sequence.
+ * @param {unknown} raw       the claimed name (a query param or typed bytes)
+ * @param {string} [fallback='guest'] used when nothing printable remains
+ * @returns {string}
+ */
+export function sanitizeName(raw, fallback = 'guest') {
+  let out = '';
+  for (const ch of String(raw ?? '')) {
+    const c = ch.codePointAt(0);
+    if (c >= 0x20 && c <= 0x7e) out += ch;
+  }
+  return out.trim().slice(0, MAX_NAME) || fallback;
+}

package/packages/relay/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@claude-share/relay",
+  "version": "0.0.0",
+  "license": "MIT",
+  "private": true,
+  "type": "module",
+  "main": "rooms.js",
+  "dependencies": {
+    "@xterm/xterm": "^5.5.0",
+    "ssh2": "^1.17.0",
+    "ws": "^8.18.0"
+  }
+}