@doriandev/devcc 0.1.2 → 0.2.0

package/src/devcc/verify/verify.ts

@@ -0,0 +1,316 @@
+import { spawn } from "node:child_process"
+import { isAbsolute, resolve } from "node:path"
+import type { CommandConfigEntry } from "../core/config.js"
+import { runScriptArgs, type PackageManager } from "../utils/packageManager.js"
+
+/**
+ * Project verification: the quality gate behind `devcc verify`.
+ *
+ * Steps are resolved from config (a command id, a package.json script, or an
+ * inline command) and run sequentially. The loop is independent of how a step
+ * executes, so the CLI can spawn directly while the TUI runs the same steps
+ * through the ProcessManager and gets log capture for free.
+ */
+
+export interface VerifyStepConfig {
+  id: string
+  name?: string
+  command: string
+  args?: string[]
+  cwd?: string
+}
+
+/** A command id or package.json script name, or an inline step. */
+export type VerifyEntry = string | VerifyStepConfig
+
+export interface VerifyStep {
+  id: string
+  name: string
+  command: string
+  args: string[]
+  cwd?: string
+  source: "command" | "script" | "inline"
+}
+
+export interface ResolveVerifyContext {
+  commands: readonly CommandConfigEntry[]
+  scripts: readonly { name: string }[]
+  packageManager: PackageManager
+}
+
+export interface ResolvedVerify {
+  steps: VerifyStep[]
+  issues: string[]
+}
+
+/**
+ * Turn config entries into runnable steps. A string names a configured
+ * command first, then a package.json script, so `verify: ["lint", "test"]`
+ * works without repeating what `package.json` already says.
+ */
+export function resolveVerifySteps(
+  entries: readonly VerifyEntry[],
+  context: ResolveVerifyContext,
+): ResolvedVerify {
+  const steps: VerifyStep[] = []
+  const issues: string[] = []
+
+  for (const entry of entries) {
+    if (typeof entry !== "string") {
+      steps.push({
+        id: entry.id,
+        name: entry.name ?? entry.id,
+        command: entry.command,
+        args: entry.args ?? [],
+        cwd: entry.cwd,
+        source: "inline",
+      })
+      continue
+    }
+
+    const command = context.commands.find((candidate) => candidate.id === entry)
+    if (command) {
+      steps.push({
+        id: entry,
+        name: command.title,
+        command: command.command,
+        args: command.args ?? [],
+        cwd: command.cwd,
+        source: "command",
+      })
+      continue
+    }
+
+    if (context.scripts.some((script) => script.name === entry)) {
+      steps.push({
+        id: entry,
+        name: entry,
+        command: context.packageManager,
+        args: runScriptArgs(context.packageManager, entry),
+        source: "script",
+      })
+      continue
+    }
+
+    issues.push(`verify: "${entry}" is neither a command id nor a package.json script`)
+  }
+
+  const seen = new Set<string>()
+  for (const step of steps) {
+    if (seen.has(step.id)) issues.push(`verify: step "${step.id}" is listed more than once`)
+    seen.add(step.id)
+  }
+
+  return { steps, issues }
+}
+
+/** Config issues about `verify`, which must block a run rather than silently shrink it. */
+export function isVerifyIssue(issue: string): boolean {
+  return issue.startsWith("verify") || issue.startsWith('"verify"')
+}
+
+export type VerifyStepStatus = "pending" | "running" | "passed" | "failed" | "skipped"
+
+export interface VerifyStepResult {
+  id: string
+  name: string
+  command: string
+  args: string[]
+  status: VerifyStepStatus
+  exitCode: number | null
+  durationMs: number
+  stdout: string
+  stderr: string
+  /** Why the step could not run or was stopped (spawn error, signal, cancellation). */
+  error?: string
+}
+
+export interface VerifyReport {
+  ok: boolean
+  passed: number
+  failed: number
+  skipped: number
+  total: number
+  durationMs: number
+  steps: VerifyStepResult[]
+}
+
+export interface StepOutcome {
+  exitCode: number | null
+  stdout?: string
+  stderr?: string
+  error?: string
+}
+
+export type StepExecutor = (step: VerifyStep, signal: AbortSignal) => Promise<StepOutcome>
+
+export interface RunVerificationOptions {
+  /** Called whenever a step changes state, with the full current list. */
+  onProgress?: (steps: readonly VerifyStepResult[]) => void
+  signal?: AbortSignal
+}
+
+/**
+ * Run every step in order. A failing step does not stop the run: the report
+ * shows every failure at once. Cancelling marks the remaining steps skipped.
+ */
+export async function runVerification(
+  steps: readonly VerifyStep[],
+  execute: StepExecutor,
+  options: RunVerificationOptions = {},
+): Promise<VerifyReport> {
+  const startedAt = Date.now()
+  const signal = options.signal ?? new AbortController().signal
+  const results: VerifyStepResult[] = steps.map((step) => ({
+    id: step.id,
+    name: step.name,
+    command: step.command,
+    args: step.args,
+    status: "pending",
+    exitCode: null,
+    durationMs: 0,
+    stdout: "",
+    stderr: "",
+  }))
+  const progress = () => options.onProgress?.(results.map((result) => ({ ...result })))
+
+  for (const [index, step] of steps.entries()) {
+    const result = results[index] as VerifyStepResult
+    if (signal.aborted) {
+      result.status = "skipped"
+      result.error = "cancelled"
+      continue
+    }
+
+    result.status = "running"
+    progress()
+    const stepStart = Date.now()
+    let outcome: StepOutcome
+    try {
+      outcome = await execute(step, signal)
+    } catch (error) {
+      outcome = { exitCode: null, error: error instanceof Error ? error.message : String(error) }
+    }
+
+    result.durationMs = Date.now() - stepStart
+    result.exitCode = outcome.exitCode
+    result.stdout = outcome.stdout ?? ""
+    result.stderr = outcome.stderr ?? ""
+    if (outcome.error) result.error = outcome.error
+    result.status = outcome.exitCode === 0 && !outcome.error ? "passed" : "failed"
+    progress()
+  }
+  if (signal.aborted) progress()
+
+  const passed = results.filter((result) => result.status === "passed").length
+  const failed = results.filter((result) => result.status === "failed").length
+  const skipped = results.filter((result) => result.status === "skipped").length
+  return {
+    ok: failed === 0 && skipped === 0 && results.length > 0,
+    passed,
+    failed,
+    skipped,
+    total: results.length,
+    durationMs: Date.now() - startedAt,
+    steps: results,
+  }
+}
+
+/** One-line summary: `5/5 passed` or `3/5 passed, 2 failed (lint, test)`. */
+export function summariseVerify(
+  report: Pick<VerifyReport, "passed" | "failed" | "skipped" | "total" | "steps">,
+): string {
+  const parts = [`${report.passed}/${report.total} passed`]
+  if (report.failed > 0) {
+    const names = report.steps.filter((step) => step.status === "failed").map((step) => step.name)
+    parts.push(`${report.failed} failed (${names.join(", ")})`)
+  }
+  if (report.skipped > 0) parts.push(`${report.skipped} skipped`)
+  return parts.join(", ")
+}
+
+// eslint-disable-next-line no-control-regex
+const ANSI_PATTERN = /\u001b\[[0-?]*[ -/]*[@-~]|\u001b\][^\u0007]*(?:\u0007|\u001b\\)/gu
+
+/** Remove terminal escape sequences, so JSON and logs stay plain text. */
+export function stripAnsi(text: string): string {
+  return text.replace(ANSI_PATTERN, "")
+}
+
+/** Keep the end of a long output, where test runners and compilers put the verdict. */
+export function keepTail(text: string, maxLength: number): string {
+  if (text.length <= maxLength) return text
+  return `…[${text.length - maxLength} characters truncated]\n${text.slice(-maxLength)}`
+}
+
+export interface SpawnExecutorOptions {
+  rootDir: string
+  env?: NodeJS.ProcessEnv
+  /** Characters of stdout/stderr kept per step (default 200k, from the end). */
+  maxOutput?: number
+  /** Live output, e.g. to mirror a failing step. */
+  onOutput?: (step: VerifyStep, chunk: string, stream: "stdout" | "stderr") => void
+}
+
+/**
+ * Executor for the CLI: `spawn(command, args)` in the project, colour disabled,
+ * output captured (tail kept) and ANSI-stripped. No shell, no timeout - a test
+ * suite takes as long as it takes - but an abort signal stops the child.
+ */
+export function createSpawnExecutor(options: SpawnExecutorOptions): StepExecutor {
+  const maxOutput = options.maxOutput ?? 200_000
+  return (step, signal) =>
+    new Promise<StepOutcome>((resolvePromise) => {
+      const cwd = step.cwd
+        ? isAbsolute(step.cwd)
+          ? step.cwd
+          : resolve(options.rootDir, step.cwd)
+        : options.rootDir
+      let stdout = ""
+      let stderr = ""
+      const append = (current: string, chunk: string) => {
+        const next = current + chunk
+        return next.length > maxOutput * 2 ? next.slice(-maxOutput) : next
+      }
+
+      const child = spawn(step.command, step.args, {
+        cwd,
+        env: { ...(options.env ?? process.env), FORCE_COLOR: "0", NO_COLOR: "1" },
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+      })
+
+      const onAbort = () => child.kill("SIGTERM")
+      signal.addEventListener("abort", onAbort, { once: true })
+
+      child.stdout.setEncoding("utf8")
+      child.stdout.on("data", (chunk: string) => {
+        stdout = append(stdout, chunk)
+        options.onOutput?.(step, chunk, "stdout")
+      })
+      child.stderr.setEncoding("utf8")
+      child.stderr.on("data", (chunk: string) => {
+        stderr = append(stderr, chunk)
+        options.onOutput?.(step, chunk, "stderr")
+      })
+
+      let settled = false
+      const finish = (outcome: StepOutcome) => {
+        if (settled) return
+        settled = true
+        signal.removeEventListener("abort", onAbort)
+        resolvePromise({
+          ...outcome,
+          stdout: keepTail(stripAnsi(stdout), maxOutput),
+          stderr: keepTail(stripAnsi(stderr), maxOutput),
+        })
+      }
+
+      child.once("error", (error) => finish({ exitCode: null, error: error.message }))
+      child.once("close", (code, closeSignal) => {
+        if (signal.aborted) finish({ exitCode: code, error: "cancelled" })
+        else if (closeSignal) finish({ exitCode: code, error: `terminated by ${closeSignal}` })
+        else finish({ exitCode: code })
+      })
+    })
+}

package/src/devcc/views/OverviewView.ts

@@ -4,6 +4,7 @@ import { RowList, type ListRow } from "../components/primitives.js"
 import { processGlyph, serviceGlyph } from "../components/StatusBadge.js"
 import { chunk, dim, styled } from "../components/styled.js"
 import { summariseStatus, summariseTracking } from "../git/parse.js"
+import { worktreeLabel } from "../git/worktrees.js"
 import { isActive } from "../processes/ManagedProcess.js"
 import type { AppState, ViewId } from "../core/state.js"
 import { fit, formatDuration, meter, toGigabytes } from "../utils/format.js"
@@ -51,6 +52,43 @@ export class OverviewView extends View {
         ),
       )
       rows.push(info("tracking", summariseTracking(state.git.status), labelWidth))
+      if (state.git.worktrees.length > 1) {
+        const current = state.git.worktrees.find((worktree) => worktree.isCurrent)
+        rows.push(
+          info(
+            "worktree",
+            `${current ? worktreeLabel(current) : "?"} · ${state.git.worktrees.length} worktrees (w)`,
+            labelWidth,
+          ),
+        )
+      }
+    }
+
+    // --- Verification ------------------------------------------------------
+    if (state.verify.configured > 0) {
+      rows.push(blank())
+      rows.push(section("Verify"))
+      rows.push(verifyRow(state, labelWidth))
+    }
+
+    // --- AI agents ---------------------------------------------------------
+    if (state.agents.length > 0) {
+      rows.push(blank())
+      rows.push(section("AI agents"))
+      for (const agent of state.agents.slice(0, compact ? 2 : 4)) {
+        rows.push({
+          key: `agent-${agent.id}`,
+          disabled: true,
+          content: styled(
+            "  ",
+            processGlyph(agent.status).chunks[0] ?? chunk(" "),
+            " ",
+            chunk(fit(agent.agentName, 16), theme.text),
+            dim(fit(agent.branch ?? agent.cwd, 26)),
+            dim(fit(agent.task, 40)),
+          ),
+        })
+      }
     }
 
     // --- Development processes -------------------------------------------
@@ -135,6 +173,16 @@ export class OverviewView extends View {
         rows.push(info("node", `${state.project.host.runtime}`, labelWidth))
       }
     }
+    const attention = environmentAttention(state)
+    if (attention) {
+      rows.push(
+        infoStyled(
+          "environment",
+          styled(chunk(attention, theme.warning), dim("  (8 for details)")),
+          labelWidth,
+        ),
+      )
+    }
 
     this.list.setRows(rows, -1)
   }
@@ -144,7 +192,8 @@ export class OverviewView extends View {
       { keys: "↑↓", label: "navigate" },
       { keys: "p", label: "processes" },
       { keys: "g", label: "git" },
-      { keys: "l", label: "logs" },
+      { keys: "w", label: "worktrees" },
+      { keys: "V", label: "verify" },
       { keys: "/", label: "commands" },
       { keys: "?", label: "help" },
       { keys: "q", label: "quit" },
@@ -180,6 +229,32 @@ function infoStyled(label: string, value: ReturnType<typeof styled>, labelWidth
   }
 }
 
+function verifyRow(state: AppState, labelWidth: number): ListRow {
+  const { verify } = state
+  if (verify.steps.length === 0) {
+    return info("status", `${verify.configured} step(s) configured - press V to run`, labelWidth)
+  }
+  const passed = verify.steps.filter((step) => step.status === "passed").length
+  const failed = verify.steps.filter((step) => step.status === "failed")
+  const running = verify.steps.find((step) => step.status === "running")
+  const color = verify.running ? theme.warning : verify.ok ? theme.success : theme.danger
+  const summary = verify.running
+    ? `${passed}/${verify.steps.length} passed · running ${running?.name ?? "…"}`
+    : `${passed}/${verify.steps.length} passed${failed.length > 0 ? ` · failed: ${failed.map((step) => step.name).join(", ")}` : ""}`
+  return infoStyled("status", styled(chunk(summary, color)), labelWidth)
+}
+
+/** One line when the environment needs a look, otherwise nothing. */
+function environmentAttention(state: AppState): string | null {
+  const { tools, direnv, mise } = state.environment
+  const problems = tools
+    .filter((tool) => tool.status === "error" || tool.status === "warning")
+    .map((tool) => tool.name)
+  if (mise.error) problems.push("mise")
+  if (direnv.installed && direnv.rcPath && direnv.approval !== "allowed") problems.push(".envrc not allowed")
+  return problems.length > 0 ? problems.join(", ") : null
+}
+
 function usageColor(ratio: number): string {
   if (ratio > 0.85) return theme.danger
   if (ratio > 0.6) return theme.warning

package/src/devcc/views/ServicesView.ts

@@ -5,11 +5,14 @@ import { RowList, type ListRow } from "../components/primitives.js"
 import { serviceBadge, serviceGlyph } from "../components/StatusBadge.js"
 import { chunk, dim, styled } from "../components/styled.js"
 import { setSelection, type AppState, type ViewId } from "../core/state.js"
+import { remoteServiceId } from "../services/remote.js"
 import type { ServiceSnapshot } from "../services/types.js"
 import { errorMessage } from "../utils/errors.js"
 import { fit } from "../utils/format.js"
 import { View, type ViewDeps } from "./View.js"
 
+const REMOTE_PREFIX = remoteServiceId("")
+
 interface Entry {
   kind: "service" | "item" | "heading"
   service?: ServiceSnapshot
@@ -117,6 +120,9 @@ export class ServicesView extends View {
       case "d":
         void this.composeDown(selected)
         return true
+      case "o":
+        void this.ssh(selected)
+        return true
       default:
         return false
     }
@@ -128,6 +134,7 @@ export class ServicesView extends View {
       { keys: "s", label: "start/stop" },
       { keys: "r", label: "restart" },
       { keys: "d", label: "compose down" },
+      { keys: "o", label: "ssh (remote)" },
       { keys: "/", label: "commands" },
     ]
   }
@@ -176,6 +183,16 @@ export class ServicesView extends View {
     }
   }
 
+  /** Open an SSH session to a remote machine in a terminal. */
+  private async ssh(index: number): Promise<void> {
+    const service = this.selectedService(index)
+    if (!service?.id.startsWith(REMOTE_PREFIX)) {
+      this.deps.app.notify("warn", "Select a remote machine first")
+      return
+    }
+    await this.deps.app.sshTo(service.id.slice(REMOTE_PREFIX.length))
+  }
+
   /** `docker compose down` removes containers; always confirmed. */
   private async composeDown(index: number): Promise<void> {
     const service = this.selectedService(index)

package/src/devcc/views/SystemView.ts

@@ -1,17 +1,28 @@
+import type { KeyEvent } from "@opentui/core"
 import { theme } from "../app/theme.js"
 import type { KeyHint } from "../components/Footer.js"
 import { RowList, type ListRow } from "../components/primitives.js"
 import { chunk, dim, styled } from "../components/styled.js"
 import type { AppState, ViewId } from "../core/state.js"
+import type { DirenvApproval } from "../environment/integrations.js"
+import type { ToolStatus } from "../environment/tools.js"
 import { fit, formatBytes, formatDuration, meter, toGigabytes } from "../utils/format.js"
+import { tildify } from "../utils/paths.js"
 import { View, type ViewDeps } from "./View.js"
 
-/** Host information and live resource usage. Read-only. */
+/**
+ * Environment health, live resource usage and host information.
+ *
+ * Tool, mise and direnv detection runs once in the background and on request
+ * ("Environment: refresh" in the palette); nothing here polls external tools.
+ */
 export class SystemView extends View {
   readonly id: ViewId = "system"
   readonly title = "System"
 
   private readonly list: RowList
+  /** Kept across refreshes: metrics repaint every tick and must not reset the scroll. */
+  private offset = 0
 
   constructor(deps: ViewDeps) {
     super(deps)
@@ -21,28 +32,72 @@ export class SystemView extends View {
 
   update(state: AppState): void {
     const host = state.project.host
-    const tools = state.project.tools
     const metrics = state.system
+    const environment = state.environment
     const rows: ListRow[] = []
 
-    rows.push(heading("Host"))
-    rows.push(row("hostname", host.hostname))
-    rows.push(row("os", `${host.platform} ${host.release}`))
-    rows.push(row("arch", host.arch))
-    rows.push(row("cpu", `${host.cpuModel} (${host.cpuCount} cores)`))
-    rows.push(row("memory", `${toGigabytes(host.totalMemory)} GB total`))
+    rows.push(heading("Environment"))
+    if (!environment.checkedAt) {
+      rows.push(row("", "checking tools…"))
+    } else {
+      for (const tool of environment.tools) rows.push(toolRow(tool))
+      if (environment.checking) rows.push(row("", "re-checking…"))
+    }
+
+    const { mise, direnv } = environment
+    if (mise.installed) {
+      rows.push(blank("mise"))
+      rows.push(heading("Runtimes (mise)"))
+      if (mise.error) rows.push(warningRow("mise", mise.error))
+      else if (mise.runtimes.length === 0) rows.push(row("", "no tools pinned for this project"))
+      for (const runtime of mise.runtimes) {
+        const note = [
+          runtime.requested && runtime.requested !== runtime.version
+            ? `requested ${runtime.requested}`
+            : undefined,
+          runtime.installed ? undefined : "not installed - run `mise install`",
+        ]
+          .filter(Boolean)
+          .join(" · ")
+        rows.push({
+          key: `rt-${runtime.tool}-${runtime.version}`,
+          disabled: true,
+          content: styled(
+            dim(fit(runtime.tool, LABEL_WIDTH)),
+            chunk(fit(runtime.version, 14), runtime.installed ? theme.text : theme.warning),
+            dim(note),
+          ),
+        })
+      }
+    }
+
+    if (direnv.installed || direnv.rcPath) {
+      rows.push(blank("direnv"))
+      rows.push(heading("direnv"))
+      if (direnv.error) rows.push(warningRow("status", direnv.error))
+      if (!direnv.rcPath) {
+        rows.push(row(".envrc", "none for this project"))
+      } else {
+        rows.push(row(".envrc", tildify(direnv.rcPath)))
+        if (direnv.installed) {
+          const approval = APPROVAL_LABELS[direnv.approval]
+          rows.push({
+            key: "direnv-approval",
+            disabled: true,
+            content: styled(
+              dim(fit("approval", LABEL_WIDTH)),
+              chunk(approval, direnv.approval === "allowed" ? theme.success : theme.warning),
+              direnv.approval === "allowed" ? dim("") : dim("   palette: Environment: direnv allow"),
+            ),
+          })
+          rows.push(
+            row("loaded in devcc", direnv.loaded ? "yes" : "no - start devcc from a direnv-enabled shell"),
+          )
+        }
+      }
+    }
 
-    rows.push(blank())
-    rows.push(heading("Toolchain"))
-    rows.push(row("runtime", host.runtime))
-    rows.push(row("node", host.nodeVersion))
-    rows.push(
-      row("package manager", `${state.project.packageManager.manager} ${tools.packageManager ?? ""}`.trim()),
-    )
-    rows.push(row("git", tools.git ?? "not found"))
-    rows.push(row("docker", tools.docker ?? "not found"))
-
-    rows.push(blank())
+    rows.push(blank("usage"))
     rows.push(heading("Usage"))
     if (!metrics) {
       rows.push(row("", "sampling…"))
@@ -67,15 +122,46 @@ export class SystemView extends View {
       rows.push(row("load average", metrics.loadAverage.map((value) => value.toFixed(2)).join("  ")))
       rows.push(row("host uptime", formatDuration(metrics.uptimeMs)))
       rows.push(row("devcc uptime", formatDuration(metrics.processUptimeMs)))
-      rows.push(row("sampled", metrics.sampledAt.toLocaleTimeString()))
     }
 
+    rows.push(blank("host"))
+    rows.push(heading("Host"))
+    rows.push(row("hostname", host.hostname))
+    rows.push(row("os", `${host.platform} ${host.release}`))
+    rows.push(row("cpu", `${host.cpuModel} (${host.cpuCount} cores)`))
+    rows.push(row("memory", `${toGigabytes(host.totalMemory)} GB total`))
+    rows.push(row("devcc runtime", host.runtime))
+    rows.push(row("package manager", state.project.packageManager.manager))
+
     this.list.setRows(rows, -1)
+    if (this.offset > 0) this.list.scrollBy(this.offset)
+    this.offset = this.list.offset
+  }
+
+  override handleKey(key: KeyEvent): boolean {
+    switch (key.name) {
+      case "up":
+      case "k":
+        this.list.scrollBy(-1)
+        this.offset = this.list.offset
+        return true
+      case "down":
+      case "j":
+        this.list.scrollBy(1)
+        this.offset = this.list.offset
+        return true
+      case "r":
+        void this.deps.commands.run("environment.refresh", this.deps.app)
+        return true
+      default:
+        return false
+    }
   }
 
   override hints(): KeyHint[] {
     return [
       { keys: "↑↓", label: "scroll" },
+      { keys: "r", label: "re-check environment" },
       { keys: "/", label: "commands" },
       { keys: "?", label: "help" },
     ]
@@ -88,8 +174,44 @@ function heading(title: string): ListRow {
   return { key: `h-${title}`, disabled: true, content: styled(chunk(title.toUpperCase(), theme.accent)) }
 }
 
-function blank(): ListRow {
-  return { key: `b-${Math.random().toString(36).slice(2)}`, disabled: true, content: "" }
+function blank(id: string): ListRow {
+  return { key: `b-${id}`, disabled: true, content: "" }
+}
+
+const APPROVAL_LABELS: Record<DirenvApproval, string> = {
+  allowed: "allowed",
+  "not-allowed": "not allowed yet",
+  denied: "denied",
+  unknown: "unknown",
+}
+
+function toolRow(tool: ToolStatus): ListRow {
+  const mark = !tool.installed
+    ? chunk("·", theme.textDim)
+    : tool.status === "ready"
+      ? chunk("✓", theme.success)
+      : tool.status === "warning"
+        ? chunk("⚠", theme.warning)
+        : chunk("✖", theme.danger)
+  const value = tool.installed ? (tool.version ?? "installed") : "not installed"
+  return {
+    key: `tool-${tool.id}`,
+    disabled: true,
+    content: styled(
+      dim(fit(tool.name, LABEL_WIDTH)),
+      chunk(fit(value, 16), tool.installed ? theme.text : theme.textDim),
+      mark,
+      tool.message && tool.installed ? chunk(`  ${tool.message}`, theme.warning) : dim(""),
+    ),
+  }
+}
+
+function warningRow(label: string, message: string): ListRow {
+  return {
+    key: `warn-${label}`,
+    disabled: true,
+    content: styled(dim(fit(label, LABEL_WIDTH)), chunk(`⚠ ${message}`, theme.warning)),
+  }
 }
 
 function row(label: string, value: string): ListRow {