@venn-lang/cli 0.1.0

package/src/project/select-packages.ts

@@ -0,0 +1,37 @@
+import { createNodeFs } from "@venn-lang/contracts/node";
+import { findProject, normalise, type Package, type Project } from "@venn-lang/project";
+
+export interface Selection {
+  project: Project;
+  /** The packages this command acts on. */
+  packages: readonly Package[];
+}
+
+export interface SelectArgs {
+  /** Where the command was run, or the path it was given. */
+  from: string;
+  /** `-p api`: one member by name. Absent means the workspace's default set. */
+  packageName?: string;
+}
+
+/**
+ * Which packages a command with no file argument acts on.
+ *
+ * A workspace answers with its `default-members`, or with all of them when it
+ * named none. That is the rule Cargo follows, and the reason `venn test` at the
+ * root of a monorepo means "the suite", not "nothing here".
+ */
+export async function selectPackages(args: SelectArgs): Promise<Selection | undefined> {
+  const { project } = await findProject({ fs: createNodeFs(), from: normalise(args.from) });
+  if (!project) return undefined;
+  if (!args.packageName) return { project, packages: project.defaultPackages };
+  const wanted = project.packages.filter((one) => one.manifest.name === args.packageName);
+  return { project, packages: wanted };
+}
+
+/** What to say when `-p` named something the workspace does not hold. */
+export function unknownPackage(project: Project, name: string): string {
+  const known = project.packages.map((one) => one.manifest.name).filter(Boolean);
+  const list = known.length > 0 ? known.join(", ") : "none";
+  return `VN2103 · no package named ${name} in this workspace.\n  it holds: ${list}\n`;
+}

package/src/project/targets-or-exit.ts

@@ -0,0 +1,28 @@
+import { type CommandKind, resolveTargets } from "./resolve-targets.js";
+
+/**
+ * The paths a command should act on, or nothing, having already written the
+ * reason to stderr and set the exit code.
+ *
+ * Saying why is the point: a bare `venn test` in a folder with no project must
+ * not be indistinguishable from one that found nothing to do.
+ */
+export async function targetsOrExit(args: {
+  kind: CommandKind;
+  target?: string;
+  packageName?: string;
+  binName?: string;
+}): Promise<readonly string[] | undefined> {
+  const found = await resolveTargets({ ...args, cwd: process.cwd() });
+  if (found.problem) {
+    process.stderr.write(found.problem);
+    process.exitCode = 1;
+    return undefined;
+  }
+  return found.paths;
+}
+
+/** The worst outcome of running one command over several paths. */
+export function worst(codes: readonly number[]): number {
+  return codes.reduce((so, far) => Math.max(so, far), 0);
+}

package/src/reporters/colors.ts

@@ -0,0 +1,17 @@
+// Colour only when a human is watching: never when piped, and never against
+// NO_COLOR (https://no-color.org) or a dumb terminal.
+const ESC = String.fromCharCode(27);
+const ENABLED =
+  Boolean(process.stdout.isTTY) && !process.env.NO_COLOR && process.env.TERM !== "dumb";
+
+function style(open: number, close: number): (text: string) => string {
+  return (text) => (ENABLED ? `${ESC}[${open}m${text}${ESC}[${close}m` : text);
+}
+
+export const bold: (text: string) => string = style(1, 22);
+export const dim: (text: string) => string = style(2, 22);
+export const red: (text: string) => string = style(31, 39);
+export const green: (text: string) => string = style(32, 39);
+export const yellow: (text: string) => string = style(33, 39);
+export const cyan: (text: string) => string = style(36, 39);
+export const inverse: (text: string) => string = style(7, 27);

package/src/reporters/dot-sink.ts

@@ -0,0 +1,18 @@
+import type { Envelope } from "@venn-lang/core";
+import type { EventSink } from "@venn-lang/runtime";
+
+/** Terminal reporter: one char per assertion, a summary line at the end. */
+export function createDotSink(): EventSink {
+  return { emit: (envelope) => write(envelope) };
+}
+
+function write(envelope: Envelope): void {
+  if (envelope.kind === "expect.passed") process.stdout.write(".");
+  else if (envelope.kind === "expect.failed") process.stdout.write("F");
+  else if (envelope.kind === "run.finished") writeSummary(envelope);
+}
+
+function writeSummary(envelope: Envelope): void {
+  const data = envelope.data as { passed: number; failed: number; durationMs: number };
+  process.stdout.write(`\n${data.passed} passed, ${data.failed} failed (${data.durationMs}ms)\n`);
+}

package/src/reporters/error-line.ts

@@ -0,0 +1,14 @@
+import { VennError } from "@venn-lang/contracts";
+
+/**
+ * One line for one failure, however it reached us.
+ *
+ * A `VennError` already knows how it wants to read, and leads with its code so
+ * the failure is googlable; anything else is a stray from below the language and
+ * gets its message, never `[object Object]`.
+ */
+export function errorLine(error: unknown): string {
+  if (error instanceof VennError) return `${error.code}  ${error.message}`;
+  const message = (error as { message?: unknown } | undefined)?.message;
+  return typeof message === "string" && message !== "" ? message : String(error);
+}

package/src/reporters/index.ts

@@ -0,0 +1,9 @@
+export { createDotSink } from "./dot-sink.js";
+export { errorLine } from "./error-line.js";
+export { createJunitSink } from "./junit-sink.js";
+export { createStdoutSink } from "./ndjson-stdout.js";
+export { pickReporter } from "./pick-reporter.js";
+export { createPrettyReporter } from "./pretty/index.js";
+export { reportProblems } from "./problem-reporter.js";
+export { createProblemSink } from "./problem-sink.js";
+export type { Reporter, RunTotals } from "./reporter.types.js";

package/src/reporters/junit-sink.ts

@@ -0,0 +1,39 @@
+import type { EventSink } from "@venn-lang/runtime";
+
+interface FlowResult {
+  title: string;
+  status: string;
+}
+
+const XML_ESCAPES: Record<string, string> = {
+  "<": "&lt;",
+  ">": "&gt;",
+  "&": "&amp;",
+  '"': "&quot;",
+};
+
+/** Accumulate flow results and emit a JUnit XML document on run.finished. */
+export function createJunitSink(args: { write: (xml: string) => void }): EventSink {
+  const flows: FlowResult[] = [];
+  return {
+    emit: (envelope) => {
+      if (envelope.kind === "flow.finished") flows.push(envelope.data as FlowResult);
+      else if (envelope.kind === "run.finished") args.write(toJunit(flows));
+    },
+  };
+}
+
+function toJunit(flows: readonly FlowResult[]): string {
+  const failures = flows.filter((flow) => flow.status === "failed").length;
+  const cases = flows.map(toCase).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>\n<testsuite tests="${flows.length}" failures="${failures}">\n${cases}\n</testsuite>\n`;
+}
+
+function toCase(flow: FlowResult): string {
+  const body = flow.status === "failed" ? "<failure/>" : "";
+  return `  <testcase name="${escapeXml(flow.title)}">${body}</testcase>`;
+}
+
+function escapeXml(text: string): string {
+  return text.replace(/[<>&"]/g, (char) => XML_ESCAPES[char] ?? char);
+}

package/src/reporters/ndjson-stdout.ts

@@ -0,0 +1,13 @@
+import { createNdjsonSink, type EventSink } from "@venn-lang/runtime";
+
+/**
+ * An event sink that writes each envelope to stdout as one line of NDJSON: the
+ * stream a script or a CI job parses.
+ */
+export function createStdoutSink(): EventSink {
+  return createNdjsonSink({
+    write: (line) => {
+      process.stdout.write(line);
+    },
+  });
+}

package/src/reporters/pick-reporter.ts

@@ -0,0 +1,28 @@
+import type { EventSink } from "@venn-lang/runtime";
+import { createDotSink } from "./dot-sink.js";
+import { createJunitSink } from "./junit-sink.js";
+import { createStdoutSink } from "./ndjson-stdout.js";
+import { createPrettyReporter } from "./pretty/index.js";
+import type { Reporter } from "./reporter.types.js";
+
+/**
+ * Choose a reporter by name. With no `--reporter`, a terminal gets the readable
+ * tree and anything piped gets NDJSON, so scripts and CI keep the
+ * machine-readable stream they can parse.
+ */
+export function pickReporter(name: string | undefined): Reporter {
+  if (name === "pretty") return createPrettyReporter();
+  if (name === "ndjson") return passive(createStdoutSink());
+  if (name === "dot") return passive(createDotSink());
+  if (name === "junit") return passive(junit());
+  return process.stdout.isTTY ? createPrettyReporter() : passive(createStdoutSink());
+}
+
+// Machine formats say everything they need through the event stream itself.
+function passive(sink: EventSink): Reporter {
+  return { sink, beginFile: () => {}, finish: () => {} };
+}
+
+function junit(): EventSink {
+  return createJunitSink({ write: (xml) => process.stdout.write(xml) });
+}

package/src/reporters/pretty/diff-lines.ts

@@ -0,0 +1,53 @@
+import { type Diff, type DiffEntry, formatValue } from "@venn-lang/core";
+import { bold, dim, green, red } from "../colors.js";
+
+const INDENT = "     ";
+const COLUMN = "expected".length;
+
+/**
+ * The body of a failure: the two sides as the kernel compared them, field by
+ * field (§16). The title says what went wrong in one line; this says where.
+ */
+export function diffLines(diff: Diff): string[] {
+  if (diff.kind === "fields") return fieldLines(diff.label, diff.entries);
+  if (diff.kind === "json") {
+    return [head(diff.path), ...pairLines(formatValue(diff.expected), formatValue(diff.actual))];
+  }
+  return pairLines(diff.expected, diff.actual);
+}
+
+function fieldLines(label: string, entries: readonly DiffEntry[]): string[] {
+  const width = Math.max(0, ...entries.map((entry) => entry.path.length));
+  const lines = [head(label)];
+  for (const [index, entry] of entries.entries()) {
+    lines.push(...entryLines({ entry, width, last: index === entries.length - 1 }));
+  }
+  return lines;
+}
+
+/** One field: a single line when both sides agree, two when they do not. */
+function entryLines(args: { entry: DiffEntry; width: number; last: boolean }): string[] {
+  const { entry, last, width } = args;
+  const branch = `${INDENT}${dim(last ? "└" : "├")} ${entry.path.padEnd(width)}`;
+  if (entry.same) return [`${branch}  ${column("same")}  ${dim(entry.expected)}`];
+  const gutter = `${INDENT}${dim(last ? " " : "│")} ${" ".repeat(width)}`;
+  return [
+    `${branch}  ${column("expected")}  ${green(entry.expected)}`,
+    `${gutter}  ${column("actual")}  ${red(entry.actual)}`,
+  ];
+}
+
+function pairLines(expected: string, actual: string): string[] {
+  return [
+    `${INDENT}${column("expected")}  ${green(expected)}`,
+    `${INDENT}${column("actual")}  ${red(actual)}`,
+  ];
+}
+
+function head(label: string): string {
+  return `${INDENT}${bold(label)}`;
+}
+
+function column(label: string): string {
+  return dim(label.padEnd(COLUMN));
+}

package/src/reporters/pretty/index.ts

@@ -0,0 +1 @@
+export { createPrettyReporter } from "./pretty-reporter.js";

package/src/reporters/pretty/pretty-reporter.ts

@@ -0,0 +1,122 @@
+import type { Envelope, Problem } from "@venn-lang/core";
+import type { Reporter, RunTotals } from "../reporter.types.js";
+import type { Failure, PrettyState } from "./pretty.types.js";
+import {
+  failuresBlock,
+  flowLine,
+  header,
+  locationOf,
+  logLine,
+  reasonLine,
+  stepLine,
+  summary,
+} from "./render.js";
+
+/**
+ * A live tree: each file opens a banner, each flow a branch, and each step
+ * prints its verdict as soon as it settles. Everything that failed across every
+ * file is repeated at the end with its code and source location.
+ */
+export function createPrettyReporter(): Reporter {
+  const state: PrettyState = {
+    flow: "",
+    step: "",
+    inStep: false,
+    stepStartedAt: 0,
+    current: [],
+    logs: [],
+    failures: [],
+  };
+  return {
+    sink: { emit: (envelope) => handle(envelope, state) },
+    beginFile: (file) => {
+      state.pendingFile = file;
+    },
+    finish: (totals) => finishRun(state, totals),
+  };
+}
+
+function handle(envelope: Envelope, state: PrettyState): void {
+  const data = envelope.data as Record<string, unknown>;
+  if (envelope.kind === "flow.started") beginFlow(state, data);
+  else if (envelope.kind === "step.started") beginStep(state, envelope, data);
+  else if (envelope.kind === "expect.failed") failed(state, data);
+  else if (envelope.kind === "step.finished") endStep(state, envelope, data);
+  else if (envelope.kind === "flow.finished") state.flow = "";
+  else if (envelope.kind === "log") logged(state, data);
+}
+
+/**
+ * A failure inside a step waits for that step's verdict, to print under it. One
+ * that arrives between steps (a `setup` or a `teardown` that blew up) has no
+ * verdict coming, and holding it would let the next `step.started` wipe it, so
+ * it goes straight to the summary.
+ */
+function failed(state: PrettyState, data: Record<string, unknown>): void {
+  const failure = fromProblem(state, data);
+  if (state.inStep) state.current.push(failure);
+  else state.failures.push(failure);
+}
+
+function beginFlow(state: PrettyState, data: Record<string, unknown>): void {
+  if (state.pendingFile) {
+    write(header(state.pendingFile));
+    state.pendingFile = undefined;
+  }
+  state.flow = String(data.title ?? "");
+  write(flowLine(state.flow));
+}
+
+function beginStep(state: PrettyState, envelope: Envelope, data: Record<string, unknown>): void {
+  state.step = String(data.title ?? "");
+  state.inStep = true;
+  state.stepStartedAt = Date.parse(envelope.ts);
+  state.current = [];
+  state.logs = [];
+}
+
+function endStep(state: PrettyState, envelope: Envelope, data: Record<string, unknown>): void {
+  const ms = Math.max(0, Date.parse(envelope.ts) - state.stepStartedAt);
+  write(stepLine({ title: String(data.title ?? ""), passed: data.status === "passed", ms }));
+  for (const line of state.logs) write(logLine(line));
+  for (const failure of state.current) write(reasonLine(failure));
+  state.failures.push(...state.current);
+  state.current = [];
+  state.logs = [];
+  state.inStep = false;
+}
+
+/**
+ * `log "…"` prints under its step, like console output in vitest. An error
+ * thrown mid-flow also arrives as a log, and that one is kept for the summary.
+ */
+function logged(state: PrettyState, data: Record<string, unknown>): void {
+  const message = String(data.message ?? "");
+  if (data.level === "error") {
+    state.failures.push({ flow: state.flow, step: state.step, code: "VN7001", title: message });
+  } else {
+    state.logs.push(message);
+  }
+}
+
+function finishRun(state: PrettyState, totals: RunTotals): void {
+  write(failuresBlock(state.failures));
+  write(summary(totals));
+}
+
+function fromProblem(state: PrettyState, data: Record<string, unknown>): Failure {
+  const problem = data.problem as Problem;
+  return {
+    flow: state.flow,
+    // A step that already ended is not to blame for what came after it.
+    step: state.inStep ? state.step : "",
+    code: problem.code,
+    title: problem.title,
+    location: locationOf(problem),
+    diff: problem.diff,
+  };
+}
+
+function write(text: string): void {
+  if (text) process.stdout.write(`${text}\n`);
+}

package/src/reporters/pretty/pretty.types.ts

@@ -0,0 +1,29 @@
+import type { Diff } from "@venn-lang/core";
+
+/** One thing that went wrong, kept for the summary printed after the tree. */
+export interface Failure {
+  flow: string;
+  step: string;
+  code: string;
+  title: string;
+  location?: string;
+  /** The two sides compared, shown as the failure's body. */
+  diff?: Diff;
+}
+
+/** What the reporter tracks while events stream in. */
+export interface PrettyState {
+  /** The file whose banner has not been printed yet. A file with no matching
+   * flow never prints one, so filters stay quiet. */
+  pendingFile?: string;
+  flow: string;
+  step: string;
+  /** Whether a step is open. A failure outside one belongs to no step. */
+  inStep: boolean;
+  stepStartedAt: number;
+  /** Failures seen in the step currently running. */
+  current: Failure[];
+  /** `log` messages emitted during the step currently running. */
+  logs: string[];
+  failures: Failure[];
+}

package/src/reporters/pretty/render.ts

@@ -0,0 +1,88 @@
+import { relative } from "node:path";
+import type { Problem } from "@venn-lang/core";
+import { bold, cyan, dim, green, inverse, red } from "../colors.js";
+import { diffLines } from "./diff-lines.js";
+import type { Failure } from "./pretty.types.js";
+
+const PASS = "✓";
+const FAIL = "✗";
+
+/** The banner naming the file under test. Flows add their own leading blank line. */
+export function header(file: string): string {
+  return `\n${inverse(cyan(" RUN "))} ${dim(shorten(file))}`;
+}
+
+/** A flow opens a branch of the tree. */
+export function flowLine(title: string): string {
+  return `\n ${dim("❯")} ${bold(title)}`;
+}
+
+/** A step closes with its verdict and how long it took. */
+export function stepLine(args: { title: string; passed: boolean; ms: number }): string {
+  const mark = args.passed ? green(PASS) : red(FAIL);
+  return `   ${mark} ${args.title} ${dim(`${args.ms}ms`)}`;
+}
+
+/** Why a step failed, shown inline right under it. */
+export function reasonLine(failure: Failure): string {
+  return `     ${red("→")} ${failure.title}`;
+}
+
+/** A `log` line the flow emitted, shown under its step like console output. */
+export function logLine(message: string): string {
+  const [first = "", ...rest] = message.split("\n");
+  const head = `     ${dim("›")} ${first}`;
+  return [head, ...rest.map((line) => `       ${line}`)].join("\n");
+}
+
+export function failuresBlock(failures: readonly Failure[]): string {
+  if (failures.length === 0) return "";
+  const blocks = failures.map((failure, index) => block(failure, index + 1));
+  return `\n${inverse(red(" FAILURES "))}\n\n${blocks.join("\n\n")}\n`;
+}
+
+export function summary(args: {
+  passed: number;
+  failed: number;
+  files?: number;
+  ms: number;
+}): string {
+  const counts = [
+    args.failed > 0 ? red(`${args.failed} failed`) : undefined,
+    green(`${args.passed} passed`),
+  ];
+  const line = counts.filter(Boolean).join(dim(" | "));
+  const total = dim(`(${args.passed + args.failed})`);
+  const files = args.files && args.files > 1 ? `\n ${dim("Files")}  ${args.files}` : "";
+  return `${files}\n ${dim("Tests")}  ${line} ${total}\n ${dim(" Time")}  ${dim(`${args.ms}ms`)}\n`;
+}
+
+/** `examples/testing/01-first-flow.vn:12:5`, relative to where the CLI was invoked. */
+export function locationOf(problem: Problem): string | undefined {
+  const span = problem.span;
+  if (!span?.uri) return undefined;
+  return `${shorten(span.uri)}:${span.line}:${span.column}`;
+}
+
+function block(failure: Failure, index: number): string {
+  const lines = [
+    `  ${red(`${index})`)} ${bold(where(failure))}`,
+    `     ${red(failure.code)}  ${failure.title}`,
+  ];
+  if (failure.location) lines.push(`     ${dim(`at ${failure.location}`)}`);
+  if (failure.diff) lines.push("", ...diffLines(failure.diff));
+  return lines.join("\n");
+}
+
+/**
+ * Which flow and step it happened in. A hook that failed belongs to neither, so
+ * it says so instead of borrowing the last step's name.
+ */
+function where(failure: Failure): string {
+  return [failure.flow, failure.step].filter(Boolean).join(` ${dim("›")} `) || "lifecycle";
+}
+
+function shorten(file: string): string {
+  const path = relative(process.cwd(), file);
+  return path && !path.startsWith("..") ? path.replace(/\\/g, "/") : file;
+}

package/src/reporters/problem-reporter.ts

@@ -0,0 +1,13 @@
+import type { Problem } from "@venn-lang/core";
+
+/**
+ * Print compile-time problems to stderr, one code and title per problem with
+ * its source location beneath. The terminal surface of the §16 model.
+ */
+export function reportProblems(problems: readonly Problem[]): void {
+  for (const problem of problems) {
+    process.stderr.write(`${problem.code} · ${problem.title}\n`);
+    const { uri, line, column } = problem.span;
+    process.stderr.write(`  at ${uri}:${line}:${column}\n`);
+  }
+}

package/src/reporters/problem-sink.ts

@@ -0,0 +1,20 @@
+import type { Problem } from "@venn-lang/core";
+import type { EventSink } from "@venn-lang/runtime";
+import { reportProblems } from "./problem-reporter.js";
+
+/**
+ * The sink for a run with no reporter watching it: `venn run` leaves stdout to
+ * the program, so nothing draws its flows.
+ *
+ * Failures are the exception. A `setup` that blew up is counted rather than
+ * thrown, so this is the only place it can still be said out loud, on stderr,
+ * where the program's own output is not.
+ */
+export function createProblemSink(): EventSink {
+  return {
+    emit: (envelope) => {
+      if (envelope.kind !== "expect.failed") return;
+      reportProblems([(envelope.data as { problem: Problem }).problem]);
+    },
+  };
+}

package/src/reporters/reporter.types.ts

@@ -0,0 +1,21 @@
+import type { EventSink } from "@venn-lang/runtime";
+
+/** Totals across every file a single `venn run` covered. */
+export interface RunTotals {
+  passed: number;
+  failed: number;
+  files: number;
+  ms: number;
+  /** Set when a file called `exit`: the code the whole command leaves with. */
+  exitCode?: number;
+}
+
+/**
+ * A reporter is an event sink plus the two moments the CLI owns: which file is
+ * starting, and that the whole run is over. Machine formats ignore both.
+ */
+export interface Reporter {
+  sink: EventSink;
+  beginFile(file: string): void;
+  finish(totals: RunTotals): void;
+}

package/src/run/collect-files.ts

@@ -0,0 +1,43 @@
+import { readdir, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+
+const EXTENSION = ".vn";
+const SKIP = new Set(["node_modules", "dist", ".git"]);
+
+/**
+ * The `.vn` files a path names: the file itself, or every one under a
+ * directory, walked recursively and sorted so runs are reproducible.
+ */
+export async function collectSourceFiles(path: string): Promise<string[]> {
+  const info = await stat(path).catch(() => undefined);
+  if (!info) return [];
+  if (info.isFile()) return path.endsWith(EXTENSION) ? [path] : [];
+  return (await walk(path)).sort();
+}
+
+async function walk(directory: string): Promise<string[]> {
+  const entries = await readdir(directory, { withFileTypes: true }).catch(() => []);
+  const found: string[] = [];
+  for (const entry of entries) {
+    if (entry.isDirectory() && !SKIP.has(entry.name))
+      found.push(...(await walk(join(directory, entry.name))));
+    else if (entry.isFile() && entry.name.endsWith(EXTENSION))
+      found.push(join(directory, entry.name));
+  }
+  return found;
+}
+
+/**
+ * Every `.vn` under any of these paths, each counted once.
+ *
+ * Deduplicated because a workspace can name the same directory twice, as a
+ * member and as the root that contains it, and checking a file twice reports
+ * every problem in it twice.
+ */
+export async function everySourceUnder(paths: readonly string[]): Promise<string[]> {
+  const found = new Set<string>();
+  for (const path of paths) {
+    for (const file of await collectSourceFiles(resolve(path))) found.add(file);
+  }
+  return [...found];
+}

package/src/run/ending.types.ts

@@ -0,0 +1,17 @@
+/**
+ * How a program ended, and what the process should do about it.
+ *
+ * Two separate questions. `exit 0` and "ran off the end cleanly" both arrive as
+ * the number 0, but one is a request to leave and the other is a program with
+ * nothing more to say, which for a server means it is still working.
+ */
+export interface Ending {
+  /** The number to leave with. */
+  code: number;
+  /**
+   * Whether the process should go now. False means hand the decision to the
+   * event loop: a program still holding a socket keeps serving, and one holding
+   * nothing exits on its own, running its cleanup on the way.
+   */
+  leave: boolean;
+}

package/src/run/exit-code.ts

@@ -0,0 +1,15 @@
+import type { RunResult } from "@venn-lang/runtime";
+
+/**
+ * The number a run hands to the process.
+ *
+ * `exit 3` is the program saying how it went, and nothing here knows better,
+ * `exit 0` after a failure included. Without one, a run that reported failures
+ * must not leave with 0: a `setup` that blew up is counted rather than thrown,
+ * and a 0 would tell whatever is waiting on this process that the program did
+ * its job.
+ */
+export function exitCodeOf(result: RunResult | undefined): number {
+  if (result?.exitCode !== undefined) return result.exitCode;
+  return result && result.failed > 0 ? 1 : 0;
+}