@agent-delivery-harness/cli 0.1.0 → 0.2.0

package/src/commands/runs.ts

@@ -0,0 +1,255 @@
+/**
+ * `runs` — read the run store back: `runs list`, `runs show <id>`, and
+ * `runs serve`, the local page over the same files.
+ *
+ * THE VIEWER IS NOT A JUDGE. Everything rendered here is self-attested: an
+ * executor wrote most of it, and the executor could have written anything.
+ * Every readout says so in as many words, because the failure this surface
+ * invites is an operator reading `complete` as though the product had verified
+ * something. It has not. The completeness readout is observability, and the
+ * viewer supplies no record tree SHA at all, so every rule phrased over a
+ * record's candidate is evaluated over any paired round and labeled unbound.
+ *
+ * EVERY STRING HERE IS HOSTILE UNTIL RENDERED. Rationales, decisions, blocker
+ * summaries and gate labels are executor-written free text on their way to a
+ * terminal. `oneLine` neutralizes the escape sequences and collapses the
+ * whitespace, so a rationale carrying a newline and a plausible-looking
+ * completion row renders as one row's worth of text and forges nothing.
+ */
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { evaluateRunJournal } from "@agent-delivery-harness/kernel";
+import {
+  READOUT_LABELS,
+  detailOf,
+  readoutRows,
+  roundRows,
+} from "../run-projection.ts";
+import { startRunServer, type RunServerHandle } from "../run-server.ts";
+import { oneLine, oneLineOf, resolveRunSurface, runSurfaceBlocker, type RunSurface } from "../run-surface.ts";
+import type { CommandResult, ConfigFreeCommandContext, ConfigFreeCommandDescriptor } from "../boundary.ts";
+
+const USAGE = [
+  "Usage: delivery-harness runs list",
+  "       delivery-harness runs show <run-id>",
+  "       delivery-harness runs serve [--repo <path>]... [--port <n>]",
+].join("\n");
+
+const unresolvable = (reason: string): CommandResult => ({
+  kind: "blocked",
+  blockers: [
+    runSurfaceBlocker({
+      code: "run_store_unresolvable",
+      summary: "The run store could not be resolved.",
+      details: oneLine(reason, 200),
+      remediation: {
+        id: "run-inside-a-repository",
+        summary: "Run this command inside a git repository; the run store lives under its common directory.",
+      },
+    }),
+  ],
+});
+
+export const runsCommand: ConfigFreeCommandDescriptor = {
+  name: "runs",
+  sourceId: "delivery-harness.cli.runs",
+  summary: "List, show, and serve the delivery runs this repository has recorded.",
+  configFree: true,
+  async run(context: ConfigFreeCommandContext): Promise<CommandResult> {
+    const [subcommand, ...rest] = context.args;
+    if (subcommand === undefined) return { kind: "usage", message: `runs needs a subcommand.\n${USAGE}` };
+    if (subcommand !== "list" && subcommand !== "show" && subcommand !== "serve") {
+      return { kind: "usage", message: `Unknown runs subcommand ${oneLine(subcommand, 64)}.\n${USAGE}` };
+    }
+    if (subcommand === "show" && rest[0] === undefined) {
+      return { kind: "usage", message: `runs show needs a run id.\n${USAGE}` };
+    }
+    // `serve` resolves its OWN repositories — one per `--repo`, none of them
+    // necessarily the invoking worktree — so it never asks the invoking
+    // worktree's store to resolve first.
+    if (subcommand === "serve") return serveRuns(context, rest);
+
+    const resolved = await resolveRunSurface(context.rootDir);
+    if (!resolved.ok) return unresolvable(resolved.reason);
+
+    return subcommand === "list"
+      ? listRuns(resolved.surface, context)
+      : showRun(resolved.surface, context, rest[0]!);
+  },
+};
+
+// ── list ─────────────────────────────────────────────────────────────────────
+
+/** The journal's size on disk, or zero where it cannot be measured. */
+async function sizeOf(runsDir: string, runId: string): Promise<number> {
+  try {
+    return (await stat(path.join(runsDir, `${runId}.jsonl`))).size;
+  } catch {
+    return 0;
+  }
+}
+
+async function listRuns(surface: RunSurface, context: ConfigFreeCommandContext): Promise<CommandResult> {
+  const runIds = await surface.store.list();
+  const current = await surface.store.current(surface.worktreeKey);
+  const currentRunId = current.ok ? current.runId : undefined;
+
+  // The status column carries a completeness verdict, so this readout is
+  // labeled exactly like `show`'s. `list` is the command an operator reaches
+  // for first, before it knows which id to show; an unlabeled `complete` here
+  // is the misreading the labels exist to prevent.
+  const lines: string[] = [`runs in ${oneLine(surface.runsDir, 400)}`, `  (${READOUT_LABELS})`];
+  let total = 0;
+  for (const runId of runIds) {
+    const size = await sizeOf(surface.runsDir, runId);
+    total += size;
+    const read = await surface.store.read(runId);
+    if (!read.ok) {
+      lines.push(`  ${runId}  unreadable  ${size} bytes`);
+      continue;
+    }
+    const evaluation = evaluateRunJournal(read.events);
+    const open = !read.events.some((event) => event.kind === "run.ended");
+    lines.push(
+      `  ${runId}  ${evaluation.status}  ${open ? "open" : "ended"}${runId === currentRunId ? " current" : ""}  ${size} bytes`,
+    );
+  }
+  lines.push(`total ${total} bytes across ${runIds.length} run(s)`);
+  for (const line of lines) context.write(line);
+  return { kind: "ok" };
+}
+
+// ── show ─────────────────────────────────────────────────────────────────────
+
+async function showRun(surface: RunSurface, context: ConfigFreeCommandContext, runId: string): Promise<CommandResult> {
+  const read = await surface.store.read(runId);
+  if (!read.ok) {
+    return {
+      kind: "blocked",
+      blockers: [
+        runSurfaceBlocker({
+          code: "run_unresolvable",
+          summary: "That run has no readable journal in this store.",
+          details: `run ${oneLine(runId, 128)}: ${oneLine(read.rejections[0]?.message ?? "unreadable", 200)}`,
+          remediation: { id: "list-the-runs", summary: "Run `delivery-harness runs list` to see the runs this repository holds." },
+        }),
+      ],
+    };
+  }
+
+  const events = read.events;
+  const open = !events.some((event) => event.kind === "run.ended");
+  const current = await surface.store.current(surface.worktreeKey);
+  const isCurrent = current.ok && current.runId === runId;
+
+  context.write(`run ${runId}  ${open ? "open" : "ended"}${isCurrent ? "  current in this worktree" : ""}`);
+  context.write("  events:");
+  for (const event of events) {
+    context.write(`    ${event.seq}  ${event.at}  ${event.kind.padEnd(20)}  ${event.actor.role.padEnd(8)}  ${detailOf(event)}`);
+  }
+
+  const rounds = roundRows(events);
+  if (rounds.length > 0) {
+    context.write("  rounds:");
+    for (const row of rounds) context.write(`  ${row}`);
+  }
+
+  const decisions = events.filter((event) => event.kind === "decision.recorded");
+  if (decisions.length > 0) {
+    context.write("  decisions:");
+    for (const decision of decisions) context.write(`    ${detailOf(decision)}`);
+  }
+
+  const notes = await surface.store.readNotes(runId);
+  if (notes.length > 0) {
+    context.write("  refused appends:");
+    for (const entry of notes) {
+      const note = (typeof entry === "object" && entry !== null ? entry : {}) as Record<string, unknown>;
+      context.write(
+        `    ${oneLineOf(note["at"], 32)}  ${oneLineOf(note["kind"], 128)}  ${oneLineOf(note["code"], 64)}${note["pattern"] === undefined ? "" : `  ${oneLineOf(note["pattern"], 64)}`}`,
+      );
+    }
+  }
+
+  // No record tree sha and no mandated pair: the viewer has neither, and
+  // pretending otherwise would turn an observation into a claim.
+  for (const row of readoutRows(events, evaluateRunJournal(events), context.rootDir)) context.write(row);
+  return { kind: "ok" };
+}
+
+// ── serve ────────────────────────────────────────────────────────────────────
+
+interface ServeArgs {
+  readonly repos: readonly string[];
+  readonly port?: number;
+}
+
+type ServeParse = { readonly ok: true; readonly args: ServeArgs } | { readonly ok: false; readonly message: string };
+
+/**
+ * The separate-argument form every other command uses. `--flag=value` is
+ * REFUSED rather than accepted as a convenience: one spelling means an
+ * operator who mistypes a path gets a usage error instead of a server quietly
+ * watching a repository named `--repo=/some/path`.
+ */
+function parseServeArgs(args: readonly string[], rootDir: string): ServeParse {
+  const repos: string[] = [];
+  let port: number | undefined;
+
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]!;
+    if (token === "--repo" || token === "--port") {
+      const value = args[index + 1];
+      if (value === undefined) return { ok: false, message: `${token} needs a value.\n${USAGE}` };
+      index += 1;
+      if (token === "--repo") {
+        repos.push(path.resolve(rootDir, value));
+        continue;
+      }
+      if (!/^\d{1,5}$/.test(value)) return { ok: false, message: `--port needs a port number.\n${USAGE}` };
+      const parsed = Number(value);
+      if (parsed > 65535) return { ok: false, message: `--port needs a port number.\n${USAGE}` };
+      port = parsed;
+      continue;
+    }
+    if (token.startsWith("--")) return { ok: false, message: `Unknown flag ${oneLine(token, 64)}.\n${USAGE}` };
+    return { ok: false, message: `runs serve takes no positional arguments.\n${USAGE}` };
+  }
+
+  // No `--repo` means the worktree the operator is standing in, which is the
+  // only repository they can have meant.
+  return { ok: true, args: { repos: repos.length === 0 ? [rootDir] : repos, ...(port === undefined ? {} : { port }) } };
+}
+
+/**
+ * Serves until the invocation is signalled.
+ *
+ * There is no other exit. A viewer's job is to be there while the operator
+ * watches, and the operator ends it with the interrupt the boundary already
+ * maps; a run ending is not a reason to stop serving, because the next run
+ * starts in the same store.
+ */
+async function serveRuns(context: ConfigFreeCommandContext, args: readonly string[]): Promise<CommandResult> {
+  const parsed = parseServeArgs(args, context.rootDir);
+  if (!parsed.ok) return { kind: "usage", message: parsed.message };
+
+  const started = await startRunServer({ repos: parsed.args.repos, ...(parsed.args.port === undefined ? {} : { port: parsed.args.port }) });
+  if (!started.ok) return unresolvable(started.reason);
+
+  const server: RunServerHandle = started.server;
+  context.write(`serving ${parsed.args.repos.length} repository path(s) at ${server.url}`);
+  context.write(`  (${READOUT_LABELS})`);
+  try {
+    await untilSignalled(context.signal);
+  } finally {
+    await server.close();
+  }
+  return { kind: "ok" };
+}
+
+/** Resolves when the invocation's signal aborts; never, when it has none. */
+function untilSignalled(signal: AbortSignal | undefined): Promise<void> {
+  if (signal === undefined) return new Promise<void>(() => {});
+  if (signal.aborted) return Promise.resolve();
+  return new Promise<void>((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
+}

package/src/commands/verify.ts

@@ -7,18 +7,120 @@
  * the pure `verifyDeliveryRecord` core. A missing record names the command that
  * writes it; a failed check surfaces the named drift class. When the base-movement
  * policy is `allow`, a passing check that relaxed base drift names the relaxation.
+ *
+ * THE RUN-JOURNAL ROW, AND WHY IT IS LOCAL ONLY. `verify` is the one caller
+ * that holds both halves of the question "was this candidate journaled": a
+ * record binding an exact tree sha, and a repository whose run store it can
+ * scan for a journal bound to the same one. So it resolves the row and reports
+ * it — and reporting is all it does by default. The row changes no exit code
+ * unless the operator asks for that with `--require-run-journal`, a LOCAL
+ * opt-in: it is not passed by the GitHub Action, not read by the gate, and not
+ * consulted by admission. A run journal is self-attested observability that
+ * anything the owner executes can append to, so a delivery that could be
+ * admitted or refused on one would be resting its gate on a file its own
+ * candidate scripts can write.
+ *
+ * `--mandated-lens <id>` is the second half of the same opt-in: supplied, the
+ * evaluator checks the journal's declared mandated pair against these ids
+ * rather than merely checking that it declared two non-empty ones. Repeatable,
+ * separate-argument form, and bounded to the run family's own id charset before
+ * it reaches the kernel.
  */
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { deliveryRecordPathFor, parseDeliveryRecord, verifyDeliveryRecord } from "@agent-delivery-harness/kernel";
+import {
+  MAX_RUN_PROVIDER_ID,
+  RUN_PROVIDER_ID,
+  deliveryRecordPathFor,
+  needsCommittedSymlinkTarget,
+  parseCandidateTreeListing,
+  parseDeliveryRecord,
+  runGitCommand,
+  verifyDeliveryRecord,
+  type CandidateTreeEntry,
+  type RunJournalRow,
+} from "@agent-delivery-harness/kernel";
 import { commandBlocker } from "../boundary.ts";
 import type { CommandContext, CommandDescriptor, CommandResult } from "../boundary.ts";
+import { oneLine, resolveRunJournalRow, runJournalRows } from "../run-surface.ts";
+
+const USAGE = "Usage: delivery-harness verify [--require-run-journal] [--mandated-lens <id>]...";
+
+interface ParsedArgs {
+  readonly requireRunJournal: boolean;
+  readonly mandatedLensIds: readonly string[];
+}
+
+type ArgParse = { readonly ok: true; readonly args: ParsedArgs } | { readonly ok: false; readonly message: string };
+
+/**
+ * The separate-argument form every other command's flags take: `--flag value`,
+ * never `--flag=value`. The joined form is not silently split, because a
+ * `--mandated-lens=x` that quietly worked here and nowhere else would be a
+ * second grammar for the same CLI. It falls through to the unknown-flag arm,
+ * which is a usage error naming the token.
+ */
+function parseArgs(args: readonly string[]): ArgParse {
+  let requireRunJournal = false;
+  const mandatedLensIds: string[] = [];
+
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]!;
+    if (token === "--require-run-journal") {
+      requireRunJournal = true;
+      continue;
+    }
+    if (token === "--mandated-lens") {
+      const value = args[index + 1];
+      if (value === undefined) return { ok: false, message: `${token} needs a value.\n${USAGE}` };
+      // Bounded before the kernel sees it: an id is compared against journal
+      // content, and an unbounded one would be echoed into the row it produces.
+      if (value.length > MAX_RUN_PROVIDER_ID || !RUN_PROVIDER_ID.test(value)) {
+        return { ok: false, message: `${token} takes a bounded lens id, not ${oneLine(value, 64)}.\n${USAGE}` };
+      }
+      mandatedLensIds.push(value);
+      index += 1;
+      continue;
+    }
+    if (token.startsWith("-")) return { ok: false, message: `Unknown flag ${oneLine(token, 64)}.\n${USAGE}` };
+    return { ok: false, message: `verify takes no positional arguments, and ${oneLine(token, 64)} is one.\n${USAGE}` };
+  }
+  return { ok: true, args: { requireRunJournal, mandatedLensIds } };
+}
+
+/**
+ * The opt-in's refusal. It names the status, the missing entries, and the
+ * violated constraints, all of them product-defined names from the evaluator's
+ * two closed sets — never journal-derived text.
+ */
+function runJournalBlocker(row: RunJournalRow) {
+  const missing = row.missing.length === 0 ? "(none)" : row.missing.join(", ");
+  const violations = row.violations === undefined || row.violations.length === 0 ? "(none)" : row.violations.join(", ");
+  return commandBlocker({
+    code: "run_journal_incomplete",
+    sourceId: "delivery-harness.cli.verify",
+    summary: "The run journal for this candidate is not complete, and --require-run-journal was given.",
+    details: `status ${row.status}${row.runId === undefined ? "" : ` (run ${oneLine(row.runId, 128)})`}; missing: ${missing}; violations: ${violations}`,
+    remediations: [
+      {
+        id: "emit-the-missing-run-events",
+        kind: "manual_action",
+        summary: "Emit the run events this delivery did not journal, or drop --require-run-journal: the row is observability, not evidence.",
+      },
+    ],
+  });
+}
 
 export const verifyCommand: CommandDescriptor = {
   name: "verify",
   sourceId: "delivery-harness.cli.verify",
   summary: "Verify the tracked delivery record against the current candidate.",
   async run(context: CommandContext): Promise<CommandResult> {
+    // Arguments first: a malformed invocation is a usage error and captures
+    // nothing, exactly as `emit` and `submit-evidence` order it.
+    const parsedArgs = parseArgs(context.args);
+    if (!parsedArgs.ok) return { kind: "usage", message: parsedArgs.message };
+
     const wiring = await context.wire();
     const capture = await wiring.captureCandidate();
     if (!capture.ok) {
@@ -67,17 +169,62 @@ export const verifyCommand: CommandDescriptor = {
       return { kind: "blocked", blockers: [...parsed.blockers] };
     }
 
-    const check = verifyDeliveryRecord(context.config, parsed.record, identity, base);
+    // The tracked tree's own entries, so this command rejects a candidate
+    // carrying a projection or discovery-configuration path exactly as the
+    // Action does. An unreadable listing supplies no entries rather than a
+    // false clean bill: the check simply does not run.
+    //
+    // Mode and object, not just the name: the one admitted exception under
+    // `.claude/skills/` turns on the entry being a symlink and on where its
+    // committed target resolves, and both facts live in the tree.
+    const listing = await runGitCommand(["git", "ls-tree", "-r", "-z", "--full-tree", "HEAD"], {
+      cwd: context.rootDir,
+    });
+    const candidateTreePaths: CandidateTreeEntry[] = [];
+    if (listing.exitCode === 0) {
+      for (const entry of parseCandidateTreeListing(listing.stdout)) {
+        if (!needsCommittedSymlinkTarget(entry)) {
+          candidateTreePaths.push(entry);
+          continue;
+        }
+        // The target read out of the committed blob, never off the filesystem:
+        // the working tree's link may differ from the one under review. A blob
+        // that will not read leaves the target absent, and an entry with no
+        // target cannot reach the exception.
+        const blob = await runGitCommand(["git", "cat-file", "blob", entry.objectSha], { cwd: context.rootDir });
+        candidateTreePaths.push(blob.exitCode === 0 ? { ...entry, symlinkTarget: blob.stdout } : entry);
+      }
+    }
+
+    // The row is resolved from the RECORD'S tree sha, not the recomputed
+    // identity: the identity digest excludes the review-neutral paths, and what
+    // a review round and a `pr.opened` bind is the raw tree the record carries.
+    const runJournal = await resolveRunJournalRow({
+      cwd: context.rootDir,
+      treeSha: parsed.record.candidateBinding.treeSha,
+      ...(parsedArgs.args.mandatedLensIds.length === 0 ? {} : { mandatedLensIds: parsedArgs.args.mandatedLensIds }),
+    });
+
+    const check = verifyDeliveryRecord(context.config, parsed.record, identity, base, { candidateTreePaths, runJournal });
     if (!check.ok) {
       return { kind: "blocked", blockers: [...check.blockers] };
     }
 
+    // The opt-in is judged AFTER the record's own verification, so a delivery
+    // whose record is bad is never told its journal is the problem.
+    if (parsedArgs.args.requireRunJournal && runJournal.status !== "complete") {
+      return { kind: "blocked", blockers: [runJournalBlocker(runJournal)] };
+    }
+
     const relaxation = check.baseMovementRelaxed
       ? ` (base movement relaxed by policy: ${check.relaxedDriftClasses.join(", ")})`
       : "";
     return {
       kind: "ok",
-      summary: `verified ${relativePath}${relaxation}; attestation: ${check.attestationLabel}`,
+      summary: [
+        `verified ${relativePath}${relaxation}; attestation: ${check.attestationLabel}`,
+        ...runJournalRows(runJournal),
+      ].join("\n"),
     };
   },
 };

package/src/index.ts

@@ -1,5 +1,5 @@
 /**
- * Delivery harness CLI: the seven-command operator surface.
+ * Delivery harness CLI: the eleven-command operator surface.
  *
  * THE COMMAND REGISTRY. `COMMANDS` is the single source of truth for which
  * commands exist. Every command module under `commands/` must appear here, and
@@ -12,22 +12,32 @@
  * in `boundary.ts`; each command is a thin, testable unit behind it.
  */
 import { checkCommand } from "./commands/check.ts";
+import { emitCommand } from "./commands/emit.ts";
 import { gateCommand } from "./commands/gate.ts";
+import { maintainCommand } from "./commands/maintain.ts";
+import { managedCommand } from "./commands/managed.ts";
 import { prepareCommand } from "./commands/prepare.ts";
 import { recordCommand } from "./commands/record.ts";
 import { reviewContextCommand } from "./commands/review-context.ts";
+import { runsCommand } from "./commands/runs.ts";
 import { submitEvidenceCommand } from "./commands/submit-evidence.ts";
 import { verifyCommand } from "./commands/verify.ts";
-import { runCliBoundary, type CliRuntime, type CommandDescriptor } from "./boundary.ts";
+import { runCliBoundary, type AnyCommandDescriptor, type CliRuntime } from "./boundary.ts";
 
 export const PACKAGE_NAME = "@agent-delivery-harness/cli";
 
 /**
  * The command registry. The order here is the order `--help` lists them, and it
  * follows the loop an operator walks: prepare, review, submit, gate, record,
- * verify — with `check` last as the standalone preflight.
+ * verify — with `check` as the standalone preflight and `managed` as the
+ * host-facing managed-delivery checkpoint surface and `maintain` as the
+ * installation-scoped maintenance lane.
+ *
+ * `emit` and `runs` come last because they are a different class: config-free
+ * commands, dispatched before `harness.config.ts` is loaded, that read and
+ * write the run store rather than anything a delivery decision depends on.
  */
-export const COMMANDS: readonly CommandDescriptor[] = [
+export const COMMANDS: readonly AnyCommandDescriptor[] = [
   prepareCommand,
   reviewContextCommand,
   submitEvidenceCommand,
@@ -35,22 +45,31 @@ export const COMMANDS: readonly CommandDescriptor[] = [
   recordCommand,
   verifyCommand,
   checkCommand,
+  managedCommand,
+  maintainCommand,
+  emitCommand,
+  runsCommand,
 ];
 
 export {
+  COMPLETION_WRAPPED_COMMANDS,
   EXIT_INTERRUPTED,
   EXIT_OK,
   EXIT_POLICY,
   EXIT_USAGE,
   CliInterruption,
+  isConfigFreeCommand,
   runCliBoundary,
   wireRepo,
   importHarnessConfig,
   commandBlocker,
+  type AnyCommandDescriptor,
   type CliRuntime,
   type CommandContext,
   type CommandDescriptor,
   type CommandResult,
+  type ConfigFreeCommandContext,
+  type ConfigFreeCommandDescriptor,
   type RepoWiring,
 } from "./boundary.ts";
 
@@ -61,6 +80,10 @@ export { gateCommand } from "./commands/gate.ts";
 export { recordCommand } from "./commands/record.ts";
 export { verifyCommand } from "./commands/verify.ts";
 export { checkCommand } from "./commands/check.ts";
+export { managedCommand } from "./commands/managed.ts";
+export { maintainCommand } from "./commands/maintain.ts";
+export { emitCommand } from "./commands/emit.ts";
+export { runsCommand } from "./commands/runs.ts";
 
 /** Runs the CLI against a runtime and returns the process exit code. */
 export function runCli(argv: readonly string[], runtime: CliRuntime): Promise<number> {

package/src/main.ts

@@ -111,6 +111,28 @@ export function invokedDirectly(argvEntry: string | undefined, moduleHref: strin
   return canonicalEntryPath(argvEntry) === canonicalEntryPath(modulePath);
 }
 
+/**
+ * Reads the whole of stdin as UTF-8.
+ *
+ * `emit` takes its payload here, and the one thing that must never happen is a
+ * hang: a terminal with no pipe attached would otherwise leave the command
+ * waiting forever for a line nobody is going to type. A TTY stdin therefore
+ * reads as empty, and the store refuses the empty payload with a diagnostic,
+ * which is a far better answer than silence.
+ */
+export function readStdinText(input: NodeJS.ReadableStream & { isTTY?: boolean }): Promise<string> {
+  if (input.isTTY === true) return Promise.resolve("");
+  return new Promise((resolve) => {
+    let text = "";
+    input.setEncoding("utf8");
+    input.on("data", (chunk: string) => {
+      text += chunk;
+    });
+    input.once("error", () => resolve(text));
+    input.once("end", () => resolve(text));
+  });
+}
+
 export function defaultRuntime(): CliRuntime {
   return {
     cwd: process.cwd(),
@@ -120,6 +142,7 @@ export function defaultRuntime(): CliRuntime {
     stdout: (text) => process.stdout.write(text),
     stderr: (text) => process.stderr.write(text),
     promptForWaiver: readlineWaiverPrompt,
+    readStdin: () => readStdinText(process.stdin),
   };
 }