tryharness 0.7.10 → 0.7.13

package/cli.mjs

@@ -5,7 +5,9 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { configureAgents, AGENTS, MCP_CLIENTS, detectMcpClients, mcpClientSnippet, removeAgentConfigurations } from "./lib/adapters.mjs";
-import { setupSwarm, testAgent } from "./lib/onboard.mjs";
+import { banner, setupSwarm, testAgent } from "./lib/onboard.mjs";
+import { createUi } from "./lib/ui.mjs";
+import pc from "picocolors";
 import { removeLocalWakes } from "./lib/wakes.mjs";
 import { detectAgents } from "./lib/commands.mjs";
 import { daemonRequest } from "./lib/control-client.mjs";
@@ -66,7 +68,7 @@ async function validateConnection(config) {
   } catch { return false; }
 }
 
-async function pair(pairOrigin, agents) {
+async function pair(pairOrigin, agents, ui) {
   const response = await fetch(pairOrigin + "/api/pair/start", {
     method: "POST",
     headers: { "content-type": "application/json" },
@@ -75,9 +77,9 @@ async function pair(pairOrigin, agents) {
   });
   if (!response.ok) throw new Error(`pairing unavailable (HTTP ${response.status})`);
   const { pairId, code } = await response.json();
-  console.log(`\n  Your code:  ${code}\n`);
-  console.log("In Harness: Settings -> Connections -> Connect a machine -> enter the code.");
-  console.log("Waiting for approval (expires in 10 minutes)...");
+  ui.note(`${pc.bold(code)}\n\n${pc.dim("In Harness: Settings → Connections → Connect a machine, then enter this code.")}`, "Pair this computer");
+  const spin = ui.spinner();
+  spin.start("Waiting for your approval (the code works for 10 minutes)");
   return new Promise((resolve, reject) => {
     fetch(pairOrigin + "/api/pair/wait/" + pairId, { headers: { accept: "text/event-stream" } }).then(async (waitResponse) => {
       if (!waitResponse.ok || !waitResponse.body) throw new Error("pairing stream failed");
@@ -100,7 +102,7 @@ async function pair(pairOrigin, agents) {
       }
       reject(new Error("pairing stream ended without approval"));
     }).catch(reject);
-  });
+  }).then((token) => { spin.stop("Paired with Harness"); return token; }, (error) => { spin.stop("Pairing did not finish", 2); throw error; });
 }
 
 async function waitForDaemon(timeoutMs = 12_000) {
@@ -126,72 +128,76 @@ async function connect() {
   const requested = argv.flatMap((value, index) => value === "--agent" && argv[index + 1] ? [argv[index + 1]] : []);
   for (const agent of requested) if (!AGENTS.includes(agent)) throw new Error(`unknown agent '${agent}'`);
   const selected = requested.length ? installed.filter((agent) => requested.includes(agent)) : installed;
-  console.log(`Harness setup ${VERSION}`);
-  console.log("detected: " + (installed.join(", ") || "no supported coding agents"));
+  const ui = createUi();
+  console.log(`\n${banner(VERSION)}\n`);
+  ui.intro(`${pc.bgCyan(pc.black(" tryharness "))}  Setting up Harness on this computer`);
+  ui.step(installed.length ? `Found ${installed.join(", ")}` : "No supported coding agents found");
 
   const pairOrigin = origin();
   let config = readJson(paths.config, {});
   const reusable = !has("--reconnect") && config.origin === pairOrigin && await validateConnection(config);
-  if (reusable) console.log("pairing: already connected");
+  if (reusable) ui.success(`Connected to Harness ${pc.dim(`· ${new URL(pairOrigin).host}`)}`);
   else {
-    const token = await pair(pairOrigin, selected);
+    const token = await pair(pairOrigin, selected, ui);
     config = { ...config, origin: pairOrigin, token };
     writeJsonAtomic(paths.config, config);
-    console.log("pairing: approved");
   }
 
   // The persistent runtime is version-pinned; neither MCP clients nor the login service
   // point into npm's temporary npx cache.
+  const spin = ui.spinner();
+  spin.start("Installing the Harness runtime and connecting your agents");
   const runtimeRoot = installRuntime({ sourceRoot: SOURCE_ROOT, version: VERSION });
   const states = configureAgents({ runtimeRoot, selected });
   const stateMap = Object.fromEntries(states.map((state) => [state.agent, state]));
   config = { ...readJson(paths.config, config), version: VERSION, runtimeRoot, agentStates: stateMap };
   writeJsonAtomic(paths.config, config);
   const service = installService({ runtimeRoot });
-  const ready = await waitForDaemon();
-  console.log(`daemon: ready via ${service.manager} and connected to Harness`);
-  await setupSwarm({ runtimeRoot, states, daemonRequest });
+  spin.message("Starting the daemon");
+  try { await waitForDaemon(); } catch (error) { spin.stop("The daemon did not connect to Harness", 2); throw error; }
+  spin.stop(`Daemon running ${pc.dim(`· ${service.manager}, connected to Harness`)}`);
+  await setupSwarm({ runtimeRoot, states, daemonRequest, ui });
   try {
     const devices = await daemonRequest({ command: "phone.list" });
     if (devices.ok && !devices.phones.some((device) => device.kind === "browser" && !device.revoked_at)) {
-      console.log("browser: connecting it to this computer end to end");
-      await link({ quiet: true });
-    } else if (devices.ok) console.log("browser: connected end to end");
+      const offer = await browserLink();
+      ui.info(offer.opened ? "Opened Harness in your browser to connect it to this computer end to end. The link works once, for 10 minutes."
+        : `Open this in the browser you use Harness in. It works once, for 10 minutes, and is the pairing secret:\n${offer.url}`);
+    } else if (devices.ok) ui.success("Browser connected end to end");
   } catch (error) {
-    console.log(`browser: not connected (${error.message}); run npx tryharness link`);
+    ui.warn(`Browser not connected (${error.message}). Run: npx tryharness link`);
   }
-  if (!has("--no-desktop")) desktop();
+  if (!has("--no-desktop")) { const shown = desktop(); (shown.ok ? ui.success : ui.info)(shown.text); }
   // The context space's embedder lives with the daemon and comes down with setup, so the machine
   // can search a task by meaning before the first task exists. About 110 MB, once.
-  try {
-    if (modelPresent(paths.models)) console.log("embedder: ready");
-    else { console.log("embedder: downloading (about 110 MB, once)"); await ensureModel({ modelsDir: paths.models, log: (line) => console.log(`  ${line}`) }); console.log("embedder: ready"); }
-  } catch (error) {
-    console.log(`embedder: not downloaded (${error.message}); task search uses words until the next setup run`);
+  if (modelPresent(paths.models)) ui.success("Embedder ready");
+  else {
+    const download = ui.spinner();
+    download.start("Downloading the embedder (about 110 MB, once)");
+    try { await ensureModel({ modelsDir: paths.models, log: (line) => download.message(`Downloading the embedder · ${line.slice(0, 30)}`) }); download.stop("Embedder ready"); }
+    catch (error) { download.stop(`Embedder not downloaded (${error.message}). Task search uses words until the next setup run`, 2); }
   }
   const failed = states.filter((state) => selected.includes(state.agent) && state.installed && !state.configured);
   if (failed.length) {
     throw new Error(`setup is incomplete for ${failed.map((state) => state.agent).join(", ")}. Nothing was hidden; run npx tryharness doctor after fixing the reported CLI error, then rerun setup.`);
   }
-  console.log("history: indexing locally in the background");
-  console.log("runs: your coding agents start the tasks you ask for in folders they have worked in, up to 10 a day each, without a Start; tasks another agent wrote wait for you. Change it: npx tryharness board standing");
-  console.log("Done. You can close this terminal.");
+  ui.info("History indexes locally in the background");
+  ui.info(`Your coding agents start the tasks you ask for in folders they have worked in, up to 10 a day each, without a Start. Tasks another agent wrote wait for you.\n${pc.dim("Change it: npx tryharness board standing")}`);
+  ui.outro("Done. You can close this terminal.");
 }
 
 // The desktop app: installed from this machine's platform package and opened. Never fatal; the
 // daemon works without it.
 function desktop() {
-  if (!canShowDesktop({})) { console.log("desktop: skipped (no screen on this login)"); return false; }
+  if (!canShowDesktop({})) return { ok: false, text: "Desktop app skipped (no screen on this login)" };
   const source = desktopSource({ sourceRoot: SOURCE_ROOT });
-  if (!source) { console.log(`desktop: no app for ${process.platform} ${process.arch} yet`); return false; }
+  if (!source) return { ok: false, text: `No desktop app for ${process.platform} ${process.arch} yet` };
   try {
     const { target, updated } = installDesktop({ source, target: desktopTarget({ source }) });
     openDesktop({ target });
-    console.log(`desktop: ${updated ? "installed and opened" : "opened"}. The Harness mark is at the top right of your screen; it starts when you log in.`);
-    return true;
+    return { ok: true, text: `Desktop app ${updated ? "installed and opened" : "opened"}. The Harness mark is at the top right of your screen; it starts when you log in.` };
   } catch (error) {
-    console.log(`desktop: not opened (${error.message})`);
-    return false;
+    return { ok: false, text: `Desktop app not opened (${error.message})` };
   }
 }
 
@@ -611,7 +617,10 @@ async function agents() {
     console.log(response.note ? `Every agent now reads this on ${response.agent}'s card: ${response.note}` : `${response.agent}'s card has no note now.`);
     return;
   }
-  await setupSwarm({ runtimeRoot: config.runtimeRoot, states: Object.values(config.agentStates || {}), daemonRequest, only: sub === "setup" ? agent || null : null });
+  const ui = createUi(), only = sub === "setup" ? agent || null : null;
+  ui.intro(`${pc.bgCyan(pc.black(" tryharness "))}  ${only ? `Setting up ${only}` : "Your swarm"}`);
+  await setupSwarm({ runtimeRoot: config.runtimeRoot, states: Object.values(config.agentStates || {}), daemonRequest, ui, only });
+  ui.outro("Done.");
 }
 
 async function phone() {
@@ -654,14 +663,15 @@ function openUrl(url) {
   const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
   try { spawn(command, args, { detached: true, stdio: "ignore" }).on("error", () => {}).unref(); return true; } catch { return false; }
 }
-async function link({ quiet = false } = {}) {
+async function browserLink() {
   const response = await daemonRequest({ command: "phone.offer", kind: "browser" });
   if (!response.ok) throw new Error(response.error || "the daemon could not make a link");
-  const opened = !has("--print") && openUrl(response.url);
-  if (!quiet || !opened) {
-    console.log(opened ? "Opened Harness in your browser to connect it to this computer end to end. The link works once, for 10 minutes." : `Open this in the browser you use Harness in. It works once, for 10 minutes, and is the pairing secret:\n\n${response.url}`);
-    console.log("Harness then carries what your browser and this computer say to each other sealed, and cannot read it.");
-  }
+  return { url: response.url, opened: !has("--print") && openUrl(response.url) };
+}
+async function link() {
+  const { url, opened } = await browserLink();
+  console.log(opened ? "Opened Harness in your browser to connect it to this computer end to end. The link works once, for 10 minutes." : `Open this in the browser you use Harness in. It works once, for 10 minutes, and is the pairing secret:\n\n${url}`);
+  console.log("Harness then carries what your browser and this computer say to each other sealed, and cannot read it.");
 }
 
 // Approving Harness in T3 Code (lib/t3.mjs): then what you send your T3 Code sessions from Harness, in the desktop app or
@@ -711,7 +721,7 @@ try {
   else if (command === "t3") await t3();
   else if (command === "peers") await peers();
   else if (command === "connect") await connectAgent();
-  else if (command === "desktop") { if (!desktop()) process.exitCode = 1; }
+  else if (command === "desktop") { const shown = desktop(); console.log(shown.text); if (!shown.ok) process.exitCode = 1; }
   else if (command === "logs") logs();
   else if (command === "disconnect") await disconnect();
   else if (command === "daemon") { const { startDaemon } = await import("./lib/daemon.mjs"); await startDaemon(); }

package/lib/onboard.mjs

@@ -1,22 +1,37 @@
 import { spawnSync } from "node:child_process";
-import readline from "node:readline";
+import pc from "picocolors";
 import { detectLocalAgents, setupHermes, setupOpenClaw, localWakes } from "./wakes.mjs";
+import { columns, createUi, wrap } from "./ui.mjs";
 
-// "Your swarm" in setup: every agent class with how Harness reaches it, the recommended way already chosen, the steps
-// numbered, and a real test at the end that passes only when the agent claims and reports a task. Also reachable on its
-// own as `npx tryharness agents`. Without a terminal to answer in, it only says what is set up and how to finish.
+// "Your swarm" in setup: every agent class with how Harness reaches it, the recommended way already chosen, and a real
+// test at the end that passes only when the agent claims and reports a task. Also reachable on its own as
+// `npx tryharness agents`. Without a terminal to answer in, it only says what is set up and how to finish.
 
 const SETUP = { openclaw: setupOpenClaw, hermes: setupHermes };
 const LABEL = { openclaw: "OpenClaw", hermes: "Hermes", "grok-bot": "Grok Bot" };
-const MEASURED = "measured on a real Grok: about 23s by email, 17s by webhook";
+const later = (agent) => `Later: ${pc.cyan(`npx tryharness agents setup ${agent}`)}`;
 
-export function createPrompter({ input = process.stdin, output = process.stdout } = {}) {
-  const ask = (question, { hidden = false } = {}) => new Promise((resolve) => {
-    const rl = readline.createInterface({ input, output, terminal: true });
-    if (hidden) rl._writeToOutput = (text) => { if (text.includes(question)) output.write(text); };
-    rl.question(question, (answer) => { rl.close(); if (hidden) output.write("\n"); resolve(answer.trim()); });
-  });
-  return { ask };
+// The Harness mark (src/main/home/landing/walkthrough/BrandMark.tsx) in box characters: dim corners, the bright one in
+// Harness teal, the wordmark beside it. Plain when the output is not a terminal or NO_COLOR is set.
+export function banner(version, { color = pc.isColorSupported } = {}) {
+  const c = pc.createColors(color), teal = (text) => (color ? `\x1b[38;5;36m${text}\x1b[39m` : text);
+  const rows = [
+    [c.dim("┌───"), "           ", teal("───┐")],
+    [c.dim("│"), "                 ", teal("│")],
+    [""],
+    ["      ", c.dim("┌──"), teal("───┐")],
+    ["      ", c.dim("│"), "     ", teal("│")],
+    ["      ", c.dim("└─────┘")],
+    [""],
+    [c.dim("│"), "                 ", c.dim("│")],
+    [c.dim("└───"), "           ", c.dim("───┘")],
+  ];
+  const side = { 3: c.bold("harness relay"), 4: "your personal swarm", 5: c.dim(`setup ${version}`) };
+  return rows.map((parts, index) => {
+    const line = parts.join("");
+    const width = line.replace(/\x1b\[[0-9;]*m/g, "").length;
+    return side[index] ? `  ${line}${" ".repeat(23 - width)}${side[index]}` : `  ${line}`.trimEnd();
+  }).join("\n");
 }
 
 const copy = (text) => {
@@ -26,106 +41,141 @@ const copy = (text) => {
 };
 
 /** Post a setup check for the agent and wait for its report: the same path real work takes. */
-export async function testAgent({ agent, daemonRequest, out = console.log, waitMs = 10 * 60_000, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) }) {
+export async function testAgent({ agent, daemonRequest, ui = createUi(), waitMs = 10 * 60_000, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) }) {
+  const name = LABEL[agent] || agent;
   const posted = await daemonRequest({ command: "board.post", agent: "user", objective: "Setup check from Harness: reply ready", brief: "Harness is checking that it can wake you. Claim this task and report it done with the single word: ready. Do nothing else.", targetAgent: agent });
-  if (!posted?.ok) { out(`    ! the test task could not be posted: ${posted?.error || "no answer"}`); return false; }
-  const started = Date.now();
-  out(`    Test sent. Waiting for ${LABEL[agent] || agent} to answer (Ctrl-C stops waiting; the test task stays on your board).`);
+  if (!posted?.ok) { ui.warn(`The test task could not be posted: ${posted?.error || "no answer"}`); return false; }
+  const started = Date.now(), spin = ui.spinner();
+  spin.start(`Waiting for ${name} to answer a test task`);
   while (Date.now() - started < waitMs) {
     await sleep(2_000);
     const task = (await daemonRequest({ command: "board.get", agent: "user", id: posted.task.id }).catch(() => null))?.task;
-    if (task?.status === "done") { out(`    ✓ ${LABEL[agent] || agent} answered in ${Math.round((Date.now() - started) / 1000)}s. Ready.`); return true; }
-    if (task && ["failed", "needs_input"].includes(task.status)) { out(`    ! ${LABEL[agent] || agent} answered but the task is ${task.status}: ${task.result || ""}`); return false; }
+    if (task?.status === "done") { spin.stop(`${name} answered in ${Math.round((Date.now() - started) / 1000)}s. Ready.`); return true; }
+    if (task && ["failed", "needs_input"].includes(task.status)) { spin.stop(`${name} answered, but the task is ${task.status}${task.result ? `: ${task.result}` : ""}`, 2); return false; }
   }
-  out(`    ! No answer after ${Math.round(waitMs / 60_000)} minutes. Check that the agent is running, then: npx tryharness agents test ${agent}`);
+  spin.stop(`No answer after ${Math.round(waitMs / 60_000)} minutes. Check that ${name} is running, then: npx tryharness agents test ${agent}`, 2);
   return false;
 }
 
-async function setupLocal({ entry, runtimeRoot, prompter, daemonRequest, out }) {
+async function setupLocal({ entry, runtimeRoot, ui, daemonRequest }) {
   const name = LABEL[entry.agent];
+  const run = async () => {
+    const result = SETUP[entry.agent]({ runtimeRoot });
+    if (!result.ok) { ui.warn(result.detail); return; }
+    ui.success(result.detail);
+    await testAgent({ agent: entry.agent, daemonRequest, ui });
+  };
   if (localWakes()[entry.agent]) {
     const health = (await daemonRequest({ command: "wake.local" }).catch(() => null))?.agents?.[entry.agent];
-    if (!health || health.answering) { out(`  ✓ ${name}: woken on this computer by its own webhook`); return; }
-    out(`  ! ${name}: not answering wakes (${health.lastFailure}). Check that it is running.`);
-    if (!prompter || /^n/i.test(await prompter.ask(`    Set ${name} up again? [Y/n] `))) { out(`    Later: npx tryharness agents setup ${entry.agent}`); return; }
-    const result = SETUP[entry.agent]({ runtimeRoot });
-    out(`    ${result.ok ? "✓" : "!"} ${result.detail}`);
-    if (result.ok) await testAgent({ agent: entry.agent, daemonRequest, out });
+    if (!health || health.answering) { ui.success(`${name} is woken on this computer by its own webhook`); return; }
+    ui.warn(`${name} is not answering wakes (${health.lastFailure}). Check that it is running.`);
+    if (!ui.interactive || !(await ui.confirm({ message: `Set ${name} up again?`, initialValue: true }))) { ui.info(later(entry.agent)); return; }
+    await run();
     return;
   }
-  if (!prompter) { out(`  ! ${name}: found. Set it up with: npx tryharness agents setup ${entry.agent}`); return; }
-  out(`  ${name} found. Harness wakes it with a webhook on this computer (recommended, nothing to copy).`);
-  out(`    This adds Harness to ${name}'s MCP servers and turns on its webhook with a key made here${entry.agent === "openclaw" ? ", then restarts its gateway" : ""}.`);
-  if (/^n/i.test(await prompter.ask(`    Set up ${name} now? [Y/n] `))) { out(`    Skipped. Later: npx tryharness agents setup ${entry.agent}`); return; }
-  const result = SETUP[entry.agent]({ runtimeRoot });
-  out(`    ${result.ok ? "✓" : "!"} ${result.detail}`);
-  if (result.ok) await testAgent({ agent: entry.agent, daemonRequest, out });
+  if (!ui.interactive) { ui.info(`${name} found. ${later(entry.agent)}`); return; }
+  ui.step(`${name} found on this computer\n${pc.dim(`Harness adds itself to ${name}'s MCP servers and turns on its webhook with a key made here${entry.agent === "openclaw" ? ", then restarts its gateway" : ""}. Nothing to copy.`)}`);
+  if (!(await ui.confirm({ message: `Set up ${name} now?`, initialValue: true }))) { ui.info(`Skipped. ${later(entry.agent)}`); return; }
+  await run();
+}
+
+async function waitFor(check, waitMs = 10 * 60_000, everyMs = 3_000) {
+  const end = Date.now() + waitMs;
+  while (Date.now() < end) {
+    if (await check()) return true;
+    await new Promise((r) => setTimeout(r, everyMs));
+  }
+  return false;
 }
 
-async function setupGrok({ prompter, daemonRequest, out, clipboard }) {
-  const listed = await daemonRequest({ command: "wake.server", input: { action: "list" } }).catch((error) => ({ ok: false, error: error.message }));
-  if (!listed.ok) { out(`  ! Grok Bot: Harness could not be reached (${listed.error}). Later: npx tryharness agents setup grok-bot`); return; }
+async function setupGrok({ ui, daemonRequest, clipboard }) {
+  const list = () => daemonRequest({ command: "wake.server", input: { action: "list" } });
+  const listed = await list().catch((error) => ({ ok: false, error: error.message }));
+  if (!listed.ok) { ui.warn(`Harness could not be reached (${listed.error}). ${later("grok-bot")}`); return; }
   const current = (listed.wakes || []).find((wake) => wake.agent === "grok-bot");
   if (current) {
     const how = current.channel === "email" ? `email at ${current.address}` : "its webhook";
-    if (current.answering) { out(`  ✓ Grok Bot: woken by ${how}`); return; }
-    out(`  ! Grok Bot: not answering wakes by ${how} (${current.last_failure}).`);
-    if (!prompter || /^n/i.test(await prompter.ask("    Set it up again? [Y/n] "))) { out("    Later: npx tryharness agents setup grok-bot"); return; }
+    if (current.answering) { ui.success(`Grok Bot is woken by ${how}`); return; }
+    ui.warn(`Grok Bot is not answering wakes by ${how} (${current.last_failure})`);
+    if (!ui.interactive || !(await ui.confirm({ message: "Set it up again?", initialValue: true }))) { ui.info(later("grok-bot")); return; }
   }
-  if (!prompter) { out("  Grok Bot: not set up. Set it up with: npx tryharness agents setup grok-bot"); return; }
-  out(`  Grok Bot. How should Harness wake it? (${MEASURED})`);
-  out("    1) Email     nothing to copy back                          (recommended)");
-  out("    2) Webhook   a little faster; you paste its URL and key here");
-  out("    3) Not now");
-  const choice = (await prompter.ask("    Choose [1]: ")) || "1";
-  if (choice === "3") { out("    Skipped. Later: npx tryharness agents setup grok-bot"); return; }
-  const channel = choice === "2" ? "webhook" : "email";
+  if (!ui.interactive) { ui.info(`Grok Bot is not set up. ${later("grok-bot")}`); return; }
+  const channel = await ui.select({
+    message: "How should Harness wake Grok Bot?",
+    initialValue: "email",
+    options: [
+      { value: "email", label: "Email", hint: "recommended · about 23s · nothing to copy back" },
+      { value: "webhook", label: "Webhook", hint: "about 17s · you paste its URL and key here" },
+      { value: "skip", label: "Not now" },
+    ],
+  });
+  if (!channel || channel === "skip") { ui.info(`Skipped. ${later("grok-bot")}`); return; }
   const message = listed.messages?.["grok-bot"]?.[channel];
-  if (!message) { out("    ! Harness did not send the setup message; update tryharness and try again."); return; }
+  if (!message) { ui.warn("Harness did not send the setup message. Update tryharness and try again."); return; }
+  const setup = (listed.setup || []).find((entry) => entry.agent === "grok-bot");
+  const connected = Boolean(setup) && !setup.missing?.includes("connection");
   const copied = clipboard(message);
-  out(`    1. ${copied ? "This message is on your clipboard. Paste it into Grok:" : "Paste this message into Grok:"}`);
-  out(message.split("\n").map((line) => `       ${line}`).join("\n"));
-  out("    2. Grok opens Harness's approval page. Name the connection Grok Bot and approve.");
+  ui.note(wrap(message, Math.max(40, columns() - 8)).join("\n"), copied ? "Paste this into Grok · it is on your clipboard" : "Paste this into Grok");
+  if (connected) ui.success(`Grok is already connected to Harness as Grok Bot${setup.old_approval ? `\n${pc.dim("approved before it could register its own address, so it gives you its address instead")}` : ""}`);
+  else ui.info("Grok opens Harness's approval page. Name the connection Grok Bot and approve it.");
+
+  const save = async (input, done) => {
+    const saved = await daemonRequest({ command: "wake.server", input: { action: "save", agent: "grok-bot", ...input } });
+    if (!saved.ok) { ui.warn(`${saved.error}. Try again: npx tryharness agents setup grok-bot`); return false; }
+    ui.success(done(saved));
+    return true;
+  };
   if (channel === "webhook") {
-    out("    3. In Grok, open Routines, then Harness wake, and copy its webhook URL and key.");
-    const address = await prompter.ask("       Webhook URL: ");
-    const key = await prompter.ask("       Key (hidden): ", { hidden: true });
-    const saved = await daemonRequest({ command: "wake.server", input: { action: "save", agent: "grok-bot", channel: "webhook", address, key } });
-    if (!saved.ok) { out(`    ! ${saved.error}. Try again: npx tryharness agents setup grok-bot`); return; }
-    out("    ✓ Saved. The key is stored sealed on Harness and is never shown again.");
+    ui.info("In Grok, open Routines, then Harness wake, and copy its webhook URL and key.");
+    const address = await ui.text({ message: "Grok's webhook URL", placeholder: "https://", validate: (value) => (/^https:\/\/\S+$/.test(value.trim()) ? undefined : "Paste the https URL from Grok's routine") });
+    if (!address) { ui.info(`Skipped. ${later("grok-bot")}`); return; }
+    const key = await ui.password({ message: "Its key", validate: (value) => (value.trim() ? undefined : "Paste the key from Grok's routine") });
+    if (!key) { ui.info(`Skipped. ${later("grok-bot")}`); return; }
+    if (!(await save({ channel: "webhook", address: address.trim(), key }, () => "Saved. The key is stored sealed on Harness and never shown again."))) return;
   } else {
-    out("    3. Grok registers its own address with Harness. Waiting for it (Ctrl-C stops waiting)...");
-    const registered = await waitFor(async () => ((await daemonRequest({ command: "wake.server", input: { action: "list" } }).catch(() => null))?.wakes || []).some((wake) => wake.agent === "grok-bot"));
-    if (!registered) { out("    Not registered yet. When Grok has done it: npx tryharness agents test grok-bot"); return; }
-    out("    ✓ Grok registered its address.");
+    const ownAddress = (value) => (/^[^\s@]+@mail\.grokbot\.com$/i.test(value.trim()) ? undefined : "Grok's address ends in @mail.grokbot.com");
+    let address = "";
+    if (setup?.old_approval) {
+      address = await ui.text({ message: "Grok's email address", placeholder: "name@mail.grokbot.com", validate: ownAddress }) ?? "";
+      if (!address) { ui.info(`Skipped. ${later("grok-bot")}`); return; }
+    } else {
+      // Grok registers its own address; the person may type the one Grok gives instead, and the prompt closes when it registers.
+      let settled = false;
+      const registered = waitFor(async () => settled || ((await list().catch(() => null))?.wakes || []).some((wake) => wake.agent === "grok-bot"))
+        .then((ok) => (ok ? { ok, line: "Grok registered its address" } : { ok, line: "Grok has not registered yet. When it has: npx tryharness agents test grok-bot" }));
+      const answer = await ui.waitOrType({ message: "Waiting for Grok to register its address", placeholder: "or type the address Grok gives you", until: registered });
+      let outcome = answer.done;
+      if (answer.cancelled) { settled = true; ui.info(`Stopped waiting. ${later("grok-bot")}`); return; }
+      if (answer.value && ownAddress(answer.value)) { settled = true; ui.warn(`${ownAddress(answer.value)}. ${later("grok-bot")}`); return; }
+      if (answer.value) address = answer.value;
+      else if (!outcome) {
+        const spin = ui.spinner();
+        spin.start("Waiting for Grok to register its address");
+        outcome = await registered;
+        spin.stop(outcome.line, outcome.ok ? 0 : 2);
+      }
+      settled = true;
+      if (outcome && !outcome.ok) return;
+    }
+    if (address && !(await save({ channel: "email", address: address.trim() }, (saved) => `Saved. Harness wakes Grok at ${saved.wake?.address ?? address.trim()}`))) return;
   }
-  await testAgent({ agent: "grok-bot", daemonRequest, out });
-}
-
-async function waitFor(check, waitMs = 10 * 60_000, everyMs = 3_000) {
-  const end = Date.now() + waitMs;
-  while (Date.now() < end) {
-    if (await check()) return true;
-    await new Promise((r) => setTimeout(r, everyMs));
-  }
-  return false;
+  await testAgent({ agent: "grok-bot", daemonRequest, ui });
 }
 
 /** The whole "Your swarm" step. `only` limits it to one agent (npx tryharness agents setup <agent>). */
-export async function setupSwarm({ runtimeRoot, states = [], daemonRequest, prompter = process.stdin.isTTY ? createPrompter() : null, out = console.log, only = null, clipboard = copy }) {
+export async function setupSwarm({ runtimeRoot, states = [], daemonRequest, ui = createUi(), only = null, clipboard = copy }) {
   const want = (agent) => !only || only === agent;
-  out("\nYour swarm");
-  if (!only) {
-    out("  On this computer: Harness starts them when work is posted");
-    for (const state of states) out(`    ${!state.installed ? "–" : state.configured ? "✓" : "!"} ${state.agent}: ${state.detail}`);
+  if (!only && states.length) {
+    const width = Math.max(...states.map((state) => state.agent.length));
+    const rows = states.map((state) => `${!state.installed ? pc.dim("–") : state.configured ? pc.green("✓") : pc.yellow("!")} ${state.agent.padEnd(width)}  ${pc.dim(state.detail)}`);
+    ui.step(`Coding agents on this computer ${pc.dim("· Harness starts them when work is posted")}\n${rows.join("\n")}`);
   }
   const local = detectLocalAgents().filter((entry) => entry.found && want(entry.agent));
-  if (local.length) out("  Agent apps on this computer: woken by a webhook Harness sets up");
-  for (const entry of local) await setupLocal({ entry, runtimeRoot, prompter, daemonRequest, out });
-  if (only && LABEL[only] && only !== "grok-bot" && !local.length) out(`  ${LABEL[only]} was not found on this computer.`);
+  for (const entry of local) await setupLocal({ entry, runtimeRoot, ui, daemonRequest });
+  if (only && LABEL[only] && only !== "grok-bot" && !local.length) ui.warn(`${LABEL[only]} was not found on this computer.`);
   if (want("grok-bot")) {
-    out("  Cloud agents: woken by email or webhook");
-    await setupGrok({ prompter, daemonRequest, out, clipboard });
+    ui.step(`Grok Bot ${pc.dim("· runs in its own cloud, woken by email or webhook")}`);
+    await setupGrok({ ui, daemonRequest, clipboard });
   }
-  if (!only) out("  Built in: Bankr and Quotient run on Harness, nothing to set up");
+  if (!only) ui.info(`Bankr and Quotient run on Harness ${pc.dim("· nothing to set up")}`);
 }

package/lib/runtime-install.mjs

@@ -76,7 +76,7 @@ export function installRuntime({ sourceRoot, version }) {
       if (!fs.existsSync(source)) continue;
       fs.cpSync(source, path.join(staging, entry), { recursive: true, force: true });
     }
-    copyDependencyClosure(sourceRoot, staging, ["node-sqlite3-wasm", "ws", "onnxruntime-web", "@huggingface/tokenizers"]);
+    copyDependencyClosure(sourceRoot, staging, ["node-sqlite3-wasm", "ws", "onnxruntime-web", "@huggingface/tokenizers", "@clack/prompts", "@clack/core", "picocolors"]);
     fs.writeFileSync(path.join(staging, ".ready"), version + "\n", { mode: 0o600 });
     ensureDir(path.dirname(release));
     fs.rmSync(release, { recursive: true, force: true });

package/lib/ui.mjs

@@ -0,0 +1,111 @@
+import * as p from "@clack/prompts";
+import { TextPrompt } from "@clack/core";
+import pc from "picocolors";
+
+// Setup's terminal interface, in the style of @clack/prompts (the skills installer's): a rail of steps, arrow-key
+// menus, spinners while waiting. createUi draws it; scriptedUi answers from a list and keeps what a person would have
+// seen, for tests. Prompts return null when the person cancels (Ctrl-C), so setup can skip that part and go on.
+
+const unicode = process.platform !== "win32" || Boolean(process.env.WT_SESSION) || process.env.TERM_PROGRAM === "vscode";
+const glyph = (fancy, plain) => (unicode ? fancy : plain);
+const BAR = glyph("│", "|"), END = glyph("└", "—"), ACTIVE = glyph("◆", "*"), DONE = glyph("◇", "o"), STOP = glyph("■", "x"), WARN = glyph("▲", "!");
+
+const visible = (text) => text.replace(/\x1b\[[0-9;]*m/g, "").length;
+
+/** Lines of text wrapped to a width, each keeping its own indent. */
+export function wrap(text, width) {
+  return text.split("\n").flatMap((line) => {
+    if (!line.trim()) return [""];
+    const indent = " ".repeat(line.length - line.trimStart().length), room = Math.max(20, width - indent.length), rows = [];
+    let row = "";
+    for (const word of line.trim().split(" ")) {
+      if (row && visible(row) + 1 + visible(word) > room) { rows.push(row); row = word; } else row = row ? `${row} ${word}` : word;
+    }
+    return [...rows, row].map((part) => `${indent}${part}`);
+  });
+}
+
+export const columns = () => process.stdout.columns || 100;
+
+// A text prompt Harness can close: shown while something else may finish first (Grok registering itself). `until`
+// resolves to { ok, line }; the prompt then closes with that line. Returns { value } when the person types and presses
+// Enter, { done } when `until` won, or { cancelled: true }.
+async function waitOrType({ message, placeholder, until }) {
+  const stop = new AbortController();
+  let done = null;
+  void until.then((result) => { done = result; stop.abort(); });
+  const value = await new TextPrompt({
+    placeholder,
+    signal: stop.signal,
+    render() {
+      const head = (symbol) => `${pc.gray(BAR)}\n${symbol}  ${message}\n`;
+      if (this.state === "submit") return `${head(pc.green(DONE))}${pc.gray(BAR)}  ${pc.dim(this.value || "keep waiting")}`;
+      if (this.state === "cancel" && done) return `${pc.gray(BAR)}\n${done.ok ? pc.green(DONE) : pc.yellow(WARN)}  ${done.line}`;
+      if (this.state === "cancel") return `${head(pc.red(STOP))}${pc.gray(BAR)}  ${pc.dim("stopped")}`;
+      const shown = this.value ? this.valueWithCursor : `${pc.inverse(placeholder[0])}${pc.dim(placeholder.slice(1))}`;
+      return `${head(pc.cyan(ACTIVE))}${pc.cyan(BAR)}  ${shown}\n${pc.cyan(END)}\n`;
+    },
+  }).prompt();
+  if (done) return { done };
+  if (p.isCancel(value)) return { cancelled: true };
+  return { value: String(value ?? "").trim() };
+}
+
+export function createUi({ interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY) } = {}) {
+  const answer = (value) => (p.isCancel(value) ? null : value);
+  // clack does not wrap; a long line would run back to the left edge, off the rail.
+  const fit = (text) => wrap(text, columns() - 4).join("\n");
+  return {
+    interactive,
+    intro: (title) => p.intro(title),
+    outro: (text) => p.outro(text),
+    step: (text) => p.log.step(fit(text)),
+    success: (text) => p.log.success(fit(text)),
+    info: (text) => p.log.info(fit(text)),
+    warn: (text) => p.log.warn(fit(text)),
+    message: (text) => p.log.message(fit(text)),
+    note: (text, title) => p.note(text, title),
+    select: async (opts) => answer(await p.select(opts)),
+    text: async (opts) => answer(await p.text(opts)),
+    password: async (opts) => answer(await p.password(opts)),
+    confirm: async (opts) => answer(await p.confirm(opts)),
+    // clack's spinner stops on Ctrl-C but keeps the process alive; setup ends there instead. Without a terminal (piped
+    // or logged) it is two plain lines, not animation frames.
+    spinner: () => {
+      if (!process.stdout.isTTY) return { start: (text) => p.log.message(fit(text)), message: () => {}, stop: (text, code) => (code ? p.log.warn : p.log.step)(fit(text)) };
+      const spin = p.spinner(), quit = () => process.exit(130);
+      return {
+        start: (text) => { spin.start(text); process.once("SIGINT", quit); },
+        message: (text) => spin.message(text),
+        stop: (text, code) => { process.removeListener("SIGINT", quit); spin.stop(text, code); },
+      };
+    },
+    waitOrType,
+  };
+}
+
+/** The same interface answered from `answers` in order (undefined takes the default); `lines` is what was shown. */
+export function scriptedUi(answers = [], lines = []) {
+  const say = (symbol) => (text) => { lines.push(...`${symbol} ${text}`.split("\n")); };
+  const next = (fallback) => { const value = answers.shift(); return value === undefined ? fallback : value; };
+  const ask = async (opts) => { lines.push(`? ${opts.message}`); const value = next(null); if (value !== null) lines.push(`  ${value}`); return value; };
+  return {
+    interactive: true,
+    lines,
+    intro: say("┌"), outro: say("└"), step: say("◇"), success: say("◆"), info: say("●"), warn: say("▲"), message: say("│"),
+    note: (text, title) => { lines.push(`[${title}]`, ...text.split("\n")); },
+    select: async (opts) => { lines.push(`? ${opts.message}`, ...opts.options.map((option) => `  ${option.label}${option.hint ? ` (${option.hint})` : ""}`)); return next(opts.initialValue ?? opts.options[0].value); },
+    text: ask,
+    password: async (opts) => { lines.push(`? ${opts.message}`); return next(null); },
+    confirm: async (opts) => { lines.push(`? ${opts.message}`); return next(opts.initialValue ?? true); },
+    spinner: () => ({ start: say("◒"), message: () => {}, stop: (text, code = 0) => say(code ? "▲" : "◇")(text) }),
+    waitOrType: async ({ message, until }) => {
+      lines.push(`? ${message}`);
+      const value = next("");
+      if (value) return { value };
+      const done = await until;
+      lines.push(`${done.ok ? "◇" : "▲"} ${done.line}`);
+      return { done };
+    },
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tryharness",
-  "version": "0.7.10",
+  "version": "0.7.13",
   "description": "Harness Relay: the daemon that turns the agents on this machine into your personal swarm. Memory, history, and work handed between any of them.",
   "bin": {
     "tryharness": "cli.mjs"
@@ -29,11 +29,14 @@
   "homepage": "https://tryharness.ai",
   "license": "MIT",
   "dependencies": {
+    "@clack/core": "0.5.0",
+    "@clack/prompts": "0.11.0",
+    "@huggingface/tokenizers": "^0.1.3",
     "node-sqlite3-wasm": "0.8.60",
+    "onnxruntime-web": "1.26.0-dev.20260416-b7804b056c",
+    "picocolors": "^1.1.1",
     "qr": "0.4.2",
-    "ws": "^8.18.3",
-    "@huggingface/tokenizers": "^0.1.3",
-    "onnxruntime-web": "1.26.0-dev.20260416-b7804b056c"
+    "ws": "^8.18.3"
   },
   "optionalDependencies": {
     "tryharness-desktop-darwin-arm64": "0.7.10",