@davstack/tui 0.2.0

package/README.md

@@ -0,0 +1,66 @@
+# @davstack/tui
+
+Long-running terminal UI that spawns, owns, and surfaces the davstack
+daemons (`logs-server`, `vitest-server`, `playwright-server`). One process
+to launch on `cd`, one quit to stop everything cleanly.
+
+## Install / run
+
+From inside a davstack-shaped repo (one with `.davstack/config/*.config.ts`):
+
+```sh
+pnpm dlx @davstack/tui start
+```
+
+The TUI auto-discovers which daemons are enabled by scanning
+`.davstack/config/<tool>.config.ts` at the repo root, spawns each one,
+streams its output into a ring buffer, and shows live status pills.
+
+Flags:
+
+- `--no-color` — disable ANSI colors (also honours `NO_COLOR` env).
+
+## Checking daemon health
+
+`davstack check` probes every configured daemon and exits 0 if all are
+running, 1 if any are missing, 2 if no davstack configs exist. Cheap
+enough to run at the start of any agent workflow.
+
+## Keybindings
+
+| Key      | Where      | What                                             |
+|----------|------------|--------------------------------------------------|
+| `1`-`9`  | any view   | jump to that daemon's log view                   |
+| `↑` / `↓`| list view  | move focus between rows                          |
+| `enter`  | list view  | drill into the focused daemon's log view         |
+| `s`      | list view  | start/stop the focused daemon                    |
+| `esc`    | log view   | back to the daemon list                          |
+| `c`      | log view   | clear the current daemon's ring buffer           |
+| `q`      | any view   | quit (confirms first if any daemon is running)   |
+| `ctrl-c` | any view   | same as `q`                                      |
+
+When `q` triggers confirm-on-quit, only `y` / `n` / `esc` are active.
+
+## Daemons
+
+| Daemon              | Default port | Purpose                                                 |
+|---------------------|--------------|---------------------------------------------------------|
+| `logs-server`       | `7077`       | Local log sink — Sentry-shaped store + `diag` queries.  |
+| `vitest-server`     | `5179`       | Warm vitest daemon for fast unit/storybook reruns.      |
+| `playwright-server` | `5180`       | Warm Playwright daemon for fast spec reruns.            |
+
+Each is independently enabled by dropping its config under
+`.davstack/config/`. Daemons that aren't configured are skipped — the TUI
+only shows what you've opted into.
+
+## Troubleshooting
+
+- **Port already in use**: a daemon's row shows `blocked :PORT` instead of
+  starting. Kill whatever else is on that port, then press `s` on the row.
+- **Windows orphan handling**: shutdown uses HTTP `/shutdown` then SIGTERM,
+  finally SIGKILL via `taskkill /F /T` so bun grandchildren can't orphan.
+- **Requires Node 24+**: the launcher runs `tsx` under your installed
+  Node. Older Node versions are unsupported.
+
+See the monorepo root [README](../../README.md) for the broader davstack
+toolkit.

package/bin/davstack.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+// davstack TUI launcher. Default to tsx (handles TS under node_modules,
+// which Node 24's --experimental-transform-types refuses). Opt into bun
+// with DAVSTACK_TUI_RUNTIME=bun, or plain Node with =node (the latter
+// only works when src is NOT under node_modules).
+import { spawn } from 'node:child_process'
+import { createRequire } from 'node:module'
+import { fileURLToPath } from 'node:url'
+import path from 'node:path'
+
+const here = path.dirname(fileURLToPath(import.meta.url))
+const entry = path.join(here, '..', 'src', 'cli.ts')
+const runtime = process.env.DAVSTACK_TUI_RUNTIME ?? 'tsx'
+
+let cmd, args
+if (runtime === 'tsx') {
+  const require = createRequire(import.meta.url)
+  const tsxCli = require.resolve('tsx/cli')
+  cmd = process.execPath
+  args = [tsxCli, entry, ...process.argv.slice(2)]
+} else if (runtime === 'bun') {
+  cmd = 'bun'
+  args = [entry, ...process.argv.slice(2)]
+} else if (runtime === 'node') {
+  cmd = process.execPath
+  args = ['--experimental-transform-types', entry, ...process.argv.slice(2)]
+} else {
+  console.error(`davstack: unknown DAVSTACK_TUI_RUNTIME='${runtime}' (expected 'tsx', 'bun', or 'node')`)
+  process.exit(2)
+}
+
+const needsShell = process.platform === 'win32' && runtime === 'bun'
+const child = spawn(cmd, args, { stdio: 'inherit', shell: needsShell })
+child.on('error', (err) => {
+  if (err.code === 'ENOENT' && runtime === 'bun') {
+    console.error("davstack: bun not found on PATH. Install bun (https://bun.sh) or unset DAVSTACK_TUI_RUNTIME.")
+  } else {
+    console.error('davstack: launcher error:', err)
+  }
+  process.exit(1)
+})
+child.on('exit', (code, signal) => {
+  if (signal) process.kill(process.pid, signal)
+  else process.exit(code ?? 0)
+})

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@davstack/tui",
+  "version": "0.2.0",
+  "license": "MIT",
+  "type": "module",
+  "description": "Long-running terminal UI that spawns, owns, and surfaces the davstack daemons (vitest-server, playwright-server, logs-server).",
+  "bin": {
+    "davstack": "./bin/davstack.mjs"
+  },
+  "files": [
+    "bin/**",
+    "src/**"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "ink": "^5.0.1",
+    "react": "^18.3.1",
+    "tsx": "^4.19.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.3",
+    "ink-testing-library": "^4.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "pnpm -w exec vitest run --project tui"
+  }
+}

package/src/App.test.tsx

@@ -0,0 +1,92 @@
+// Shell-level smoke tests for the App composition. Navigation hotkey
+// behaviour is covered as a unit in `hooks/useHotkeys.test.tsx` — those
+// tests render the providers without App and drive the dispatcher
+// directly, sidestepping ink's raw-mode plumbing which
+// ink-testing-library doesn't simulate.
+
+import React from "react"
+import { EventEmitter } from "node:events"
+import { PassThrough } from "node:stream"
+import { test, expect, afterEach } from "vitest"
+import { render } from "ink-testing-library"
+
+import { App } from "./App.tsx"
+import type { DaemonDescriptor, DaemonKey } from "./lib/daemon-registry.ts"
+
+function makeFakeDescriptor(key: DaemonKey, label: string, port: number): DaemonDescriptor {
+  return {
+    key,
+    label,
+    port,
+    readyRegex: /listening on http:\/\//i,
+    spawn: () => {
+      const ee = new EventEmitter() as EventEmitter & {
+        stdout: PassThrough
+        stderr: PassThrough
+        kill: () => boolean
+      }
+      ee.stdout = new PassThrough()
+      ee.stderr = new PassThrough()
+      ee.kill = () => true
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      return ee as any
+    },
+  }
+}
+
+let active: ReturnType<typeof render> | null = null
+
+afterEach(() => {
+  active?.unmount()
+  active = null
+})
+
+test("renders title, list view with logs row, and a status bar pill", () => {
+  active = render(
+    <App
+      registry={[makeFakeDescriptor("logs", "logs", 7077)]}
+      autoStart={false}
+      skipConfigDiscovery
+    />,
+  )
+  const frame = active.lastFrame() ?? ""
+
+  expect(frame).toContain("davstack")
+  expect(frame).toContain("Daemons")
+  expect(frame).toContain("logs")
+  // Idle glyph appears for both the row and the bottom pill (○).
+  expect(frame).toMatch(/○/)
+})
+
+test("renders the empty state with version + init command when no daemons configured", () => {
+  active = render(<App registry={[]} autoStart={false} skipConfigDiscovery />)
+  const frame = active.lastFrame() ?? ""
+
+  expect(frame).toContain("davstack TUI v")
+  expect(frame).toContain("No davstack configs found")
+  expect(frame).toContain("pnpm dlx @davstack/init")
+  expect(frame).toContain("Press q to quit")
+})
+
+test("renders three daemon rows + three status pills when all configured", () => {
+  active = render(
+    <App
+      registry={[
+        makeFakeDescriptor("logs", "logs", 7077),
+        makeFakeDescriptor("vitest", "vitest", 5179),
+        makeFakeDescriptor("playwright", "playwright", 5180),
+      ]}
+      autoStart={false}
+      skipConfigDiscovery
+    />,
+  )
+  const frame = active.lastFrame() ?? ""
+
+  expect(frame).toContain("logs")
+  expect(frame).toContain("vitest")
+  expect(frame).toContain("playwright")
+  // Status pills are numbered 1/2/3 in the bottom bar.
+  expect(frame).toMatch(/1.*logs/)
+  expect(frame).toMatch(/2.*vitest/)
+  expect(frame).toMatch(/3.*playwright/)
+})

package/src/App.tsx

@@ -0,0 +1,103 @@
+// Composition root for `davstack start`. Wires up providers, supervisors
+// and view components — keeps no logic of its own beyond glue.
+
+import React, { useEffect } from "react"
+import { Box, Text } from "ink"
+
+import { daemonRegistry, type DaemonDescriptor } from "./lib/daemon-registry.ts"
+import { installGlobalTeardown } from "./lib/global-teardown.ts"
+
+import { ViewProvider } from "./state/view-context.tsx"
+import { DaemonsProvider } from "./state/daemons-context.tsx"
+import { QuitProvider, useQuit } from "./state/quit-context.tsx"
+
+import { DaemonSupervisor } from "./components/DaemonSupervisor.tsx"
+import { DescriptorSync } from "./components/DescriptorSync.tsx"
+import { GlobalHotkeys } from "./components/GlobalHotkeys.tsx"
+import { QuitController } from "./components/QuitController.tsx"
+import { MainView } from "./components/MainView.tsx"
+import { BottomBar } from "./components/BottomBar.tsx"
+import { QuitConfirm } from "./components/QuitConfirm.tsx"
+
+import { useConfigDiscovery } from "./hooks/useConfigDiscovery.ts"
+
+interface AppProps {
+  registry?: DaemonDescriptor[]
+  // When false, daemons are NOT auto-started on mount. Tests use this.
+  autoStart?: boolean
+  // When true, skip the .davstack/config discovery filter. Tests pass a
+  // pre-filtered registry directly.
+  skipConfigDiscovery?: boolean
+}
+
+export function App({
+  registry = daemonRegistry,
+  autoStart = true,
+  skipConfigDiscovery = false,
+}: AppProps): React.ReactElement {
+  // Install the process-level emergency teardown once. Idempotent.
+  useEffect(() => {
+    installGlobalTeardown()
+  }, [])
+
+  const { done, filtered } = useConfigDiscovery(registry, skipConfigDiscovery)
+
+  return (
+    <ViewProvider>
+      <DaemonsProvider descriptors={filtered}>
+        <QuitProvider>
+          <DescriptorSync descriptors={filtered} />
+          {filtered.map((d) => (
+            <DaemonSupervisor key={d.key} descriptor={d} autoStart={autoStart} />
+          ))}
+          <QuitController>
+            {({ quit, quitting }) => (
+              <AppFrame
+                quit={quit}
+                quitting={quitting}
+                done={done}
+                hasAnyDaemon={filtered.length > 0}
+              />
+            )}
+          </QuitController>
+        </QuitProvider>
+      </DaemonsProvider>
+    </ViewProvider>
+  )
+}
+
+// Inner frame — pulled out so it can `useQuit()` (which requires being
+// inside QuitProvider). Renders the confirm overlay when active.
+function AppFrame({
+  quit,
+  quitting,
+  done,
+  hasAnyDaemon,
+}: {
+  quit: () => void
+  quitting: boolean
+  done: boolean
+  hasAnyDaemon: boolean
+}): React.ReactElement {
+  const { confirming } = useQuit()
+  return (
+    <Box flexDirection="column">
+      <GlobalHotkeys onQuit={quit} />
+      <Box>
+        <Text bold>davstack</Text>
+      </Box>
+      <Box marginTop={1} flexDirection="column">
+        <MainView discoveryDone={done} hasAnyDaemon={hasAnyDaemon} />
+      </Box>
+      <Box marginTop={1}>
+        <BottomBar />
+      </Box>
+      {confirming ? <QuitConfirm /> : null}
+      {quitting ? (
+        <Box marginTop={1}>
+          <Text dimColor>shutting down daemons…</Text>
+        </Box>
+      ) : null}
+    </Box>
+  )
+}

package/src/cli.ts

@@ -0,0 +1,62 @@
+// @davstack/tui — subcommand dispatcher.
+//
+// Ships `davstack start` (Ink shell) and `davstack check` (one-shot
+// daemon probe + start hint). Other subcommands (stop/status/logs) are
+// reserved.
+
+import { Command } from "commander"
+import React from "react"
+import { render } from "ink"
+
+import { App } from "./App.tsx"
+import { runCheck, formatResult, exitCodeFor } from "./commands/check.ts"
+
+function runStart(opts: { noColor?: boolean }): void {
+  if (opts.noColor) process.env.DAVSTACK_NO_COLOR = "1"
+  // Wipe stale shell scrollback so the Ink UI takes over a clean screen.
+  // Sequence: ED(2) clears viewport, ED(3) clears scrollback (xterm/WT),
+  // CUP homes the cursor.
+  process.stdout.write("\x1b[2J\x1b[3J\x1b[H")
+  render(React.createElement(App))
+}
+
+const program = new Command()
+
+program
+  .name("davstack")
+  .description("Long-running TUI that owns the davstack daemons.")
+  .showHelpAfterError()
+  .exitOverride()
+
+program
+  .command("start")
+  .description("Launch the TUI.")
+  .option("--no-color", "Disable ANSI colors (also respects NO_COLOR env)")
+  .action((opts: { color?: boolean }) => {
+    // commander maps `--no-color` to opts.color === false.
+    runStart({ noColor: opts.color === false })
+  })
+
+program
+  .command("check")
+  .description("Probe configured daemons; reports running status + start hint if missing.")
+  .option("--no-color", "Disable ANSI colors (also respects NO_COLOR env)")
+  .action(async (opts: { color?: boolean }) => {
+    const result = await runCheck()
+    const useColor =
+      opts.color !== false && !process.env.NO_COLOR && !process.env.DAVSTACK_NO_COLOR
+    process.stdout.write(formatResult(result, useColor) + "\n")
+    process.exit(exitCodeFor(result))
+  })
+
+try {
+  program.parse(process.argv)
+} catch (err) {
+  const exitErr = err as { code?: string; exitCode?: number }
+  if (exitErr.code === "commander.helpDisplayed" || exitErr.code === "commander.help") {
+    process.exit(0)
+  }
+  // commander already prints help-after-error for unknown commands/options
+  // (via showHelpAfterError above), so we just propagate the exit code.
+  process.exit(exitErr.exitCode ?? 1)
+}

package/src/commands/check.test.ts

@@ -0,0 +1,160 @@
+// Unit tests for `davstack check`. Pure: no real network, no real daemons.
+// Uses fake DaemonDescriptors + a spy `probe` so we can assert which
+// ports got hit and what the formatter does with the result.
+
+import fs from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest"
+
+import { runCheck, formatResult, exitCodeFor } from "./check.ts"
+import type { DaemonDescriptor, DaemonKey } from "../lib/daemon-registry.ts"
+
+function fakeDescriptor(key: DaemonKey, label: string, port: number): DaemonDescriptor {
+  return {
+    key,
+    label,
+    port,
+    host: "127.0.0.1",
+    readyRegex: /listening on http:\/\//i,
+    spawn: () => {
+      throw new Error("check must never call spawn")
+    },
+  }
+}
+
+const FAKE_REGISTRY: DaemonDescriptor[] = [
+  fakeDescriptor("logs", "logs", 7077),
+  fakeDescriptor("vitest", "vitest", 5179),
+  fakeDescriptor("playwright", "playwright", 5180),
+]
+
+let tmpRoot = ""
+
+beforeEach(async () => {
+  tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), "davstack-tui-check-"))
+})
+
+afterEach(async () => {
+  await fs.rm(tmpRoot, { recursive: true, force: true })
+})
+
+async function writeConfig(name: string): Promise<void> {
+  const dir = path.join(tmpRoot, ".davstack", "config")
+  await fs.mkdir(dir, { recursive: true })
+  await fs.writeFile(path.join(dir, name), "export default {}\n", "utf8")
+}
+
+describe("runCheck", () => {
+  test("returns no-config when .davstack/config is missing", async () => {
+    const result = await runCheck({
+      repoRoot: tmpRoot,
+      probe: vi.fn(),
+      registry: FAKE_REGISTRY,
+    })
+    expect(result.kind).toBe("no-config")
+    if (result.kind === "no-config") {
+      expect(result.repoRoot).toBe(tmpRoot)
+    }
+  })
+
+  test("probes only configured daemons", async () => {
+    await writeConfig("logs-server.config.ts")
+    await writeConfig("vitest-server.config.ts")
+    const probe = vi.fn().mockResolvedValue(true)
+    const result = await runCheck({
+      repoRoot: tmpRoot,
+      probe,
+      registry: FAKE_REGISTRY,
+    })
+    expect(probe).toHaveBeenCalledTimes(2)
+    const probedPorts = probe.mock.calls.map((c) => c[1]).sort()
+    expect(probedPorts).toEqual([5179, 7077])
+    expect(result.kind).toBe("checked")
+  })
+
+  test("exit 1 when any daemon's probe returns false", async () => {
+    await writeConfig("logs-server.config.ts")
+    await writeConfig("vitest-server.config.ts")
+    const probe = vi.fn(async (_h: string, port: number) => port === 7077)
+    const result = await runCheck({
+      repoRoot: tmpRoot,
+      probe,
+      registry: FAKE_REGISTRY,
+    })
+    expect(exitCodeFor(result)).toBe(1)
+  })
+
+  test("exit 0 when all probes return true", async () => {
+    await writeConfig("logs-server.config.ts")
+    const probe = vi.fn().mockResolvedValue(true)
+    const result = await runCheck({
+      repoRoot: tmpRoot,
+      probe,
+      registry: FAKE_REGISTRY,
+    })
+    expect(exitCodeFor(result)).toBe(0)
+  })
+
+  test("exit 2 for no-config", async () => {
+    const result = await runCheck({
+      repoRoot: tmpRoot,
+      probe: vi.fn(),
+      registry: FAKE_REGISTRY,
+    })
+    expect(exitCodeFor(result)).toBe(2)
+  })
+})
+
+describe("formatResult", () => {
+  test("renders the no-config message with the init command", () => {
+    const out = formatResult({ kind: "no-config", repoRoot: "/repo" }, false)
+    expect(out).toContain("No davstack configs found")
+    expect(out).toContain("pnpm dlx @davstack/init")
+    expect(out).toContain("/repo")
+  })
+
+  test("all-running output omits the start hint", () => {
+    const out = formatResult(
+      {
+        kind: "checked",
+        repoRoot: "/repo",
+        rows: [
+          { descriptor: FAKE_REGISTRY[0]!, running: true },
+          { descriptor: FAKE_REGISTRY[1]!, running: true },
+        ],
+      },
+      false,
+    )
+    expect(out).toContain("All configured daemons running.")
+    expect(out).not.toContain("pnpm dlx @davstack/tui start")
+  })
+
+  test("some-missing output includes the start hint", () => {
+    const out = formatResult(
+      {
+        kind: "checked",
+        repoRoot: "/repo",
+        rows: [
+          { descriptor: FAKE_REGISTRY[0]!, running: true },
+          { descriptor: FAKE_REGISTRY[1]!, running: false },
+        ],
+      },
+      false,
+    )
+    expect(out).toContain("1 daemon(s) not running.")
+    expect(out).toContain("pnpm dlx @davstack/tui start")
+  })
+
+  test("color=true emits ANSI escapes; color=false does not", () => {
+    const rows = [
+      { descriptor: FAKE_REGISTRY[0]!, running: true },
+      { descriptor: FAKE_REGISTRY[1]!, running: false },
+    ]
+    const colored = formatResult({ kind: "checked", repoRoot: "/r", rows }, true)
+    const plain = formatResult({ kind: "checked", repoRoot: "/r", rows }, false)
+    expect(colored).toContain("\x1b[")
+    expect(plain).not.toContain("\x1b[")
+  })
+})
+

package/src/commands/check.ts

@@ -0,0 +1,112 @@
+// `davstack check` — probe every configured daemon and report status.
+//
+// Pure (no Ink, no spawning, no stdin). Designed to be safe to run in CI,
+// piped, or as a one-liner at the top of any agent workflow. The TUI's
+// `start` is the only spawner; `check` only reports.
+//
+// Exit codes:
+//   0 — all configured daemons are reachable
+//   1 — at least one configured daemon is not reachable
+//   2 — no davstack configs found in this repo
+
+import { discoverEnabledDaemons, findConfigRoot } from "../lib/config-discovery.ts"
+import {
+  daemonRegistry,
+  type DaemonDescriptor,
+  type DaemonKey,
+} from "../lib/daemon-registry.ts"
+import { probePort } from "../lib/port-probe.ts"
+import { findRepoRoot } from "../lib/repo-root.ts"
+
+const PROBE_TIMEOUT_MS = 300
+const DEFAULT_PROBE_HOST = "127.0.0.1"
+
+export type CheckRow = { descriptor: DaemonDescriptor; running: boolean }
+
+export type CheckResult =
+  | { kind: "no-config"; repoRoot: string }
+  | { kind: "checked"; repoRoot: string; rows: CheckRow[] }
+
+export type CheckDeps = {
+  repoRoot?: string
+  probe?: (host: string, port: number) => Promise<boolean>
+  registry?: DaemonDescriptor[]
+  // Test-only override of the discovery step (default reads filesystem).
+  discover?: (repoRoot: string) => Promise<Set<DaemonKey>>
+}
+
+export async function runCheck(deps: CheckDeps = {}): Promise<CheckResult> {
+  const cwd = process.cwd()
+  const repoRoot = deps.repoRoot ?? findConfigRoot(cwd) ?? findRepoRoot(cwd)
+  const discover = deps.discover ?? discoverEnabledDaemons
+  const probe = deps.probe ?? ((h, p) => probePort(h, p, PROBE_TIMEOUT_MS))
+  const registry = deps.registry ?? daemonRegistry
+
+  const enabled = await discover(repoRoot)
+  if (enabled.size === 0) return { kind: "no-config", repoRoot }
+
+  const descriptors = registry.filter((d) => enabled.has(d.key))
+  const rows = await Promise.all(
+    descriptors.map(async (descriptor) => {
+      const host = descriptor.host ?? DEFAULT_PROBE_HOST
+      const running = await probe(host, descriptor.port)
+      return { descriptor, running }
+    }),
+  )
+  return { kind: "checked", repoRoot, rows }
+}
+
+function green(s: string, useColor: boolean): string {
+  return useColor ? `\x1b[32m${s}\x1b[0m` : s
+}
+
+function red(s: string, useColor: boolean): string {
+  return useColor ? `\x1b[31m${s}\x1b[0m` : s
+}
+
+const START_HINT = [
+  "To start the missing daemons, run this in a separate terminal:",
+  "",
+  "  pnpm dlx @davstack/tui start",
+  "",
+  "The TUI supervises every configured daemon together; closing it",
+  "cleans them up. Re-run `davstack check` to confirm.",
+].join("\n")
+
+export function formatResult(result: CheckResult, useColor: boolean): string {
+  const header = `davstack check (cwd: ${result.repoRoot})`
+
+  if (result.kind === "no-config") {
+    return [header, "", "No davstack configs found. Run: pnpm dlx @davstack/init"].join("\n")
+  }
+
+  const labelWidth = Math.max(...result.rows.map((r) => r.descriptor.label.length), 1)
+  const portWidth = Math.max(...result.rows.map((r) => `:${r.descriptor.port}`.length), 1)
+
+  const lines: string[] = [header, ""]
+  let missing = 0
+  for (const row of result.rows) {
+    const marker = row.running ? green("●", useColor) : red("✗", useColor)
+    const label = row.descriptor.label.padEnd(labelWidth)
+    const port = `:${row.descriptor.port}`.padEnd(portWidth)
+    const status = row.running ? "running" : "not running"
+    lines.push(`  ${marker} ${label}  ${port}  ${status}`)
+    if (!row.running) missing += 1
+  }
+  lines.push("")
+
+  if (missing === 0) {
+    lines.push("All configured daemons running.")
+  } else {
+    lines.push(`${missing} daemon(s) not running.`)
+    lines.push("")
+    lines.push(START_HINT)
+  }
+
+  return lines.join("\n")
+}
+
+export function exitCodeFor(result: CheckResult): number {
+  if (result.kind === "no-config") return 2
+  return result.rows.every((r) => r.running) ? 0 : 1
+}