failproofai 1.0.10 → 1.0.11-beta.1

package/scripts/launch-facts.ts

@@ -0,0 +1,157 @@
+/**
+ * What the launch screen states about this machine, read from disk.
+ *
+ * Files only: no daemon probe, no `systemctl`, no `which` (`detectInstalled()`
+ * spawns one per agent), and no policy file imported. This runs on every bare
+ * `failproofai`, while someone waits for a URL. Each fact is read on its own
+ * and degrades on its own, so an unreadable file costs one row its detail and
+ * never the screen.
+ */
+// Aliased for the same reason as the long names below: the CLI is one
+// scope-hoisted bundle, where another plain `resolve` import renumbers every
+// later module's `resolveN` binding.
+import { resolve as resolveLaunchPath } from "node:path";
+import { INTEGRATION_TYPES } from "../src/hooks/types";
+import { getIntegration } from "../src/hooks/integrations";
+import { integrationsInstalledAt, notEnforcingReason } from "../src/hooks/manager";
+import { readConfig, readCredentials, type FpConfig } from "../src/hooks/fp-config";
+import { readCloudCredentials } from "../src/hooks/cloud-enrollment";
+import { readIngestCredential } from "../src/hooks/collector-config";
+import { cloudBaseFor } from "../src/hooks/cloud-connection";
+import { deliveryHealth } from "../src/hooks/delivery-health";
+import { hasInstalledRegexPacks, readInstalledPacks } from "../src/hooks/pack-manifest";
+import { readActiveCloudManagedPolicies } from "../src/hooks/cloud-managed-policies";
+import { configuredCustomPolicyPaths, findProjectConfigDir, readMergedHooksConfig } from "../src/hooks/hooks-config";
+import { discoverPolicyFiles } from "../src/hooks/custom-hooks-loader";
+import { customPoliciesDir } from "../src/hooks/fp-home";
+import {
+  describeCloudConnection,
+  describePoliciesOn,
+  describeTracedAgents,
+  type LaunchCloudSummary,
+  type LaunchPoliciesSummary,
+} from "./launch-screen";
+
+export interface LaunchMachineFacts {
+  policies: string;
+  agents: string;
+  cloud: string;
+  notEnforcing: boolean;
+}
+
+export function gatherLaunchFacts(cwd: string): LaunchMachineFacts {
+  const row = (read: () => string): string => {
+    try {
+      return read();
+    } catch {
+      return "could not be read";
+    }
+  };
+  let notEnforcing = false;
+  try {
+    notEnforcing = notEnforcingReason(cwd) !== null;
+  } catch {
+    // Unknown is not a warning: `failproofai policies` is the full answer.
+  }
+  return {
+    policies: row(() => describePoliciesOn(readLaunchPolicies(cwd))),
+    agents: row(() => describeTracedAgents(readTracedAgentNames(cwd))),
+    cloud: row(() => describeCloudConnection(readLaunchCloud())),
+    notEnforcing,
+  };
+}
+
+/**
+ * Policies switched on, from the same inputs `notEnforcingReason` reads, so the
+ * row and the warning under it cannot disagree: installed packs (minus the
+ * per-version switches the dashboard used to write), the cloud deployment, the
+ * legacy built-ins on a machine still on the pre-pack shim, and whether custom
+ * policy files exist. Their contents are never imported to count them.
+ */
+export function readLaunchPolicies(cwd: string): LaunchPoliciesSummary {
+  const config = readMergedHooksConfig(cwd);
+  const disabled = new Set(config.disabledCustomPolicies ?? []);
+  const sources: LaunchPoliciesSummary["sources"] = [];
+  try {
+    for (const pack of readInstalledPacks().packs) {
+      const taken = pack.enabled ?? pack.policies.map((policy) => policy.name);
+      const on = taken.filter((name) => !disabled.has(`pack:${pack.id}@${pack.version}:${name}`)).length;
+      if (on > 0) sources.push({ label: `${pack.id}@${pack.version}`, count: on, pack: true });
+    }
+  } catch {
+    // An unreadable manifest is reported by `failproofai policies`.
+  }
+  try {
+    const managed = readActiveCloudManagedPolicies();
+    if (managed.length > 0) sources.push({ label: "FailproofAI Cloud", count: managed.length, pack: false });
+  } catch {
+    // No deployment, or an unreadable one: nothing is on from there.
+  }
+  if (config.enabledPolicies.length > 0 && !hasInstalledRegexPacks()) {
+    sources.push({ label: "built-in policies", count: config.enabledPolicies.length, pack: false });
+  }
+  const projectDir = resolveLaunchPath(findProjectConfigDir(cwd), ".failproofai", "policies");
+  const customFiles =
+    configuredCustomPolicyPaths(config).length > 0 ||
+    discoverPolicyFiles(projectDir).length > 0 ||
+    discoverPolicyFiles(customPoliciesDir()).length > 0;
+  return { sources, customFiles };
+}
+
+/**
+ * The agents failproofai traces, by display name in the canonical order: the
+ * saved selection when there is one, else the agents hooked at user scope.
+ */
+export function readTracedAgentNames(cwd: string, config: FpConfig = readConfig()): string[] {
+  const ids: readonly string[] = config.agents ? config.agents.selected : integrationsInstalledAt("user", cwd);
+  return INTEGRATION_TYPES.filter((id) => ids.includes(id)).map((id) => {
+    try {
+      return getIntegration(id).displayName;
+    } catch {
+      return id;
+    }
+  });
+}
+
+/**
+ * The connection, in the precedence `config --status` uses
+ * (`connectionStatusReport`): the environment first, then either credential,
+ * and the collector's record of refused uploads over the files' claim, because
+ * a revoked key leaves both files byte-for-byte correct while nothing arrives.
+ * The daemon's state is left out: reading it runs `systemctl`.
+ */
+export function readLaunchCloud(): LaunchCloudSummary {
+  const envUrl = process.env.FAILPROOFAI_CLOUD_URL;
+  if (envUrl) return { kind: "environment", url: envUrl };
+  const creds = readCloudCredentials();
+  const ingest = readIngestCredential();
+  if (!creds && !ingest) return { kind: "none" };
+  const org = readCredentials().org;
+  const where = creds ? creds.url : cloudBaseFor(ingest!.url);
+  let host = where;
+  try {
+    host = new URL(where).host || where;
+  } catch {
+    // Not a URL: show it as written.
+  }
+  let refused: { codes: number[]; credential: boolean } | null = null;
+  if (ingest) {
+    const health = deliveryHealth();
+    if (health.rejected > 0) {
+      refused = {
+        codes: Object.keys(health.byStatus)
+          .map(Number)
+          .sort((a, b) => a - b),
+        credential: health.credentialRejected > 0,
+      };
+    }
+  }
+  return {
+    kind: "connected",
+    org: org?.name || org?.slug || org?.id || null,
+    host,
+    pulling: Boolean(creds),
+    sending: Boolean(ingest),
+    refused,
+  };
+}

package/scripts/launch-ready.ts

@@ -0,0 +1,228 @@
+/**
+ * Watches the dashboard server start, so the launch screen can say it is live.
+ *
+ * Only `start` mode can: it pipes the standalone server's output, which is
+ * where Next says it is listening. Three signals decide the start, in order of
+ * preference:
+ *
+ *  - Next's `Ready in` line on stdout (`makeNextStartupFilter`), logged from the
+ *    server's own `listening` handler.
+ *  - A TCP connect to the bind address, tried every 250ms once 5s have passed
+ *    with no ready line: a Next upgrade that rewords the line must not leave
+ *    the screen waiting for the deadline.
+ *  - The server exiting first. That is a failure to start, and the cause is in
+ *    what it wrote to stderr.
+ *
+ * Until then the server's output is held back, so the screen opens the output
+ * rather than appearing halfway down it. After 30s with no answer the screen
+ * prints anyway, marked as still starting, and Next's own banner is let through
+ * from then on, so a late start still says when it happened.
+ */
+// Aliased: in the scope-hoisted CLI bundle a bare `connect` binding would make
+// the bundler rename every local `connect` elsewhere (the setup wizard has one).
+import { connect as connectDashboardProbe } from "node:net";
+import { createInterface } from "node:readline";
+import type { EventEmitter } from "node:events";
+import { makeNextStartupFilter, makeSkewLogFilter } from "./skew-log-filter";
+
+export interface DashboardChild extends EventEmitter {
+  stdout: NodeJS.ReadableStream | null;
+  stderr: NodeJS.ReadableStream | null;
+}
+
+export interface DashboardSink {
+  write(chunk: string): unknown;
+}
+
+export type DashboardStartOutcome =
+  | { kind: "ready"; via: "ready-line" | "probe" }
+  | { kind: "timeout" }
+  | { kind: "failed"; code: number | null; portInUse: boolean; cause: string | null };
+
+export interface DashboardStartWatch {
+  child: DashboardChild;
+  stdout: DashboardSink;
+  stderr: DashboardSink;
+  /** True once something accepts a connection on the bind address and port. */
+  probe: () => Promise<boolean>;
+  /**
+   * Called once, when the start is decided. The held-back output is released
+   * right after it for a ready or a timeout, so the screen comes first, and
+   * right before it for a failure, so the ✕ line comes last.
+   */
+  onSettled: (outcome: DashboardStartOutcome) => void;
+  /** The server exited, or errored, after the start was decided. */
+  onExit: (code: number | null, error?: Error) => void;
+  probeAfterMs?: number;
+  probeEveryMs?: number;
+  timeoutMs?: number;
+  /** How long to wait after `exit` for the streams to close, in case a grandchild holds them open. */
+  exitGraceMs?: number;
+}
+
+export function watchDashboardStart(watch: DashboardStartWatch): void {
+  const probeAfterMs = watch.probeAfterMs ?? 5_000;
+  const probeEveryMs = watch.probeEveryMs ?? 250;
+  const timeoutMs = watch.timeoutMs ?? 30_000;
+  const exitGraceMs = watch.exitGraceMs ?? 500;
+  // A server that floods its output before it listens stops being held back
+  // past this many lines, and so does what is kept to find a failure's cause.
+  const holdLimit = 2_000;
+
+  let starting = true;
+  let holding = true;
+  let bannerActive = true;
+  let finished = false;
+  const held: Array<{ sink: DashboardSink; line: string; fromStderr: boolean }> = [];
+  const startupText: string[] = [];
+  const timers = new Set<ReturnType<typeof setTimeout>>();
+  const later = (fn: () => void, ms: number): void => {
+    const timer = setTimeout(() => {
+      timers.delete(timer);
+      fn();
+    }, ms);
+    timers.add(timer);
+  };
+
+  const release = (dropStderr: boolean): void => {
+    holding = false;
+    for (const entry of held.splice(0)) {
+      if (!(dropStderr && entry.fromStderr)) entry.sink.write(`${entry.line}\n`);
+    }
+  };
+
+  const decide = (outcome: DashboardStartOutcome): void => {
+    if (!starting) return;
+    starting = false;
+    for (const timer of timers) clearTimeout(timer);
+    timers.clear();
+    if (outcome.kind === "failed") {
+      // Next's own dump for a port in use is a stack trace that says what the
+      // ✕ line already says; anything else is the evidence, and stays.
+      release(outcome.portInUse);
+      watch.onSettled(outcome);
+      return;
+    }
+    if (outcome.kind === "timeout") bannerActive = false;
+    try {
+      watch.onSettled(outcome);
+    } finally {
+      release(false);
+    }
+  };
+
+  const pipe = (src: NodeJS.ReadableStream | null, sink: DashboardSink, fromStderr: boolean): void => {
+    if (!src) return;
+    // One of each per stream: both filters are stateful.
+    const skew = makeSkewLogFilter();
+    const banner = fromStderr ? null : makeNextStartupFilter(() => decide({ kind: "ready", via: "ready-line" }));
+    createInterface({ input: src, crlfDelay: Infinity }).on("line", (raw) => {
+      let line = skew(raw);
+      if (line !== null && banner && bannerActive) line = banner(line);
+      if (line === null) return;
+      if (starting && startupText.length < holdLimit) startupText.push(line);
+      if (holding && held.length >= holdLimit) release(false);
+      if (holding) held.push({ sink, line, fromStderr });
+      else sink.write(`${line}\n`);
+    });
+  };
+  pipe(watch.child.stdout, watch.stdout, false);
+  pipe(watch.child.stderr, watch.stderr, true);
+
+  const probeOnce = (): void => {
+    if (!starting) return;
+    const next = (): void => {
+      if (starting) later(probeOnce, probeEveryMs);
+    };
+    let attempt: Promise<boolean>;
+    try {
+      attempt = watch.probe();
+    } catch {
+      next();
+      return;
+    }
+    attempt.then((up) => {
+      if (!starting) return;
+      if (up) decide({ kind: "ready", via: "probe" });
+      else next();
+    }, next);
+  };
+  later(probeOnce, probeAfterMs);
+  later(() => decide({ kind: "timeout" }), timeoutMs);
+
+  // `close` comes after the streams have ended, so the last lines (where the
+  // cause is) have been read. `exit` alone can arrive first; the grace timer
+  // covers a grandchild that keeps a stream open and so delays `close`.
+  let grace: ReturnType<typeof setTimeout> | undefined;
+  const finish = (code: number | null, error?: Error): void => {
+    if (finished) return;
+    finished = true;
+    if (grace) clearTimeout(grace);
+    if (!starting) {
+      watch.onExit(code, error);
+      return;
+    }
+    const portInUse = !error && startupText.some((line) => line.includes("EADDRINUSE"));
+    decide({
+      kind: "failed",
+      code,
+      portInUse,
+      cause: error ? error.message : portInUse ? null : dashboardStartupCause(startupText),
+    });
+  };
+  watch.child.on("exit", (code: number | null) => {
+    if (grace === undefined) grace = setTimeout(() => finish(code), exitGraceMs);
+  });
+  watch.child.on("close", (code: number | null) => finish(code));
+  watch.child.on("error", (error: Error) => finish(null, error));
+}
+
+/**
+ * The line that says why the server stopped: the first `Error:` line (Node
+ * prints the message first), else Next's first `⨯` line. A plain `Error: `
+ * prefix is dropped as noise; a named one (`TypeError: …`) is kept.
+ */
+export function dashboardStartupCause(lines: readonly string[]): string | null {
+  const plain = lines.map((line) => line.replace(/\x1B\[[0-9;]*m/g, "").trim());
+  for (const line of plain) {
+    const match = /(?:^|[\s[])((?:[A-Z][A-Za-z]*)?Error): (.+)$/.exec(line);
+    if (match) return match[1] === "Error" ? match[2].trim() : `${match[1]}: ${match[2].trim()}`;
+  }
+  for (const line of plain) {
+    if (line.startsWith("⨯ ")) return line.slice(2).trim();
+  }
+  return null;
+}
+
+/** Where to probe for a bind address: a wildcard bind answers on loopback. */
+export function dashboardProbeHost(bindHost: string): string {
+  const raw = bindHost.trim();
+  if (raw === "" || raw === "0.0.0.0") return "127.0.0.1";
+  if (raw === "::" || raw === "[::]" || raw === "0:0:0:0:0:0:0:0") return "::1";
+  return raw.startsWith("[") && raw.endsWith("]") ? raw.slice(1, -1) : raw;
+}
+
+/** One TCP connect: true when something accepts it within `timeoutMs`. */
+export function probeDashboardPort(host: string, port: number, timeoutMs = 1_000): Promise<boolean> {
+  return new Promise((settle) => {
+    let socket: ReturnType<typeof connectDashboardProbe>;
+    try {
+      socket = connectDashboardProbe({ host, port });
+    } catch {
+      // A port that is not a port (`--port abc`) throws here; the server has
+      // already failed on it, and its exit says why.
+      settle(false);
+      return;
+    }
+    let answered = false;
+    const answer = (up: boolean): void => {
+      if (answered) return;
+      answered = true;
+      socket.destroy();
+      settle(up);
+    };
+    socket.setTimeout(timeoutMs, () => answer(false));
+    socket.once("connect", () => answer(true));
+    socket.once("error", () => answer(false));
+  });
+}

package/scripts/launch-screen.ts

@@ -0,0 +1,202 @@
+/**
+ * The screen bare `failproofai` prints when the local dashboard is up: the
+ * logomark, the wordmark header, a DASHBOARD block, at most one attention line,
+ * LINKS and the key hint. The design target is `reference/screens.js` → `launch`
+ * in the TUI redesign handoff.
+ *
+ * Pure on purpose: facts in, lines out. Reading the machine is
+ * `launch-facts.ts`, and noticing that the server is listening is
+ * `launch-ready.ts`, so every state of this screen is asserted without starting
+ * a server.
+ *
+ * Every top-level name here is long and specific. The CLI ships as one
+ * scope-hoisted bundle, and a short name that matches a local inside a builtin
+ * policy or an audit detector makes the bundler rename that local, which
+ * changes the audit cache key and rescans every user's history (see
+ * `screenKit` in `src/hooks/tui.ts`).
+ */
+import { screenKit } from "../src/hooks/tui";
+
+/** The links the screen ends on. `https://` stays: GNOME/VTE and others only
+ *  make a link clickable when it carries a scheme. The docs root is the live
+ *  docs' home page (`docs/index.mdx`); the `/introduction` page #461 pointed at
+ *  was removed when the docs site was rebuilt (#699) and has no redirect. */
+export const LAUNCH_SCREEN_LINKS: ReadonlyArray<readonly [string, string]> = [
+  ["docs", "https://docs.befailproof.ai"],
+  ["discord", "https://discord.befailproof.ai/"],
+  ["github", "https://github.com/failproofai/failproofai"],
+  ["reddit", "https://www.reddit.com/r/failproofai/"],
+];
+
+export interface LaunchScreenFacts {
+  /** The address to open, from the bind address and port (`dashboardBrowseUrl`). */
+  url: string;
+  /** The server is listening. False when it was still starting at the deadline, or in dev mode. */
+  live: boolean;
+  /** The `policies` value (`describePoliciesOn`). */
+  policies: string;
+  /** The `agents` value (`describeTracedAgents`). */
+  agents: string;
+  /** The `cloud` value (`describeCloudConnection`). */
+  cloud: string;
+  /** Set when the bind address is reachable from other machines. Outranks every other warning. */
+  exposed?: { host: string; fix: string };
+  /** `notEnforcingReason()` answered with a cause. */
+  notEnforcing: boolean;
+}
+
+export interface LaunchScreenOpts {
+  color: boolean;
+  cols?: number;
+  /** Draw the logomark. The caller decides: a terminal only, and not after the setup wizard drew one. */
+  logo: boolean;
+  version?: string;
+}
+
+export function launchScreenLines(facts: LaunchScreenFacts, opts: LaunchScreenOpts): string[] {
+  const k = screenKit({ color: opts.color, cols: opts.cols, version: opts.version });
+  const art = opts.logo ? k.logo() : [];
+  // One attention line at most. The exposed bind is a security warning and
+  // outranks the state one; the fix sits on its own line because the sentence
+  // carries all three consequences and is too long to share one.
+  const attention = facts.exposed
+    ? [k.caution(exposedBindWarning(facts.exposed.host)), `  ${k.cmd(facts.exposed.fix)}`]
+    : facts.notEnforcing
+      ? [k.caution("Policies are not enforcing yet.", "failproofai config")]
+      : [];
+  return [
+    "",
+    ...(art.length > 0 ? [...art, ""] : []),
+    k.header("End-to-end failure layer for AI agents"),
+    "",
+    k.head("Dashboard"),
+    ...k.kv([
+      ["url", `${k.cmd(facts.url)}  ${facts.live ? `${k.on} live` : `${k.off} starting`}`],
+      ["policies", facts.policies],
+      ["agents", facts.agents],
+      ["cloud", facts.cloud],
+    ]),
+    ...(attention.length > 0 ? ["", ...attention] : []),
+    "",
+    k.head("Links"),
+    ...k.kv(LAUNCH_SCREEN_LINKS.map(([label, href]): [string, string] => [label, href])),
+    "",
+    k.keys(["ctrl+c stop the dashboard"]),
+    "",
+  ];
+}
+
+/**
+ * The address a browser can open for a bind address. Brackets an IPv6 literal,
+ * and turns a wildcard bind into this machine's loopback, which it also serves:
+ * `0.0.0.0` is not an address anyone can browse to.
+ */
+export function dashboardBrowseUrl(bindHost: string, port: string | number): string {
+  const raw = bindHost.trim();
+  const host =
+    raw === "" || raw === "0.0.0.0"
+      ? "127.0.0.1"
+      : raw === "::" || raw === "[::]" || raw === "0:0:0:0:0:0:0:0"
+        ? "[::1]"
+        : raw.includes(":") && !raw.startsWith("[")
+          ? `[${raw}]`
+          : raw;
+  return `http://${host}:${port}`;
+}
+
+/** The security warning for a bind other machines can reach. All three consequences stay. */
+export function exposedBindWarning(bindHost: string): string {
+  return (
+    `The dashboard is bound to ${bindHost}, which is reachable from outside this machine, and has no ` +
+    "authentication: anyone who can reach it can read your session transcripts, disable your policies " +
+    "and uninstall failproofai's hooks."
+  );
+}
+
+/** Policies switched on, per source that has any, and whether custom policy files exist. */
+export interface LaunchPoliciesSummary {
+  /** A pack (`id@version`), the cloud deployment, or the legacy built-ins. */
+  sources: Array<{ label: string; count: number; pack: boolean }>;
+  /** Configured or convention policy files exist. Never imported to count what they hold. */
+  customFiles: boolean;
+}
+
+export function describePoliciesOn(summary: LaunchPoliciesSummary): string {
+  const total = summary.sources.reduce((n, source) => n + source.count, 0);
+  if (total === 0) return summary.customFiles ? "custom policy files only" : "none on";
+  const from =
+    summary.sources.length === 1
+      ? summary.sources[0].label
+      : `${summary.sources.length} ${summary.sources.every((source) => source.pack) ? "packs" : "sources"}`;
+  return `${total} on from ${from}${summary.customFiles ? ", plus custom policy files" : ""}`;
+}
+
+/**
+ * `9 traced: Claude Code, OpenAI Codex, GitHub Copilot, Cursor Agent and 5 more`.
+ * Four names and a count past five; five or fewer are all named, because
+ * "and 1 more" hides a name it had room for.
+ */
+export function describeTracedAgents(names: readonly string[]): string {
+  if (names.length === 0) return "none traced";
+  const shown = names.length <= 5 ? names : names.slice(0, 4);
+  const rest = names.length - shown.length;
+  const list =
+    rest > 0
+      ? `${shown.join(", ")} and ${rest} more`
+      : shown.length === 1
+        ? shown[0]
+        : `${shown.slice(0, -1).join(", ")} and ${shown[shown.length - 1]}`;
+  return `${names.length} traced: ${list}`;
+}
+
+/** The connection, in the precedence `config --status` uses. */
+export type LaunchCloudSummary =
+  | { kind: "environment"; url: string }
+  | { kind: "none" }
+  | {
+      kind: "connected";
+      /** The org recorded at connect time, or null when the server did not name one. */
+      org: string | null;
+      host: string;
+      /** A policy credential: managed policies are pulled. */
+      pulling: boolean;
+      /** An ingest credential: hook activity is sent. */
+      sending: boolean;
+      /** The server definitively refused uploads, by status code. Overrides everything else. */
+      refused: { codes: number[]; credential: boolean } | null;
+    };
+
+export function describeCloudConnection(summary: LaunchCloudSummary): string {
+  if (summary.kind === "environment") return `Configured by environment (${summary.url})`;
+  if (summary.kind === "none") return "Not connected";
+  const lead = summary.org ? `Connected as ${summary.org}` : `Connected to ${summary.host}`;
+  if (summary.refused) {
+    const what = summary.refused.credential ? "its key is" : "its uploads are";
+    return `${lead}, but ${what} refused (${summary.refused.codes.join("/")})`;
+  }
+  if (!summary.sending) return `${lead}, not sending activity`;
+  if (!summary.pulling) return `${lead}, reporting only`;
+  return lead;
+}
+
+/** Why the dashboard did not start, as the ✕ block launch prints before exiting. */
+export function launchFailureLines(
+  failure: { portInUse: boolean; cause: string | null; code: number | null },
+  opts: { port: string; portFromFlag: boolean; color: boolean },
+): string[] {
+  const k = screenKit({ color: opts.color });
+  if (failure.portInUse) {
+    // The shipped CLI always serves on 8020 (the bin refuses --port), so the
+    // way out is to free the port. Only the contributor scripts take --port.
+    const fix = opts.portFromFlag
+      ? `Pass a different ${k.cmd("--port")}, or stop whatever is using ${opts.port}.`
+      : `Stop whatever is using it, often another failproofai dashboard, then run ${k.cmd("failproofai")} again.`;
+    return ["", k.fail(`Port ${opts.port} is already in use, so the dashboard did not start.`), `  ${fix}`, ""];
+  }
+  const text = failure.cause
+    ? `The dashboard did not start: ${failure.cause}`
+    : failure.code === null
+      ? "The dashboard stopped before it was ready."
+      : `The dashboard stopped before it was ready (exit code ${failure.code}).`;
+  return ["", k.fail(text), ""];
+}