@runuai/host 0.8.13 → 0.8.17

package/src/cli.ts

@@ -27,6 +27,10 @@ import { dirname } from "node:path";
 
 import { ulid } from "ulid";
 
+import {
+  persistTelemetryDisclosure,
+  telemetryNoticeIfActive,
+} from "../lib/obs";
 import { envLocalPath, serviceLogPath, uaiHome, uiPortFilePath } from "./paths";
 import { CloudResponse, StatusResponse, TasksResponse } from "./ui/types";
 import type { InstallContext, Installer } from "../scripts/install/types";
@@ -322,6 +326,7 @@ async function cmdSetup(rest: string[]): Promise<void> {
     return;
   }
   console.log(green("✓ enrolled") + dim(` — config written to ${envLocalPath()}`));
+  printTelemetryNotice();
   console.log("");
   console.log("Start the host:");
   console.log(cyan("  uai-host install && uai-host start") + dim("   (first time)"));
@@ -342,6 +347,7 @@ async function cmdPair(token: string | undefined): Promise<void> {
   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)"));
+  printTelemetryNotice();
 }
 
 function upsertEnvLocal(key: string, value: string): void {
@@ -361,15 +367,41 @@ function upsertEnvLocal(key: string, value: string): void {
 // --- install dispatch -------------------------------------------------------
 
 async function cmdInstall(dryRun: boolean): Promise<void> {
+  // Disclosure BEFORE activation (review): install starts the service, and
+  // the notice must precede the first telemetry-armed run.
+  if (!dryRun) printTelemetryNotice();
   const installer = await loadInstaller();
   await installer.install(installContext(dryRun));
-  if (!dryRun) console.log(green("installed") + dim(" — start it: uai-host start"));
+  if (!dryRun) {
+    console.log(green("installed") + dim(" — start it: uai-host start"));
+  }
+}
+
+/**
+ * ADR-071 default-on disclosure at the surfaces an operator actually SEES:
+ * the service's own start line only reaches host.out.log/journald, so the
+ * interactive commands (install/pair/setup/start/restart) print it — and
+ * PERSIST the shown-once marker that gates the baked default (a silently
+ * upgraded service stays off until one of these runs).
+ */
+function printTelemetryNotice(): void {
+  const notice = telemetryNoticeIfActive();
+  if (notice) {
+    console.log(yellow("telemetry: ") + notice);
+    persistTelemetryDisclosure();
+  }
 }
 
 async function cmdInstaller(
   action: "uninstall" | "start" | "stop" | "restart",
   dryRun: boolean,
 ): Promise<void> {
+  // Upgrade path (review finding): operators of EXISTING installs meet
+  // default-on telemetry through start/restart — disclose BEFORE the
+  // service action activates anything, and persist the gate marker.
+  if (!dryRun && (action === "start" || action === "restart")) {
+    printTelemetryNotice();
+  }
   const installer = await loadInstaller();
   await installer[action](dryRun);
   if (!dryRun && action === "uninstall") console.log(green("uninstalled"));

package/src/load-env.ts

@@ -3,16 +3,37 @@
  * read environment variables.
  */
 
-import { existsSync } from "node:fs";
+import { existsSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { dirname, join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { config as dotenvConfig } from "dotenv";
+
 const proc = process as unknown as {
   loadEnvFile?: (path: string) => void;
 };
 
-const here = dirname(fileURLToPath(import.meta.url)); // <pkg>/src
+// Real path, not the import path: pnpm workspace links reach this file via
+// symlinks — a repo checkout must resolve to the checkout, and an installed
+// tarball to its true node_modules location.
+const here = (() => {
+  const raw = dirname(fileURLToPath(import.meta.url)); // <pkg>/src
+  try {
+    return realpathSync(raw);
+  } catch {
+    return raw;
+  }
+})();
+
+// An INSTALLED copy always lives under a node_modules directory. Without
+// this guard, a tarball installed beneath some user's pnpm workspace that
+// happens to contain a sibling host-agent/ dir was mistaken for this source
+// checkout — suppressing telemetry AND selecting the wrong UAI_HOME
+// (review finding). Packaged desktop resources contain no node_modules
+// segment and no workspace above them; the repo checkout contains neither
+// problem.
+const installedCopy = here.split(sep).includes("node_modules");
 
 // Resolve the same UAI_HOME as lib/env.ts, but independently: this module runs
 // FIRST (before lib/env is imported) so it can't depend on it. .env.local is
@@ -28,22 +49,44 @@ function findUp(start: string, pred: (dir: string) => boolean): string | null {
   }
 }
 
-const repoRoot = findUp(
-  here,
-  (d) =>
-    existsSync(resolve(d, "pnpm-workspace.yaml")) &&
-    existsSync(resolve(d, "host-agent")),
-);
+const repoRoot = installedCopy
+  ? null
+  : findUp(
+      here,
+      (d) =>
+        existsSync(resolve(d, "pnpm-workspace.yaml")) &&
+        existsSync(resolve(d, "host-agent")),
+    );
 
 const uaiHome = process.env.UAI_HOME
   ? resolve(process.env.UAI_HOME.replace(/^~(?=\/|$)/, homedir()))
   : (repoRoot ?? resolve(homedir(), ".uai"));
 
+// ADR-071: expose the repo-checkout detection computed above to the
+// telemetry gate (lib/obs resolveHostDsn). `pnpm host-agent` from a fresh
+// checkout and host-desktop's non-packaged dev launch set neither NODE_ENV
+// nor UAI_AGENT_FROM_REPO — this marker is the signal tied to the REAL
+// launch path, so dev runs never default-activate crash reporting. Packaged
+// installs (npm tarball, desktop resources) have no workspace file above
+// them and stay unmarked.
+if (repoRoot && !process.env.UAI_LAUNCHED_FROM_REPO) {
+  process.env.UAI_LAUNCHED_FROM_REPO = "1";
+}
+
 for (const file of [".env.local", ".env"]) {
   const path = join(uaiHome, file);
-  if (!proc.loadEnvFile || !existsSync(path)) continue;
+  if (!existsSync(path)) continue;
   try {
-    proc.loadEnvFile(path);
+    if (proc.loadEnvFile) {
+      proc.loadEnvFile(path);
+    } else {
+      // process.loadEnvFile landed in Node 20.12; the package supports
+      // >=20. Silently skipping .env.local on 20.0–20.11 would ignore
+      // UAI_TELEMETRY_DISABLED — the telemetry kill switch MUST load on
+      // every supported Node, so fall back to dotenv (already a dep).
+      // Neither loader overrides pre-set process.env — same semantics.
+      dotenvConfig({ path });
+    }
   } catch (err) {
     console.warn(
       `[host-agent] could not load ${file}: ${(err as Error).message}`,

package/src/main.ts

@@ -23,7 +23,7 @@ import {
   markReconnecting,
 } from "../lib/cloud-state";
 import { getHostTask } from "../lib/runtime-state";
-import { getOrchestrator } from "../lib/orchestrator";
+import { getOrchestrator, recoveryComplete } from "../lib/orchestrator";
 import {
   connectedUserIds,
   isTransientGithubError,
@@ -45,6 +45,7 @@ import {
 } from "../lib/host-env";
 import { handleMcpOp } from "../lib/mcp-connections";
 import { startMcpGateway } from "../lib/mcp-gateway";
+import { addHostBreadcrumb, initHostObs, setHostObsTag } from "../lib/obs";
 import {
   packageVersion,
   serviceLogPath,
@@ -89,6 +90,11 @@ import {
   FilesOpInput,
 } from "./protocol";
 
+// Crash reporting (ADR-071) — default-ON for installed hosts via the baked
+// DSN (lib/obs.ts); repo checkouts and dev/test never default-activate.
+// UAI_TELEMETRY_DISABLED=1 turns it off; UAI_SENTRY_DSN overrides.
+initHostObs({ version: packageVersion() });
+
 const PING_INTERVAL_MS = 15_000;
 const DEAD_AFTER_MS = 45_000;
 // Reconnect backoff, capped low (~15s) on purpose: cloud deploys drop the
@@ -159,7 +165,13 @@ void ensureStandardImage();
 // token → `codex login`) otherwise reaches only NEW tasks — re-copy into
 // running tasks on start (covers the desktop "Connect Codex", which restarts
 // the host) and watch ~/.codex for future logins (a terminal `codex login`).
-void reinjectCodexRunningTasks();
+// Sequenced AFTER boot recovery: reinjecting while recovery was still
+// `docker start`ing exited containers raced — `docker cp` into a stopped
+// container succeeds but the ownership-fix exec can't run, stranding 0600
+// files owned by the host uid (macOS 501) that the container's node (1000)
+// can't read, and Codex died at startup. The post-recovery sweep also
+// self-heals such containers: it re-copies and chowns every running task.
+void recoveryComplete().then(() => reinjectCodexRunningTasks());
 watchCodexAuth();
 connect();
 // Local browser UI (ADR-028) — same single process, alongside the WSS client.
@@ -262,6 +274,8 @@ function connect(): void {
     reconnectAttempt = 0;
     markConnected();
     console.log(`[host-agent] connected as ${hostId}`);
+    setHostObsTag(hostId);
+    addHostBreadcrumb("bridge", "connected");
 
     unsubscribe = hostEvents.subscribe((event) => {
       if (socket.readyState !== WebSocket.OPEN) return;
@@ -440,6 +454,11 @@ function connect(): void {
     console.warn(
       `[host-agent] disconnected${ready ? "" : " before auth"}; reconnecting in ${Math.round(delay)}ms`,
     );
+    addHostBreadcrumb("bridge", "disconnected", {
+      code,
+      authed: ready,
+      retryInMs: Math.round(delay),
+    });
     setTimeout(connect, delay);
   });
 }

package/src/ui/server.ts

@@ -30,6 +30,8 @@ import { dockerCli } from "../../lib/docker-exec";
 import {
   connectEngine,
   disconnectEngine,
+  engineCliStatuses,
+  installEngineCli,
   engineCatalog,
   engineStatuses,
   isEngineKind,
@@ -151,6 +153,8 @@ async function handle(
       switch (path) {
         case "/api/engines/connect":
           return await handleEngineConnect(req, res, opts);
+        case "/api/engines/install":
+          return await handleEngineInstall(req, res);
         case "/api/engines/disconnect":
           return await handleEngineDisconnect(req, res, opts);
         case "/api/tasks/stop":
@@ -181,7 +185,7 @@ async function handle(
       case "/api/users":
         return sendJson(res, UsersResponse, usersBody(opts));
       case "/api/engines":
-        return sendJson(res, EnginesResponse, enginesBody());
+        return sendJson(res, EnginesResponse, await enginesBody());
     }
     if (path.startsWith("/api/")) {
       return sendError(res, 404, `no such endpoint: ${path}`);
@@ -194,8 +198,47 @@ async function handle(
 
 // --- engines ----------------------------------------------------------------
 
-function enginesBody(): EnginesResponse {
-  return { catalog: engineCatalog(), statuses: engineStatuses() };
+async function enginesBody(): Promise<EnginesResponse> {
+  return {
+    catalog: engineCatalog(),
+    statuses: engineStatuses(),
+    cli: await engineCliStatuses(),
+  };
+}
+
+/**
+ * POST /api/engines/install `{kind}` — run the engine's pinned installer,
+ * streaming NDJSON like connect: `{"line":…}` frames, then `{done,ok,message}`.
+ * No re-advertise or image rebuild here: installing a CLI connects nothing;
+ * that happens on the connect that follows.
+ */
+async function handleEngineInstall(
+  req: IncomingMessage,
+  res: ServerResponse,
+): Promise<void> {
+  const body = await readJsonBody(req);
+  const kind = body?.kind;
+  if (!isEngineKind(kind)) {
+    return sendError(res, 400, "unknown or missing engine kind");
+  }
+  res.writeHead(200, {
+    "content-type": "application/x-ndjson; charset=utf-8",
+    "cache-control": "no-store",
+  });
+  const emit = (obj: unknown): void => {
+    res.write(`${JSON.stringify(obj)}\n`);
+  };
+  let result: { ok: boolean; message: string };
+  try {
+    result = await installEngineCli(kind, (line) => emit({ line }));
+  } catch (err) {
+    result = {
+      ok: false,
+      message: err instanceof Error ? err.message : "install failed",
+    };
+  }
+  emit({ done: true, ok: result.ok, message: result.message });
+  res.end();
 }
 
 /**

package/src/ui/types.ts

@@ -84,12 +84,15 @@ export const EngineCatalogEntry = z.object({
   // Pasted-API-key alternative to the login/token flow (null = not offered).
   apiKeyHint: z.string().nullable(),
   apiKeyUrl: z.string().nullable(),
+  // Install command shown when the CLI is missing (null = nothing to install).
+  installHint: z.string().nullable(),
 });
 export type EngineCatalogEntry = z.infer<typeof EngineCatalogEntry>;
 
 export const EnginesResponse = z.object({
   catalog: z.array(EngineCatalogEntry),
   statuses: z.record(z.boolean()), // kind → connected
+  cli: z.record(z.boolean()), // kind → CLI resolvable on this host
 });
 export type EnginesResponse = z.infer<typeof EnginesResponse>;
 

package/ui/app.js

@@ -483,6 +483,11 @@ function commandForm(e) {
   log.className = "log";
   log.hidden = true;
 
+  const pushLine = (line) => {
+    log.textContent += (log.textContent ? "\n" : "") + line;
+    log.scrollTop = log.scrollHeight;
+  };
+
   const actions = document.createElement("div");
   actions.className = "setup-actions";
   const connect = document.createElement("button");
@@ -499,10 +504,7 @@ function commandForm(e) {
         : "Your browser will open to sign in…";
     log.hidden = false;
     log.textContent = "";
-    const result = await runConnect({ kind: e.kind }, (line) => {
-      log.textContent += (log.textContent ? "\n" : "") + line;
-      log.scrollTop = log.scrollHeight;
-    });
+    const result = await runConnect({ kind: e.kind }, pushLine);
     if (result.ok) {
       await poll();
       closeModal();
@@ -514,6 +516,47 @@ function commandForm(e) {
     }
   });
   actions.append(connect);
+
+  // CLI missing → offer the pinned installer first, chaining into connect on
+  // success. The command is shown verbatim; its output streams into the log.
+  const cliMissing =
+    !!latestEngines?.cli && latestEngines.cli[e.kind] === false && !!e.installHint;
+  if (cliMissing) {
+    connect.hidden = true;
+    const installNote = document.createElement("p");
+    installNote.className = "setup-note";
+    installNote.textContent = `The ${e.label} CLI isn't installed on this Mac. Install it with:`;
+    const installCmd = document.createElement("pre");
+    installCmd.className = "log";
+    installCmd.textContent = e.installHint;
+    const install = document.createElement("button");
+    install.className = "btn";
+    install.type = "button";
+    install.textContent = "Install & connect";
+    install.addEventListener("click", async () => {
+      install.disabled = true;
+      install.textContent = "Installing…";
+      status.className = "setup-status";
+      status.textContent = "Running the installer…";
+      log.hidden = false;
+      log.textContent = "";
+      const result = await runInstall({ kind: e.kind }, pushLine);
+      if (result.ok) {
+        await poll();
+        install.hidden = true;
+        connect.hidden = false;
+        connect.click();
+      } else {
+        install.disabled = false;
+        install.textContent = "Try again";
+        status.className = "setup-status err";
+        status.textContent = result.message || "Install failed.";
+      }
+    });
+    actions.prepend(install);
+    form.append(installNote, installCmd);
+  }
+
   form.append(actions, status, log);
 
   // Manual paste fallback for when the browser flow isn't possible: Claude
@@ -590,14 +633,24 @@ function commandForm(e) {
   return form;
 }
 
+/** POST /api/engines/connect and consume the NDJSON stream. */
+function runConnect(body, onLine) {
+  return runStream("/api/engines/connect", body, onLine);
+}
+
+/** POST /api/engines/install and consume the NDJSON stream. */
+function runInstall(body, onLine) {
+  return runStream("/api/engines/install", body, onLine);
+}
+
 /**
- * POST /api/engines/connect and consume the NDJSON stream: `{line}` frames feed
- * onLine; the final `{done,ok,message}` frame is the result.
+ * POST an NDJSON-streaming endpoint: `{line}` frames feed onLine; the final
+ * `{done,ok,message}` frame is the result.
  */
-async function runConnect(body, onLine) {
+async function runStream(path, body, onLine) {
   let res;
   try {
-    res = await fetch("/api/engines/connect", {
+    res = await fetch(path, {
       method: "POST",
       headers: { "content-type": "application/json" },
       body: JSON.stringify(body),
@@ -606,7 +659,7 @@ async function runConnect(body, onLine) {
     return { ok: false, message: String(err) };
   }
   if (!res.ok || !res.body) {
-    return { ok: false, message: `connect failed (${res.status})` };
+    return { ok: false, message: `request failed (${res.status})` };
   }
   const reader = res.body.getReader();
   const dec = new TextDecoder();