huddle-cli 0.1.0 → 0.1.1

package/dist/ui/paste.js

@@ -0,0 +1,515 @@
+// Pasting at the `huddle ›` prompt, and the commands that put things on the
+// shared screen (src/room/context.ts).
+//
+// readline fires one "line" per pasted line, so a pasted stack trace used to
+// run as 200 goals. Here the paste is caught BEFORE readline sees it:
+//
+//   bracketed paste  the terminal wraps a paste in ESC[200~ … ESC[201~ (we turn
+//                    that on with ESC[?2004h) — everything inside is one input
+//   fallback         a terminal without it: text that arrives in one burst
+//                    (a newline plus more, chunks < 30 ms apart) is one paste
+//
+// A short paste (≤ 3 lines, ≤ 500 chars) goes back to the line as typed, on
+// one line. A long one becomes a screen item; what you type next is the goal.
+import { StringDecoder } from "node:string_decoder";
+import fs from "node:fs";
+import path from "node:path";
+import { RoomDB } from "../room/db.js";
+import { ContextStore, brainSummary, droppedPaths, expandGlob, fmtBytes, isGlob, looksText as looksTextBuf, redactSecrets, splitPathTokens, } from "../room/context.js";
+import { C } from "./term.js";
+export const PASTE_START = "\x1b[200~";
+export const PASTE_END = "\x1b[201~";
+/** Ask the terminal to mark pastes (or stop, before handing it to another program). */
+export function bracketedPaste(on, out = process.stdout) {
+    if (out.isTTY)
+        out.write(on ? "\x1b[?2004h" : "\x1b[?2004l");
+}
+/** Long enough to be a screen item rather than part of the line. */
+export function isLongPaste(text) {
+    const t = text.replace(/\r\n?/g, "\n").replace(/\n+$/, "");
+    return t.split("\n").length > 3 || t.length > 500;
+}
+/** A short multi-line paste, as one typed line. */
+export const flatten = (text) => text.replace(/\r\n?|\n/g, " ").replace(/[\x00-\x08\x0B-\x1F\x7F]/g, "").replace(/\s+$/, "");
+/** How many chars at the end of `s` could be the start of `marker`. */
+function partialTail(s, marker) {
+    for (let k = Math.min(marker.length - 1, s.length); k > 0; k--)
+        if (s.endsWith(marker.slice(0, k)))
+            return k;
+    return 0;
+}
+/**
+ * Splits terminal input into typed text (passed through to readline) and
+ * pastes (handed to onPaste). Pure apart from its timers, so tests feed it
+ * chunks directly.
+ */
+export class PasteCatcher {
+    o;
+    inPaste = false;
+    buf = "";
+    tail = "";
+    burst = "";
+    burstTimer = null;
+    tailTimer = null;
+    constructor(o) {
+        this.o = o;
+    }
+    feed(chunk) {
+        if (this.o.enabled && !this.o.enabled() && !this.inPaste) {
+            this.flushBurst();
+            return this.o.pass(this.takeTail() + chunk);
+        }
+        let s = this.takeTail() + chunk;
+        while (s) {
+            if (this.inPaste) {
+                const j = s.indexOf(PASTE_END);
+                if (j < 0) {
+                    const k = partialTail(s, PASTE_END);
+                    this.buf += s.slice(0, s.length - k);
+                    this.holdTail(s.slice(s.length - k));
+                    return;
+                }
+                this.buf += s.slice(0, j);
+                s = s.slice(j + PASTE_END.length);
+                this.inPaste = false;
+                const text = this.buf;
+                this.buf = "";
+                if (text)
+                    this.o.onPaste(text);
+                continue;
+            }
+            const i = s.indexOf(PASTE_START);
+            if (i < 0) {
+                const k = partialTail(s, PASTE_START);
+                if (s.length - k)
+                    this.typed(s.slice(0, s.length - k));
+                this.holdTail(s.slice(s.length - k));
+                return;
+            }
+            if (i > 0)
+                this.typed(s.slice(0, i));
+            this.flushBurst();
+            s = s.slice(i + PASTE_START.length);
+            this.inPaste = true;
+        }
+    }
+    takeTail() {
+        const t = this.tail;
+        this.tail = "";
+        if (this.tailTimer)
+            clearTimeout(this.tailTimer);
+        this.tailTimer = null;
+        return t;
+    }
+    /** A lone ESC (the escape key) may be a marker's start: wait a moment, then let it through. */
+    holdTail(t) {
+        this.tail = t;
+        if (!t)
+            return;
+        this.tailTimer = setTimeout(() => {
+            this.tailTimer = null;
+            const held = this.tail;
+            this.tail = "";
+            if (!held)
+                return;
+            if (this.inPaste)
+                this.buf += held;
+            else
+                this.typed(held);
+        }, 25);
+    }
+    /** The fallback: a newline plus more in one chunk — or chunks right behind it — is a paste. */
+    typed(t) {
+        if (this.burstTimer) {
+            this.burst += t;
+            this.armBurst();
+            return;
+        }
+        if (t.length > 1 && /[\r\n]/.test(t)) {
+            this.burst = t;
+            this.armBurst();
+            return;
+        }
+        this.o.pass(t);
+    }
+    armBurst() {
+        if (this.burstTimer)
+            clearTimeout(this.burstTimer);
+        this.burstTimer = setTimeout(() => this.flushBurst(), this.o.windowMs ?? 30);
+    }
+    flushBurst() {
+        if (this.burstTimer)
+            clearTimeout(this.burstTimer);
+        this.burstTimer = null;
+        const b = this.burst;
+        this.burst = "";
+        if (!b)
+            return;
+        // One line + Enter that arrived in one chunk (a laggy terminal) is still typing.
+        const body = b.replace(/[\r\n]+$/, "");
+        if (/[\r\n]/.test(body))
+            this.o.onPaste(body);
+        else
+            this.o.pass(b);
+    }
+}
+/**
+ * Put a catcher in front of stdin: every "data" chunk goes through it before
+ * readline (and keypress listeners) see anything. Returns the undo.
+ */
+export function interceptStdin(stdin, make) {
+    const orig = stdin.emit;
+    const decoder = new StringDecoder("utf8");
+    const pass = (s) => void orig.call(stdin, "data", Buffer.from(s, "utf8"));
+    const catcher = make(pass);
+    stdin.emit = function (ev, ...args) {
+        if (ev !== "data")
+            return orig.apply(this, [ev, ...args]);
+        const c = args[0];
+        catcher.feed(typeof c === "string" ? c : decoder.write(c));
+        return true;
+    };
+    return () => {
+        stdin.emit = orig;
+    };
+}
+const q = (s) => `'${s.length > 40 ? s.slice(0, 39) + "…" : s}'`;
+const sizeWord = (i) => (i.lines && (i.kind === "text" || i.kind === "code") ? `${i.lines} line${i.lines === 1 ? "" : "s"}` : fmtBytes(i.bytes));
+/** Secrets found → ask (or, with nobody to ask, redact) → save. */
+async function save(store, p, ui) {
+    let redact = true;
+    if (p.secrets.length) {
+        const kinds = [...new Set(p.secrets.map((h) => h.kind))].join(", ");
+        const { agents, companies } = ui.audience();
+        const who = agents.length ? `${agents.join(", ")} (${companies} compan${companies === 1 ? "y" : "ies"})` : "every agent in the room";
+        ui.print(C.yellow(`  ⚠ ${p.secrets.length} likely secret${p.secrets.length > 1 ? "s" : ""} in ${q(p.title)}: ${kinds} (line ${p.secrets.slice(0, 3).map((h) => h.line).join(", ")})`));
+        if (ui.interactive)
+            redact = await ui.yes(`  this will be shown to ${who} — redact?`, true);
+        else
+            ui.print(C.faint(`  redacted before it goes to ${who}`));
+    }
+    const res = store.commit(p, { by: "you", redact, announce: ui.announce });
+    if (res.ok && !res.duplicate && res.item.lines > 200 && ui.brain) {
+        // A one-line brain summary for the index — in the background, never blocking the prompt.
+        void brainSummary(store, res.item, ui.brain(), ui.root?.() ?? process.cwd()).catch(() => { });
+    }
+    return res;
+}
+/** Print what happened to an add; true if the item is on the screen. */
+function report(res, ui, verb) {
+    if (!res.ok) {
+        ui.print(C.red(`  ✗ ${res.reason}`));
+        return false;
+    }
+    const i = res.item;
+    if (res.duplicate) {
+        ui.print(`  📎 already on the screen: ${i.id} ${q(i.title)}`);
+        return true;
+    }
+    // "📎 pasted 214 lines (ctx-3 'TypeError…')" · "📎 added 'shot.png' (ctx-4 · image · 412 KB · 1280×720)"
+    if (verb === "added")
+        ui.print(`  📎 added ${q(i.title)} ${C.faint(`(${i.id} · ${i.kind} · ${i.lines ? sizeWord(i) + ", " : ""}${fmtBytes(i.bytes)}${i.summary ? " · " + i.summary.slice(0, 60) : ""})`)}`);
+    else
+        ui.print(`  📎 ${verb} ${sizeWord(i)} ${C.faint(`(${i.id} ${q(i.title)})`)}`);
+    if (res.redacted)
+        ui.print(C.faint(`     ${res.redacted} secret${res.redacted > 1 ? "s" : ""} redacted`));
+    for (const w of res.warnings ?? [])
+        ui.print(C.faint(`     ${w}`));
+    if (res.announced?.length)
+        ui.print(C.faint(`     told ${res.announced.join(", ")} (working now)`));
+    return true;
+}
+/** A long paste → a screen item. Returns false if it should go back to the line instead. */
+export async function pasteToScreen(text, ui) {
+    const db = await ui.db();
+    if (!db) {
+        ui.print(C.yellow("  ! pastes go on a repo's shared screen — cd into a git repo first"));
+        return true;
+    }
+    const store = ContextStore.open(db);
+    const p = store.prepareText(text);
+    if ("ok" in p) {
+        ui.print(C.red(`  ✗ ${p.reason}`));
+        return true;
+    }
+    const res = await save(store, p, ui);
+    report(res, ui, "pasted");
+    if (res.ok && !res.duplicate)
+        ui.print(C.faint("     type your goal — every agent sees it on the shared screen, not in N copies"));
+    return true;
+}
+/** A dropped file path (or several): the whole line is existing absolute paths. */
+export function asDrop(text) {
+    return droppedPaths(text.replace(/\r?\n/g, " "));
+}
+/**
+ * `add a login page` is a goal; `add ./log.txt`, `add *.png`, `add ~/shot.png`,
+ * `add notes.md` (when it exists) add files. A bare missing name ("add
+ * README.md") is a goal: the user wants it written.
+ */
+export function looksLikePaths(rest, cwd = process.cwd()) {
+    const toks = splitPathTokens(rest);
+    if (!toks.length)
+        return false;
+    return toks.every((t) => isGlob(t) || /[\\/~]|^\./.test(t) || (/\.\w{1,8}$/.test(t) && fs.existsSync(path.resolve(cwd, t))));
+}
+/** A Room event as a line for the prompt and/or the live view (null = not a screen event). */
+export function screenEvent(e) {
+    if (!e.type.startsWith("context."))
+        return null;
+    let p = {};
+    try {
+        p = JSON.parse(e.payload || "{}");
+    }
+    catch {
+        return null;
+    }
+    const t = q(String(p.title ?? ""));
+    if (e.type === "context.note") {
+        const text = `📌 ${C.bold(p.by)} on ${p.id} ${C.faint(t)}: ${p.body}`;
+        return { print: p.by === "you" ? undefined : `  ${text}`, dash: { text } };
+    }
+    if (e.type === "context.added" && p.by !== "you") {
+        const text = `📎 ${C.bold(p.by)} put ${p.id} on the screen: ${t}`;
+        return { print: `  ${text}`, dash: { text } };
+    }
+    if (e.type === "context.read" && e.agent_id)
+        return { dash: { agent: e.agent_id, text: `📖 read ${p.id} ${t}${p.from ? ` lines ${p.from}-${p.to}` : ""}` } };
+    return null;
+}
+/**
+ * `add <path…|glob>`: files, folders (their text files, as one item) and
+ * globs (more than 5 matches → one item). Returns how many failed.
+ */
+export async function addPaths(args, ui, cwd = process.cwd()) {
+    const db = await ui.db();
+    if (!db) {
+        ui.print(C.red("  ✗ open a git repo first") + C.faint(" — the shared screen belongs to a project"));
+        return args.length || 1;
+    }
+    const store = ContextStore.open(db);
+    if (!args.length)
+        ui.print(C.faint("  usage: add <file|folder|glob> … — or just drag a file into this window"));
+    let failed = 0;
+    for (const a of args) {
+        // "shot [1].png" that exists is a file, not a pattern.
+        if (isGlob(a) && !fs.existsSync(path.resolve(cwd, a))) {
+            const hits = expandGlob(a, cwd);
+            if (!hits.length) {
+                ui.print(C.red(`  ✗ nothing matches ${a}`));
+                failed++;
+            }
+            else if (hits.length > 5) {
+                const p = store.prepareBundle(a, cwd, hits);
+                if ("ok" in p) {
+                    ui.print(C.red(`  ✗ ${p.reason}`));
+                    failed++;
+                }
+                else if (!report(await save(store, p, ui), ui, "added"))
+                    failed++;
+            }
+            else
+                for (const h of hits)
+                    if (!(await addOne(store, h, ui, cwd)))
+                        failed++;
+            continue;
+        }
+        if (!(await addOne(store, a, ui, cwd)))
+            failed++;
+    }
+    return failed;
+}
+async function addOne(store, p, ui, cwd) {
+    const prep = store.preparePath(p, cwd);
+    if ("ok" in prep) {
+        ui.print(C.red(`  ✗ ${prep.reason}`));
+        return false;
+    }
+    return report(await save(store, prep, ui), ui, "added");
+}
+/** `ctx` / `context`: list · show <id> · rm <id…> · note <id> <text> · add <path…> · clear */
+export async function ctxCommand(arg, ui) {
+    const db = await ui.db();
+    if (!db)
+        return ui.print(C.red("  ✗ open a git repo first") + C.faint(" — the shared screen belongs to a project"));
+    const store = ContextStore.open(db);
+    const [sub, ...rest] = arg.trim().split(/\s+/).filter(Boolean);
+    if (!sub || sub === "ls" || sub === "list") {
+        const items = store.list();
+        if (!items.length)
+            return ui.print(C.faint("  nothing on the shared screen — paste something long, drag a file in, or `add <file>`"));
+        ui.print(`\n  ${C.violet("SCREEN")} ${C.faint(`· ${items.length} item${items.length > 1 ? "s" : ""} · ${fmtBytes(store.totalBytes())} · agents read these on demand`)}`);
+        for (const i of items) {
+            ui.print(`  ${C.bold(i.id.padEnd(6))} ${i.kind.padEnd(5)} ${q(i.title)} ${C.faint(`· ${sizeWord(i)} · by ${i.added_by}${i.notes.length ? ` · ${i.notes.length} note${i.notes.length > 1 ? "s" : ""}` : ""}`)}`);
+            if (i.brain_summary || i.summary)
+                ui.print(C.faint(`         ${(i.brain_summary || i.summary).slice(0, 110)}`));
+            for (const n of i.notes.slice(-2))
+                ui.print(`         📌 ${C.bold(n.by)} ${n.body.slice(0, 110)}`);
+        }
+        return ui.print(C.faint("\n  ctx show <id> · ctx rm <id> · ctx note <id> <text> · add <file>"));
+    }
+    if (sub === "add")
+        return void (await addPaths(splitPathTokens(rest.join(" ")), ui));
+    if (sub === "clear") {
+        const items = store.list();
+        if (!items.length)
+            return ui.print(C.faint("  the screen is already empty"));
+        if (ui.interactive && !(await ui.yes(`  take all ${items.length} items off the screen?`, false)))
+            return;
+        for (const i of items)
+            store.remove(i.id);
+        return ui.print(`  ${C.green("✓")} screen cleared`);
+    }
+    if (sub === "rm" || sub === "remove" || sub === "del") {
+        if (!rest.length)
+            return ui.print(C.faint("  usage: ctx rm <id>"));
+        for (const id of rest)
+            ui.print(store.remove(id) ? `  ${C.green("✓")} ${id} is off the screen` : C.red(`  ✗ no item ${id}`));
+        return;
+    }
+    if (sub === "note") {
+        const [id, ...words] = rest;
+        if (!id || !words.length)
+            return ui.print(C.faint("  usage: ctx note <id> <what everyone should know about it>"));
+        const n = store.note(id, words.join(" "), "you");
+        return ui.print("error" in n ? C.red(`  ✗ ${n.error}`) : `  📌 pinned on ${id}`);
+    }
+    const id = sub === "show" || sub === "cat" ? rest[0] : sub;
+    const it = id ? store.get(id) : undefined;
+    if (!it)
+        return ui.print(C.red(`  ✗ no item ${id ?? ""}`) + C.faint(" — `ctx` lists them"));
+    ui.print(`\n  ${C.bold(it.id)} ${it.kind} ${q(it.title)} ${C.faint(`· ${sizeWord(it)} · ${fmtBytes(it.bytes)} · by ${it.added_by}`)}`);
+    if (it.summary)
+        ui.print(C.faint(`  ${it.summary}`));
+    if (it.sections.length)
+        ui.print(C.faint(`  sections: ${it.sections.slice(0, 8).map((s, k) => `${k + 1}. ${s.title} (${s.from}-${s.to})`).join(" · ")}${it.sections.length > 8 ? " …" : ""}`));
+    const text = store.textOf(it);
+    if (text === null)
+        ui.print(C.faint(`  file: ${store.pathOf(it)}`));
+    else {
+        const lines = text.split("\n");
+        for (const l of lines.slice(0, 30))
+            ui.print(C.faint("  │ ") + l.slice(0, 200));
+        if (lines.length > 30)
+            ui.print(C.faint(`  │ … ${lines.length - 30} more lines`));
+    }
+    for (const n of it.notes)
+        ui.print(`  📌 ${C.bold(n.by)} ${n.body}`);
+}
+// ---- one-shot runs: huddle join "<goal>" --with f --with g, and stdin -----------
+/** `--with a --with=b` → ["a", "b"], and the args without them. */
+export function takeWith(args) {
+    const files = [];
+    const rest = [];
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--with" && i + 1 < args.length)
+            files.push(args[++i]);
+        else if (a.startsWith("--with="))
+            files.push(a.slice(7));
+        else
+            rest.push(a);
+    }
+    return { files, rest };
+}
+/** Piped stdin (`cat log.txt | huddle join "fix this"`). Waits briefly for a first chunk, so an idle pipe never hangs a run. */
+export function readPipedStdin(stdin = process.stdin, firstMs = 300) {
+    if (stdin.isTTY)
+        return Promise.resolve("");
+    return new Promise((resolve) => {
+        let data = "";
+        let started = false;
+        const done = () => {
+            clearTimeout(idle);
+            stdin.off("data", onData);
+            stdin.off("end", done);
+            stdin.off("error", done);
+            stdin.pause();
+            resolve(data);
+        };
+        const onData = (c) => {
+            started = true;
+            data += c.toString();
+        };
+        const idle = setTimeout(() => !started && done(), firstMs);
+        stdin.on("data", onData);
+        stdin.once("end", done);
+        stdin.once("error", done);
+        stdin.resume();
+    });
+}
+/** Text from a pipe (`cat err.log | huddle add -`) as one item. True if it's on the screen. */
+export async function addPiped(store, text, ui, opts = {}) {
+    const p = store.prepareText(text, { source: "stdin", title: opts.title });
+    if ("ok" in p) {
+        ui.print(C.red(`  ✗ stdin: ${p.reason}`));
+        return false;
+    }
+    return report(await save(store, p, ui), ui, "piped in");
+}
+/** Put a one-shot run's --with files and stdin on the screen before planning. */
+export async function addForRun(dbFile, files, piped, print, cwd = process.cwd()) {
+    if (!files.length && !piped.trim())
+        return 0;
+    const db = new RoomDB(dbFile);
+    const ui = { print, yes: async () => true, db: async () => db, audience: () => ({ agents: [], companies: 0 }), interactive: false };
+    let failed = 0;
+    try {
+        const store = ContextStore.open(db);
+        if (piped.trim() && !(await addPiped(store, piped, ui)))
+            failed++;
+        failed += files.length ? await addPaths(files, ui, cwd) : 0;
+    }
+    finally {
+        db.close();
+    }
+    return failed;
+}
+// ---- a teammate's side (`huddle join <address> <CODE>`) ----------------------------
+/**
+ * `add <file>` / `ctx` typed by a teammate: text files go to the host's screen
+ * over the shared API (the body cap there is 256 KB); `ctx` lists the screen.
+ */
+export async function remoteScreen(request, line, say) {
+    const [cmd] = line.split(/\s+/);
+    if (cmd === "ctx" || cmd === "context") {
+        const r = await request("GET", "/context");
+        if (r.status !== 200)
+            return say(C.red(`  ✗ ${r.body?.error ?? "couldn't read the screen"}`));
+        const items = r.body.items ?? [];
+        if (!items.length)
+            return say(C.faint("  nothing on the shared screen yet — `add <file>` to put a text file up"));
+        for (const i of items) {
+            say(`  ${C.bold(String(i.id).padEnd(6))} ${String(i.kind).padEnd(5)} ${q(String(i.title))} ${C.faint(`· ${i.size} · by ${i.added_by}`)}`);
+            for (const n of (i.notes ?? []).slice(-2))
+                say(`         📌 ${n}`);
+        }
+        return;
+    }
+    for (const f of splitPathTokens(line.slice(cmd.length))) {
+        let text;
+        try {
+            const buf = fs.readFileSync(f);
+            if (buf.length > 200 * 1024) {
+                say(C.red(`  ✗ ${path.basename(f)} is ${fmtBytes(buf.length)} — teammates can send text up to 200 KB; ask the host to add it`));
+                continue;
+            }
+            if (!looksTextBuf(buf)) {
+                say(C.red(`  ✗ ${path.basename(f)} isn't text — screenshots and PDFs go up from the host's machine`));
+                continue;
+            }
+            text = buf.toString("utf8");
+        }
+        catch (e) {
+            say(C.red(`  ✗ ${e?.code === "ENOENT" ? "no such file: " + f : e?.code === "EACCES" ? "permission denied: " + f : String(e?.message ?? e)}`));
+            continue;
+        }
+        // Secrets never leave this machine: redacted here, before the send.
+        const red = redactSecrets(text);
+        if (red.count)
+            say(C.yellow(`  ⚠ redacted ${red.count} likely secret${red.count > 1 ? "s" : ""} in ${path.basename(f)} before sending`));
+        const r = await request("POST", "/context/add", { text: red.text, title: path.basename(f) });
+        say(r.status === 200 ? `  📎 ${r.body.duplicate ? "already on the screen" : "on the screen"}: ${r.body.id} ${q(path.basename(f))}` : C.red(`  ✗ ${r.body?.error ?? "not added"}`));
+    }
+}
+//# sourceMappingURL=paste.js.map

package/dist/ui/remote.js

@@ -22,7 +22,8 @@ import { transportFor } from "../room/transport.js";
 import { signAs, githubUser } from "../room/identity.js";
 import { canonicalRemote, pushBranch, remoteInfo } from "../sandbox/sync.js";
 import { connectAgents, readPrefs, workersFrom, ensureInit } from "./app.js";
-import { launchAgent } from "../orchestrator/launcher.js";
+import { launchAgent, stopChild } from "../orchestrator/launcher.js";
+import { looksLikePaths, remoteScreen } from "./paste.js";
 import { removeWorktree } from "../sandbox/worktree.js";
 import { fmtDuration, fmtTokens } from "../adapters/usage.js";
 export const INVITE_CODE = /^[A-HJ-NP-Z2-9]{4}-[A-HJ-NP-Z2-9]{4}-[A-HJ-NP-Z2-9]{4}$/i;
@@ -199,7 +200,7 @@ export async function joinRoom(address, code) {
         // Worktree off the room's pushed main (or the branch itself, on a fix round).
         const f = git(root, ["fetch", "--quiet", "origin"]);
         if (!f.ok)
-            return deliver({ ok: false, reason: `couldn't fetch: ${f.err.split("\n")[0]}` });
+            return deliver({ ok: false, reason: `couldn't fetch: ${f.err.split(/\r?\n/)[0]}` });
         const wtPath = path.join(root, ".huddle", "worktrees", branch.replace(/[^\w.-]/g, "_"));
         if (!fs.existsSync(wtPath)) {
             const hasRemoteBranch = git(root, ["rev-parse", "--verify", "--quiet", `origin/${branch}`]).ok;
@@ -207,7 +208,7 @@ export async function joinRoom(address, code) {
                 ? git(root, ["worktree", "add", "-B", branch, wtPath, `origin/${branch}`])
                 : git(root, ["worktree", "add", "-B", branch, wtPath, p.base]);
             if (!add.ok)
-                return deliver({ ok: false, reason: `couldn't prepare a worktree: ${add.err.split("\n")[0]}` });
+                return deliver({ ok: false, reason: `couldn't prepare a worktree: ${add.err.split(/\r?\n/)[0]}` });
         }
         say(`  ${dot(w.id)} ${pad(w.id, 10)} ${C.violet("▸")} ${p.task.title} ${C.faint("· on your machine")}`);
         const prefs = readPrefs();
@@ -250,7 +251,7 @@ export async function joinRoom(address, code) {
             return;
         leaving = true;
         for (const a of assigned.values())
-            a.handle?.child?.kill("SIGTERM");
+            stopChild(a.handle?.child);
         await t.request("POST", "/leave", {}, token).catch(() => { });
         proxy?.close();
         t.close();
@@ -304,7 +305,7 @@ export async function joinRoom(address, code) {
         process.stdout.write("\r\x1b[2K");
         console.log(code === 4403 ? C.yellow("you were removed from the room") : C.faint("the room closed"));
         for (const a of assigned.values())
-            a.handle?.child?.kill("SIGTERM");
+            stopChild(a.handle?.child);
         proxy?.close();
         process.exit(0);
     });
@@ -321,6 +322,11 @@ export async function joinRoom(address, code) {
             printBoard(b.body);
             return rl.prompt();
         }
+        // The host's shared screen: `ctx` lists it, `add <file>` puts a text file up.
+        if (/^(ctx|context)$/.test(line) || /^add\s+\S/.test(line) && looksLikePaths(line.slice(3))) {
+            await remoteScreen((m, p, b) => t.request(m, p, b, token), line, say);
+            return rl.prompt();
+        }
         const r = await t.request("POST", "/message", { body: line }, token);
         if (r.status !== 200)
             say(C.red(`  ✗ ${r.body.error ?? "not sent"}`));