huddle-cli 0.0.0-stage → 0.1.0

package/dist/ui/remote.js

@@ -0,0 +1,332 @@
+// Joining a teammate's room: `huddle join <address> <CODE>`.
+//
+// You prove who you are (your GitHub SSH key, if the invite names you), then
+// your Huddle becomes a member node:
+//   · you see their board live and can message the room
+//   · if you're in a clone of the same repo, your crew joins theirs — the room
+//     can offer your agents tasks; YOU accept or decline each one
+//   · accepted work runs here, on your machine, with your accounts, your tokens
+//     and your approval level, in a worktree off the room's pushed main
+//   · the result goes back as a branch on the shared remote; the room tests,
+//     reviews and merges it
+// Nobody can run anything on your machine without your yes. `leave` ends it.
+import fs from "node:fs";
+import http from "node:http";
+import crypto from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { spawnSync } from "node:child_process";
+import { C, dot, pad } from "./term.js";
+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 { 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;
+function git(cwd, args) {
+    const r = spawnSync("git", args, { cwd, encoding: "utf8", env: { ...process.env, GIT_TERMINAL_PROMPT: "0" } });
+    return { ok: r.status === 0, out: (r.stdout ?? "").trim(), err: (r.stderr ?? "").trim() };
+}
+function repoRootOf(dir) {
+    const r = git(dir, ["rev-parse", "--show-toplevel"]);
+    return r.ok ? r.out : null;
+}
+function printBoard(b) {
+    console.log(`\n${C.violet("BOARD")} ${C.faint("· " + (b.session?.goal ?? "(no goal yet)"))}`);
+    for (const t of b.tasks ?? []) {
+        const w = 16;
+        const filled = Math.round(((t.progress_pct ?? 0) / 100) * w);
+        const bar = C.violet("█".repeat(filled)) + C.faint("░".repeat(w - filled));
+        const who = t.claimed_by ? `${dot(t.claimed_by)} ${t.claimed_by}` : C.faint("unclaimed");
+        console.log(`  ${pad(C.faint(t.status), 12)} ${bar} ${String(t.progress_pct ?? 0).padStart(3)}%  ${t.title}  ${who}`);
+    }
+    const people = (b.members ?? []).map((m) => C.bold(m.github ? "@" + m.github : m.name)).join(", ");
+    console.log(C.faint(`\n  in the room: host${people ? ", " + people : ""}${b.crews?.length ? " · teammates' agents: " + b.crews.join(", ") : ""}`));
+}
+/**
+ * The member's local stand-in for the Room: their agents' Plug talks to this
+ * (with its own secret); every verb is forwarded to the host's Room, tagged
+ * with the task that agent was assigned. Nothing else is reachable.
+ */
+async function startProxy(t, token, taskOf) {
+    const secret = crypto.randomBytes(24).toString("hex");
+    const server = http.createServer(async (req, res) => {
+        const url = new URL(req.url ?? "/", "http://proxy");
+        const reply = (status, body) => {
+            res.writeHead(status, { "content-type": "application/json" });
+            res.end(JSON.stringify(body));
+        };
+        if (req.headers["x-huddle-secret"] !== secret)
+            return reply(401, { error: "not this node's agent" });
+        let body = Object.fromEntries(url.searchParams);
+        if (req.method === "POST") {
+            const raw = await new Promise((r) => {
+                let d = "";
+                req.on("data", (c) => (d += c));
+                req.on("end", () => r(d));
+            });
+            try {
+                body = raw ? JSON.parse(raw) : {};
+            }
+            catch {
+                return reply(400, { error: "bad json" });
+            }
+        }
+        const agent = String(body.agent_id ?? req.headers["x-huddle-agent"] ?? "");
+        const task = taskOf(agent);
+        if (!task)
+            return reply(403, { error: "no task assigned to this agent" });
+        const verb = url.pathname.slice(1);
+        const r = await t.request("POST", `/agent/${verb}`, { ...body, task_id: body.task_id ?? task, for_task: task }, token);
+        reply(r.status, r.body);
+    });
+    const port = await new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve(server.address().port)));
+    return { url: `http://127.0.0.1:${port}`, secret, close: () => server.close() };
+}
+export async function joinRoom(address, code) {
+    const t = transportFor(address);
+    code = code.toUpperCase();
+    // 1. Who are you? (GitHub-bound invites need a signature from your key.)
+    let ch;
+    try {
+        ch = await t.request("POST", "/challenge", { code });
+    }
+    catch (e) {
+        console.log(C.red(`✗ couldn't reach ${t.describe}`) + C.faint(` — ${e?.cause?.code ?? e?.message ?? e}. Is their Huddle open? Same network / Tailscale / relay?`));
+        process.exit(1);
+    }
+    if (ch.status !== 200) {
+        console.log(C.red(`✗ ${ch.body.error ?? "couldn't join"}`));
+        process.exit(1);
+    }
+    const join = { code, name: githubUser() ?? os.userInfo().username };
+    if (ch.body.github) {
+        console.log(C.faint(`  this invite is for @${ch.body.github} — proving it with your GitHub SSH key…`));
+        const s = await signAs(ch.body.github, ch.body.nonce);
+        if (!s.ok) {
+            console.log(C.red(`✗ ${s.reason}`));
+            process.exit(1);
+        }
+        Object.assign(join, { key: s.key, sig: s.sig });
+    }
+    const j = await t.request("POST", "/join", join);
+    if (j.status !== 200) {
+        console.log(C.red(`✗ ${j.body.error ?? "couldn't join"}`));
+        process.exit(1);
+    }
+    const token = j.body.token;
+    const room = j.body.room ?? {};
+    const me = j.body.member;
+    console.log(`${C.green("✓")} joined ${C.bold((room.host ?? "their") + "'s room")} as ${C.bold(me.github ? "@" + me.github : me.name)} ${C.faint("· " + me.role)}`);
+    printBoard(j.body.board);
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: C.violet("room ›") + " " });
+    let asking = false;
+    const held = [];
+    const say = (line) => {
+        if (asking)
+            return void held.push(line);
+        process.stdout.write("\r\x1b[2K");
+        console.log(line);
+        rl.prompt(true);
+    };
+    const ask = (q) => new Promise((resolve) => {
+        asking = true;
+        process.stdout.write("\r\x1b[2K");
+        rl.question(q, (a) => {
+            asking = false;
+            for (const l of held.splice(0))
+                console.log(l);
+            resolve(a.trim().toLowerCase());
+        });
+    });
+    // 2. Code layer: are we in a clone of the room's repo? If not, offer to clone.
+    let root = repoRootOf(process.cwd());
+    const sameRepo = (r) => {
+        const ri = r ? remoteInfo(r) : null;
+        return !!(ri && room.remote && canonicalRemote(ri.url) === room.remote);
+    };
+    if (me.role !== "guest" && room.remote && !sameRepo(root)) {
+        const name = room.remote.split("/").pop();
+        const here = path.join(process.cwd(), name);
+        if (fs.existsSync(here) && sameRepo(repoRootOf(here))) {
+            process.chdir(here);
+            root = repoRootOf(here);
+        }
+        else {
+            console.log(C.faint(`\n  Your agents work in your own copy of ${room.remote}.`));
+            const a = await ask(`  Clone it into ./${name}? ${C.faint("[Y/n]")} `);
+            if (a === "" || a.startsWith("y")) {
+                const cl = spawnSync("git", ["clone", "--quiet", `https://${room.remote}.git`, here], { stdio: "inherit" });
+                if (cl.status === 0) {
+                    process.chdir(here);
+                    root = repoRootOf(here);
+                    console.log(`  ${C.green("✓")} cloned into ${here}`);
+                }
+            }
+        }
+    }
+    const crewMode = me.role !== "guest" && sameRepo(root);
+    // 3. Your crew joins theirs.
+    let workers = [];
+    let proxy = null;
+    const assigned = new Map(); // local agent → task
+    let always = false;
+    if (crewMode && root) {
+        process.chdir(root);
+        ensureInit();
+        const results = await connectAgents();
+        workers = workersFrom(results);
+        proxy = await startProxy(t, token, (agent) => assigned.get(agent)?.taskId);
+        const r = await t.request("POST", "/crew", { agents: workers.map((w) => ({ id: w.id, vendor: w.adapter.vendor, prefers: w.adapter.prefers })) }, token);
+        if (r.status === 200)
+            console.log(`\n  ${C.green("⚡")} your crew is in the room: ${workers.map((w) => dot(w.id) + " " + w.id).join("  ")} ${C.faint("· you approve every task")}`);
+    }
+    else if (me.role !== "guest") {
+        console.log(C.faint(`\n  watching only — run \`huddle join\` from your clone of ${room.remote ?? "their repo"} to bring your crew`));
+    }
+    console.log(C.faint("\n  type to message the room · board · leave (or ctrl-d)\n"));
+    // 4. Doing a task the room offered — on this machine, your rules.
+    const runTask = async (p) => {
+        const w = workers.find((x) => x.id === p.agent);
+        const branch = p.branch;
+        const t0 = Date.now();
+        const deliver = (body) => t.request("POST", "/delivered", { task_id: p.task.id, ms: Date.now() - t0, ...body }, token);
+        if (!w || !root || !/^huddle\/[\w./#-]+$/.test(branch))
+            return deliver({ ok: false, reason: "no such agent here" });
+        // 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]}` });
+        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;
+            const add = hasRemoteBranch
+                ? 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]}` });
+        }
+        say(`  ${dot(w.id)} ${pad(w.id, 10)} ${C.violet("▸")} ${p.task.title} ${C.faint("· on your machine")}`);
+        const prefs = readPrefs();
+        const h = launchAgent({
+            repoRoot: root,
+            adapter: w.adapter,
+            agentId: w.id,
+            role: "worker",
+            taskId: p.task.id,
+            taskSpec: `${p.task.title}\n\n${p.task.spec}`,
+            roomUrl: proxy.url,
+            roomSecret: proxy.secret,
+            approvals: prefs.approvals ?? "auto",
+            worktree: { branch, path: wtPath },
+        });
+        assigned.set(w.id, { taskId: p.task.id, handle: h });
+        const code = await new Promise((resolve) => {
+            h.child.on("exit", resolve);
+            h.child.on("error", () => resolve(-1));
+        });
+        assigned.delete(w.id);
+        if (code !== 0) {
+            say(`  ${dot(w.id)} ${pad(w.id, 10)} ${C.red("✗")} exited with ${code} ${C.faint("· log: " + h.logPath)}`);
+            return deliver({ ok: false, reason: `agent exited with code ${code}`, tokens: h.meter.tokens, cached: h.meter.cached });
+        }
+        // Commit here, push the branch; the room tests, reviews and merges it.
+        git(wtPath, ["add", "-A", "--", ".", ...h.excludes.map((e) => `:!${e}`)]);
+        git(wtPath, ["commit", "--quiet", "--allow-empty", "-m", `huddle(${p.worker}): ${p.task.title}`]);
+        const push = pushBranch(wtPath, branch);
+        if (!push.ok)
+            return deliver({ ok: false, reason: `couldn't push ${branch}: ${push.note}`, tokens: h.meter.tokens });
+        removeWorktree(root, wtPath);
+        say(`  ${dot(w.id)} ${pad(w.id, 10)} ${C.green("↑ delivered")} ${p.task.title} ${C.faint(`· ${fmtDuration(Date.now() - t0)} · ${fmtTokens(h.meter.tokens)} tok · the room will test & merge`)}`);
+        await deliver({ ok: true, branch, tokens: h.meter.tokens, cached: h.meter.cached });
+    };
+    // 5. Live room.
+    let leaving = false;
+    const leave = async () => {
+        if (leaving)
+            return;
+        leaving = true;
+        for (const a of assigned.values())
+            a.handle?.child?.kill("SIGTERM");
+        await t.request("POST", "/leave", {}, token).catch(() => { });
+        proxy?.close();
+        t.close();
+        process.stdout.write("\r\x1b[2K");
+        console.log(C.faint("left the room · your access is revoked"));
+        process.exit(0);
+    };
+    t.events(token, async (e) => {
+        const p = typeof e.payload === "string" ? JSON.parse(e.payload || "{}") : e.payload ?? {};
+        if (e.type === "message")
+            say(`  ${C.violet("💬")} ${C.bold(p.from)} ${C.faint("›")} ${p.body}`);
+        else if (e.type === "member.joined")
+            say(`  ${C.green("●")} ${C.bold(p.github ? "@" + p.github : p.name)} joined`);
+        else if (e.type === "member.left")
+            say(`  ${C.faint("○")} ${C.bold(p.name)} ${p.reason === "removed" ? "was removed" : "left"}`);
+        else if (e.type === "session.created")
+            say(`\n  ${C.violet("▸ new goal:")} ${p.goal}`);
+        else if (e.type === "task.claimed")
+            say(`  ${dot(e.agent_id ?? "")} ${pad(e.agent_id ?? "", 14)} ${C.violet("▸")} picked up a task`);
+        else if (e.type === "task.status" && p.status === "merged")
+            say(`  ${C.green("✓ merged")} ${C.faint(e.task_id)}`);
+        else if (e.type === "task.progress" && p.note)
+            say(`  ${C.faint(String(p.pct).padStart(3) + "%")}  ${p.note}`);
+        else if (e.type === "ask")
+            say(`  ${dot(p.from)} ${C.bold(p.from)} ${C.faint("→")} ${p.to ? C.bold(p.to) : C.faint("room")}  ${p.question}`);
+        else if (e.type === "answer" && p.source !== "teammate")
+            say(`  ${dot(p.from)} ${C.bold(p.from)} ${C.faint("→")} ${C.bold(p.to)}  ${p.answer} ${C.faint("— from shared memory")}`);
+        else if (e.type === "agent.message" && p.kind !== "question")
+            say(`  ${dot(p.from)} ${C.bold(p.from)} ${C.faint("→")} ${C.bold(p.to)}${C.faint(":")} ${String(p.body).slice(0, 200)}`);
+        else if (e.type === "assign") {
+            // Rule 1: an offer is data. Only you (or your "always") turn it into work.
+            const title = p.task?.title ?? "a task";
+            let ok = always;
+            if (!ok) {
+                const a = await ask(`\n  ${C.bold((room.host ?? "the room") + "'s room")} offers ${C.bold("“" + title + "”")} to your ${dot(p.agent)} ${p.agent}.\n  Accept? ${C.faint("[Y/n/a = always this session]")} `);
+                if (a === "a" || a === "always")
+                    always = ok = true;
+                else
+                    ok = a === "" || a.startsWith("y");
+            }
+            await t.request("POST", "/assignment", { task_id: p.task.id, accept: ok }, token);
+            if (ok)
+                void runTask(p);
+            else
+                say(C.faint(`  declined · it goes back on their board`));
+            rl.prompt(true);
+        }
+    }, (code) => {
+        if (leaving)
+            return;
+        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");
+        proxy?.close();
+        process.exit(0);
+    });
+    rl.on("line", async (raw) => {
+        if (asking)
+            return;
+        const line = raw.trim();
+        if (!line)
+            return rl.prompt();
+        if (line === "leave" || line === "exit" || line === "quit")
+            return leave();
+        if (line === "board") {
+            const b = await t.request("GET", "/board", undefined, token);
+            printBoard(b.body);
+            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"}`));
+        rl.prompt();
+    });
+    rl.on("close", () => void leave());
+    rl.prompt();
+}
+//# sourceMappingURL=remote.js.map