huddle-cli 0.0.0-stage → 0.1.1

package/dist/ui/remote.js

@@ -0,0 +1,338 @@
+// 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, 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;
+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(/\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;
+            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(/\r?\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())
+            stopChild(a.handle?.child);
+        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())
+            stopChild(a.handle?.child);
+        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();
+        }
+        // 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"}`));
+        rl.prompt();
+    });
+    rl.on("close", () => void leave());
+    rl.prompt();
+}
+//# sourceMappingURL=remote.js.map

package/dist/ui/setup.js

@@ -0,0 +1,152 @@
+// `huddle setup`: everything a person would otherwise do by hand before the
+// first goal, in one command — check Node and git, pick which agents you use,
+// install the missing ones with this platform's command, then hand the
+// terminal to each one's own sign-in, and check again.
+//
+//   huddle setup                    asks: use each agent? install the missing ones?
+//   huddle setup --yes              no questions for choices and installs
+//                                   (sign-ins still need you: they open a browser)
+//   huddle setup --agents=claude,codex   only these (and they're marked "used")
+//
+// Huddle never sees a credential: sign-in is always the agent's own command.
+import readline from "node:readline/promises";
+import { spawnSync } from "node:child_process";
+import { ADAPTERS, LEGACY, installCommand, loginLine } from "../adapters/index.js";
+import { MIN_NODE } from "../preflight.js";
+import { gitFix, nodeFix } from "../platform.js";
+import { connectAgents, installAgent, installLine, runInteractive, setAgentChoice, signIn, skippedAgents } from "./app.js";
+import { C, dot } from "./term.js";
+function realDeps(rl) {
+    return {
+        ask: async (q, def = true) => {
+            if (!rl)
+                return def;
+            const a = (await rl.question(`${q} ${C.faint(def ? "[Y/n]" : "[y/N]")} `)).trim().toLowerCase();
+            return a === "" ? def : a.startsWith("y");
+        },
+        run: (cmd) => runInteractive(rl, cmd),
+        print: (l = "") => console.log(l),
+        probe: () => connectAgents(),
+        git: () => {
+            const r = spawnSync("git", ["--version"], { encoding: "utf8" });
+            return r.status === 0 ? (r.stdout.match(/\d+\.\d+(\.\d+)?/)?.[0] ?? "?") : null;
+        },
+        node: process.versions.node,
+        interactive: !!process.stdin.isTTY,
+    };
+}
+export async function runSetup(args, deps) {
+    const rl = deps ? null : process.stdin.isTTY ? readline.createInterface({ input: process.stdin, output: process.stdout }) : null;
+    try {
+        return await setup(args, deps ?? realDeps(rl));
+    }
+    finally {
+        rl?.close();
+    }
+}
+/** The flow, with every side effect in `d` (tests pass fakes). Exit code: 0 = at least one agent ready. */
+export async function setup(args, d) {
+    const yesAll = args.includes("--yes") || args.includes("-y");
+    const pick = args.find((a) => a.startsWith("--agents="))?.split("=")[1];
+    const only = pick?.split(",").map((s) => s.trim()).filter(Boolean);
+    const ask = (q, def = true) => (yesAll || !d.interactive ? Promise.resolve(def) : d.ask(q, def));
+    // 1. Huddle's own needs. Node is checked by preflight before we get here, but say it.
+    d.print(`\n${C.bold("Huddle setup")}\n`);
+    d.print(`  ${C.green("✓")} node ${d.node}${Number(d.node.split(".")[0]) < MIN_NODE ? C.red(` — needs ${MIN_NODE}+: ${nodeFix()}`) : ""}`);
+    const git = d.git();
+    if (git)
+        d.print(`  ${C.green("✓")} git ${git}`);
+    else
+        d.print(`  ${C.red("✗")} git is missing — Huddle gives every agent its own git worktree. Install it:\n      ${gitFix()}`);
+    if (only) {
+        const known = new Set(ADAPTERS.map((a) => a.id));
+        const unknown = only.filter((id) => !known.has(id));
+        if (unknown.length) {
+            d.print(C.red(`✗ --agents: no agent called ${unknown.join(", ")}.`) + ` Known: ${[...known].join(", ")}`);
+            return 1;
+        }
+        setAgentChoice(only, true);
+    }
+    // 2. Which agents you use. Asked once per agent; --yes keeps your earlier choices.
+    let results = await d.probe();
+    const inScope = (r) => (only ? only.includes(r.adapter.id) : true);
+    if (!only && d.interactive && !yesAll) {
+        d.print(C.faint("\n  Pick the agents you want Huddle to use. Skipped ones are never installed, asked about, or put to work."));
+        const skipped = skippedAgents();
+        const use = [];
+        const skip = [];
+        for (const r of results) {
+            const id = r.adapter.id;
+            const was = r.state === "skipped" ? r.was : r.state;
+            const note = was === "ready" ? "ready" : was === "not_authed" ? "installed, not signed in" : "not installed";
+            (await d.ask(`  Use ${dot(id)} ${C.bold(id)} ${C.faint(`(${note})`)}?`, !skipped.has(id)) ? use : skip).push(id);
+        }
+        setAgentChoice(use, true);
+        setAgentChoice(skip, false);
+        if (skip.some((id) => !skipped.has(id)) || use.some((id) => skipped.has(id)))
+            results = await d.probe();
+    }
+    // 3. Install what's missing, with this platform's command.
+    const missing = results.filter((r) => r.state === "not_installed" && inScope(r) && (only || !LEGACY.has(r.adapter.id)));
+    if (missing.length) {
+        d.print(`\n  ${C.bold("Not installed:")}`);
+        for (const r of missing)
+            d.print(`    ${dot(r.adapter.id)} ${C.bold(r.adapter.id.padEnd(12))} ${C.faint(installCommand(r.adapter) ? "$ " : "")}${installLine(r.adapter)}`);
+        const installable = missing.filter((r) => installCommand(r.adapter));
+        let chosen = [];
+        if (installable.length) {
+            if (!d.interactive && !yesAll) {
+                d.print(C.faint("\n  Run those yourself, or `huddle setup --yes` to have Huddle run them."));
+            }
+            else if (await ask(`\n  Install all missing (${installable.map((r) => r.adapter.id).join(", ")})?`)) {
+                chosen = installable.map((r) => r.adapter);
+            }
+            else {
+                for (const r of installable)
+                    if (await d.ask(`  Install ${r.adapter.id}?`, false))
+                        chosen.push(r.adapter);
+            }
+        }
+        let installed = false;
+        for (const a of chosen)
+            installed = installAgent(d, a) || installed;
+        if (installed)
+            results = await d.probe();
+    }
+    // 4. Sign in, one agent at a time: its own login, with the terminal handed over.
+    const signedOut = results.filter((r) => r.state === "not_authed" && inScope(r));
+    let signedIn = false;
+    for (const r of signedOut) {
+        const a = r.adapter;
+        const line = loginLine(a);
+        if (!line) {
+            d.print(`\n  ${dot(a.id)} ${C.bold(a.id)} isn't signed in — ${r.detail}`);
+            continue;
+        }
+        if (!d.interactive) {
+            d.print(`\n  ${dot(a.id)} ${C.bold(a.id)} isn't signed in — run: ${C.bold(line)}`);
+            continue;
+        }
+        // Even with --yes: a sign-in opens a browser, so the human is needed anyway — ask.
+        if (await d.ask(`\n  ${dot(a.id)} ${C.bold(a.id)} isn't signed in. Sign in now? ${C.faint(`($ ${line})`)}`)) {
+            signIn(d, a);
+            signedIn = true;
+        }
+    }
+    if (signedIn)
+        results = await d.probe();
+    // 5. Where that leaves you.
+    const ready = results.filter((r) => r.state === "ready");
+    const rest = results.filter((r) => inScope(r) && (r.state === "not_authed" || (r.state === "not_installed" && !LEGACY.has(r.adapter.id))));
+    d.print("");
+    if (ready.length)
+        d.print(`${C.green("✓")} ${ready.length} agent${ready.length === 1 ? "" : "s"} ready (${ready.map((r) => r.adapter.id).join(", ")}) — cd into a repo and run ${C.bold("huddle")}`);
+    else
+        d.print(`${C.yellow("No agents ready yet.")} Install or sign in to one, then run ${C.bold("huddle setup")} again.`);
+    if (rest.length)
+        d.print(C.faint(`  not ready: ${rest.map((r) => r.adapter.id).join(", ")} — run huddle setup again any time`));
+    if (!git)
+        d.print(C.red(`  git is still needed: ${gitFix()}`));
+    return ready.length && git ? 0 : 1;
+}
+//# sourceMappingURL=setup.js.map