huddle-cli 0.1.0 → 0.1.1

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