@runuai/host 0.1.0

package/src/cli.ts

@@ -0,0 +1,445 @@
+#!/usr/bin/env tsx
+/**
+ * `uai-host` CLI (ADR-028). Hand-rolled argv switch — no argparser dependency.
+ *
+ *   run | install | uninstall | start | stop | restart
+ *   status | logs [--follow] | pair <token> | open
+ *
+ * `run` boots the service in-process; the install/start/... family dispatches
+ * to the per-OS installer (scripts/install/{darwin,linux,win}.ts) by
+ * process.platform. `status`/`open` read the local UI's own JSON API.
+ */
+
+// MUST be first: load-env populates process.env from .env.local before any
+// import below pulls in lib/env, which freezes its config snapshot (uaiHome,
+// dataDir, hostKeyPath, …) at module-eval. `./paths` imports lib/env, so
+// without this the `run` path boots before UAI_DATA_DIR/UAI_HOME are loaded and
+// resolves the data dir — and the master key that decrypts every secret store
+// — from the wrong base. (main.ts loads it too, but `await import("./main")`
+// runs far too late.)
+import "./load-env";
+
+import { spawn, spawnSync } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { hostname } from "node:os";
+
+import { ulid } from "ulid";
+
+import { envLocalPath, serviceLogPath, uaiHome, uiPortFilePath } from "./paths";
+import { CloudResponse, StatusResponse, TasksResponse } from "./ui/types";
+import type { InstallContext, Installer } from "../scripts/install/types";
+
+// --- tiny ANSI (no chalk) ---------------------------------------------------
+
+const useColor = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+const paint =
+  (code: number) =>
+  (s: string): string =>
+    useColor ? `\x1b[${code}m${s}\x1b[0m` : s;
+const bold = paint(1);
+const dim = paint(2);
+const red = paint(31);
+const green = paint(32);
+const yellow = paint(33);
+const cyan = paint(36);
+
+// --- dispatch ---------------------------------------------------------------
+
+async function main(): Promise<void> {
+  const [cmd, ...rest] = process.argv.slice(2);
+  const dryRun = rest.includes("--dry-run");
+  const follow = rest.includes("--follow") || rest.includes("-f");
+  switch (cmd) {
+    case "run":
+      return cmdRun();
+    case "status":
+      return cmdStatus();
+    case "open":
+      return cmdOpen();
+    case "logs":
+      return cmdLogs(follow);
+    case "setup":
+      return cmdSetup(rest);
+    case "pair":
+      return cmdPair(rest[0]);
+    case "install":
+      return cmdInstall(dryRun);
+    case "uninstall":
+    case "start":
+    case "stop":
+    case "restart":
+      return cmdInstaller(cmd, dryRun);
+    case undefined:
+    case "help":
+    case "-h":
+    case "--help":
+      return printHelp();
+    default:
+      console.error(red(`unknown command: ${cmd}`));
+      printHelp();
+      process.exitCode = 1;
+  }
+}
+
+// --- run --------------------------------------------------------------------
+
+async function cmdRun(): Promise<void> {
+  // Boot the service in-process: main.ts's top-level code starts the WSS
+  // client + local UI server and keeps the event loop alive.
+  await import("./main");
+}
+
+// --- status -----------------------------------------------------------------
+
+async function cmdStatus(): Promise<void> {
+  const port = readPort();
+  if (port == null) {
+    console.log(
+      dim("service not running (no host.port). Start it: uai-host start  (or: uai-host run)"),
+    );
+    process.exitCode = 1;
+    return;
+  }
+  let status, cloud, tasks;
+  try {
+    status = StatusResponse.parse(await api(port, "/api/status"));
+    cloud = CloudResponse.parse(await api(port, "/api/cloud"));
+    tasks = TasksResponse.parse(await api(port, "/api/tasks"));
+  } catch (err) {
+    console.log(
+      dim(
+        `service unreachable on 127.0.0.1:${port} (${err instanceof Error ? err.message : String(err)})`,
+      ),
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  const stateColor =
+    cloud.state === "connected"
+      ? green
+      : cloud.state === "reconnecting"
+        ? yellow
+        : red;
+  console.log(bold("Uai host") + dim(` — ${status.hostName} · v${status.version}`));
+  console.log(
+    `  cloud    ${stateColor(cloud.state)} ${dim(status.cloudUrl)}` +
+      (cloud.reconnectCount ? dim(`  (reconnects: ${cloud.reconnectCount})`) : ""),
+  );
+  if (cloud.lastError) console.log(`           ${dim("last error: " + cloud.lastError)}`);
+  console.log(`  service  ${dim(`pid ${status.pid} · up ${fmtDuration(status.uptime * 1000)}`)}`);
+  console.log(`  ui       ${dim(`http://127.0.0.1:${port}`)}`);
+  console.log(`  log      ${dim(status.logPath)}`);
+  console.log(`  tasks    ${tasks.tasks.length === 0 ? dim("none") : tasks.tasks.length}`);
+  for (const t of tasks.tasks) {
+    const slugs = t.projectSlugs.length ? t.projectSlugs.join(",") : "scratchpad";
+    const age = t.ageMs != null ? fmtDuration(t.ageMs) : "—";
+    const mem = t.memoryBytes != null ? fmtBytes(t.memoryBytes) : "—";
+    console.log(
+      `    ${cyan((t.ownerEmail ?? "unknown").padEnd(22))} ${dim(slugs.padEnd(16))} ` +
+        `${(t.status ?? "—").padEnd(9)} ${dim(`up ${age}`.padEnd(11))} ${dim(mem)}`,
+    );
+    console.log(`      ${dim(t.taskId)}`);
+  }
+}
+
+async function api(port: number, path: string): Promise<unknown> {
+  const res = await fetch(`http://127.0.0.1:${port}${path}`);
+  if (!res.ok) throw new Error(`${path} → ${res.status}`);
+  return (await res.json()) as unknown;
+}
+
+// --- open -------------------------------------------------------------------
+
+async function cmdOpen(): Promise<void> {
+  const port = readPort();
+  if (port == null) {
+    console.error(red("no host.port — is the service running?"));
+    process.exitCode = 1;
+    return;
+  }
+  const url = `http://127.0.0.1:${port}`;
+  if (process.platform === "darwin") detach("open", [url]);
+  else if (process.platform === "win32") detach("cmd", ["/c", "start", "", url]);
+  else detach("xdg-open", [url]);
+  console.log(`opening ${url}`);
+}
+
+function detach(cmd: string, args: string[]): void {
+  const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+  child.on("error", (err) => console.error(red(`could not run ${cmd}: ${err.message}`)));
+  child.unref();
+}
+
+// --- logs -------------------------------------------------------------------
+
+async function cmdLogs(follow: boolean): Promise<void> {
+  const log = serviceLogPath();
+  if (log.startsWith("journald")) {
+    const args = ["--user", "-u", "uai-host"];
+    if (follow) args.push("-f");
+    inherit("journalctl", args);
+    return;
+  }
+  if (!existsSync(log)) {
+    console.error(red(`log not found: ${log}`));
+    console.error(dim("(install + start the service first, or run in the foreground)"));
+    process.exitCode = 1;
+    return;
+  }
+  inherit("tail", follow ? ["-f", log] : ["-n", "200", log]);
+}
+
+function inherit(cmd: string, args: string[]): void {
+  const child = spawn(cmd, args, { stdio: "inherit" });
+  child.on("error", (err) => {
+    console.error(red(`could not run ${cmd}: ${err.message}`));
+    process.exitCode = 1;
+  });
+  child.on("exit", (code) => process.exit(code ?? 0));
+}
+
+// --- setup (enrollment, ADR-031) --------------------------------------------
+
+/** Read a `--name value` or `--name=value` flag from argv. */
+function flagValue(rest: string[], name: string): string | undefined {
+  const i = rest.indexOf(name);
+  if (i >= 0 && rest[i + 1]) return rest[i + 1];
+  const eq = rest.find((a) => a.startsWith(`${name}=`));
+  return eq ? eq.slice(name.length + 1) : undefined;
+}
+
+/**
+ * Claim this machine as a host: redeem a one-time enrollment token (minted in
+ * the web app) for a permanent bridge credential, then write the config. The
+ * bridge secret is generated HERE and never leaves — only its hash is sent
+ * (ADR-015/ADR-031).
+ *
+ *   uai-host setup --cloud wss://app.runuai.com/host --enroll uaienroll_…
+ */
+async function cmdSetup(rest: string[]): Promise<void> {
+  const enroll = flagValue(rest, "--enroll");
+  const cloud = flagValue(rest, "--cloud");
+  if (!enroll || !cloud) {
+    console.error(
+      red("usage: uai-host setup --cloud <wss-url> --enroll <token>"),
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  let cloudUrl: URL;
+  try {
+    cloudUrl = new URL(cloud);
+  } catch {
+    console.error(red(`invalid --cloud URL: ${cloud}`));
+    process.exitCode = 1;
+    return;
+  }
+
+  // Don't silently re-enroll an already-claimed machine (would orphan the old
+  // host row + steal its slot).
+  const existing = existsSync(envLocalPath())
+    ? readFileSync(envLocalPath(), "utf8")
+    : "";
+  if (/^UAI_HOST_TOKEN=/m.test(existing) && !rest.includes("--force")) {
+    console.error(red("this machine is already enrolled (UAI_HOST_TOKEN set)."));
+    console.error(
+      dim("re-enrolling creates a new host + orphans the old one — pass --force to proceed."),
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  const proto =
+    cloudUrl.protocol === "wss:"
+      ? "https:"
+      : cloudUrl.protocol === "ws:"
+        ? "http:"
+        : cloudUrl.protocol;
+  const redeemUrl = `${proto}//${cloudUrl.host}/api/hosts/enroll/redeem`;
+
+  // This host's identity + bridge secret. Secret stays local; cloud gets the hash.
+  const hostId = ulid().toLowerCase();
+  const secret = randomBytes(32).toString("hex");
+  const tokenHash = createHash("sha256").update(secret).digest("hex");
+  const name = hostname();
+
+  console.log(dim(`enrolling ${name} (${hostId}) with ${cloudUrl.host}…`));
+  let res: Response;
+  try {
+    res = await fetch(redeemUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ enrollToken: enroll, hostId, tokenHash, name }),
+      signal: AbortSignal.timeout(15_000),
+    });
+  } catch (err) {
+    console.error(
+      red(`could not reach the cloud: ${err instanceof Error ? err.message : String(err)}`),
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (!res.ok) {
+    let detail = `HTTP ${res.status}`;
+    try {
+      const j = (await res.json()) as { error?: { message?: string } };
+      if (j.error?.message) detail = j.error.message;
+    } catch {
+      /* keep the HTTP status */
+    }
+    console.error(red(`enrollment failed: ${detail}`));
+    console.error(
+      dim("the token may be expired or already used — mint a fresh one in the web app."),
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  upsertEnvLocal("UAI_HOST_ID", hostId);
+  upsertEnvLocal("UAI_HOST_TOKEN", secret);
+  upsertEnvLocal("UAI_CLOUD_URL", cloud);
+  console.log(green("✓ enrolled") + dim(` — config written to ${envLocalPath()}`));
+  console.log("");
+  console.log("Start the host:");
+  console.log(cyan("  uai-host install && uai-host start") + dim("   (first time)"));
+  console.log(cyan("  uai-host restart") + dim("                     (already installed)"));
+}
+
+// --- pair -------------------------------------------------------------------
+
+async function cmdPair(token: string | undefined): Promise<void> {
+  if (!token) {
+    console.error(red("usage: uai-host pair <token>"));
+    process.exitCode = 1;
+    return;
+  }
+  // v1 "pairing" = persist the host token to .env.local (load-env.ts reads it).
+  // The cloud-issued-pairing-token -> host-token handshake is a future flow
+  // (hosted-architecture.md, "what we don't do now"); this stores what you paste.
+  upsertEnvLocal("UAI_HOST_TOKEN", token);
+  console.log(green("paired") + dim(` — wrote UAI_HOST_TOKEN to ${envLocalPath()}`));
+  console.log(dim("apply it: uai-host restart  (or start the service)"));
+}
+
+function upsertEnvLocal(key: string, value: string): void {
+  const path = envLocalPath();
+  const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
+  const kept = existing
+    .split("\n")
+    .filter((l) => !l.startsWith(`${key}=`) && l.trim() !== "");
+  kept.push(`${key}=${value}`);
+  writeFileSync(path, kept.join("\n") + "\n", { mode: 0o600 });
+}
+
+// --- install dispatch -------------------------------------------------------
+
+async function cmdInstall(dryRun: boolean): Promise<void> {
+  const installer = await loadInstaller();
+  await installer.install(installContext(dryRun));
+  if (!dryRun) console.log(green("installed") + dim(" — start it: uai-host start"));
+}
+
+async function cmdInstaller(
+  action: "uninstall" | "start" | "stop" | "restart",
+  dryRun: boolean,
+): Promise<void> {
+  const installer = await loadInstaller();
+  await installer[action](dryRun);
+  if (!dryRun && action === "uninstall") console.log(green("uninstalled"));
+}
+
+async function loadInstaller(): Promise<Installer> {
+  const name =
+    process.platform === "darwin"
+      ? "darwin"
+      : process.platform === "win32"
+        ? "win"
+        : "linux";
+  try {
+    const mod = (await import(`../scripts/install/${name}`)) as {
+      installer: Installer;
+    };
+    return mod.installer;
+  } catch (err) {
+    throw new Error(
+      `no installer available for ${process.platform}: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}
+
+function installContext(dryRun: boolean): InstallContext {
+  const run = resolveRunCommand();
+  return { execPath: run.execPath, args: run.args, cwd: uaiHome(), dryRun };
+}
+
+/** The command that runs `uai-host run`: the installed binary if on PATH,
+ *  else `pnpm host-agent` from the repo (dev). */
+function resolveRunCommand(): { execPath: string; args: string[] } {
+  const uaiHost = which("uai-host");
+  if (uaiHost) return { execPath: uaiHost, args: ["run"] };
+  return { execPath: which("pnpm") ?? "pnpm", args: ["host-agent"] };
+}
+
+function which(cmd: string): string | null {
+  const finder = process.platform === "win32" ? "where" : "which";
+  const res = spawnSync(finder, [cmd], { encoding: "utf8" });
+  if (res.status !== 0 || !res.stdout) return null;
+  return res.stdout.split("\n")[0]?.trim() || null;
+}
+
+// --- helpers ----------------------------------------------------------------
+
+function readPort(): number | null {
+  const p = uiPortFilePath();
+  if (!existsSync(p)) return null;
+  const n = Number(readFileSync(p, "utf8").trim());
+  return Number.isInteger(n) && n > 0 ? n : null;
+}
+
+function fmtDuration(ms: number): string {
+  const s = Math.floor(ms / 1000);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ${m % 60}m`;
+  return `${Math.floor(h / 24)}d ${h % 24}h`;
+}
+
+function fmtBytes(n: number): string {
+  if (n < 1024) return `${n} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let v = n / 1024;
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i += 1;
+  }
+  return `${v.toFixed(1)} ${units[i]}`;
+}
+
+function printHelp(): void {
+  console.log(`${bold("uai-host")} — local host service (ADR-028)
+
+  run                  run the service in the foreground (debug)
+  install [--dry-run]  install as a per-user service for this OS
+  uninstall            remove the service
+  start | stop         control the installed service
+  restart              stop + start
+  status               connection, service info, active tasks (same as the UI)
+  logs [--follow]      tail the service log
+  setup --cloud <wss-url> --enroll <token>
+                       claim this machine via an enrollment token from the web
+                       app (mints + writes the host credential)
+  pair <token>         store a host token directly (manual fallback)
+  open                 open the local UI in your browser
+`);
+}
+
+main().catch((err) => {
+  console.error(red(err instanceof Error ? err.message : String(err)));
+  process.exitCode = 1;
+});