@workerstack/repo 0.0.0-stage → 0.1.0

package/cli/scripts/sync-global-settings.ts

@@ -0,0 +1,316 @@
+#!/usr/bin/env bun
+/**
+ * Merge each manifest host payload (`agents/global-settings/*`) into its
+ * dotfile under $HOME: claude, codex, grok, antigravity and cursor full-permission
+ * keys. Payload keys win; unrelated dest keys survive. Applies by default;
+ * `--dry-run` only reports, `--check` reports drift per host.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { checkHint, checkHosts, checkLine, projectConfigError } from "./check-globals.ts";
+import { isRecord } from "./hook-input.ts";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { readEnv } from "../env.ts";
+
+/** The package root, two levels above `cli/scripts/`: where the stock manifest and payloads live. */
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+const MANIFEST_REL = "agents/global-settings/manifest.json";
+
+export type JsonObject = Record<string, unknown>;
+export type SettingsFormat = "json" | "toml";
+
+/** One host in the manifest: the payload file in the repo and the dotfile under $HOME it merges into. */
+export interface ManifestHost {
+  id: string;
+  format: SettingsFormat;
+  payload: string;
+  dest: string;
+}
+
+export interface Manifest {
+  skipKeyPattern: string;
+  hosts: ManifestHost[];
+}
+
+export type ParsedArgv = { ok: true; dryRun: boolean; check: boolean; host: string } | { ok: false; error: string };
+
+export interface ReportRow {
+  action: string;
+  id: string;
+  dest: string;
+  line: string;
+}
+
+export interface SyncResult {
+  ok: boolean;
+  report: ReportRow[];
+  error?: string;
+}
+
+const errorText = (err: unknown): string => (err instanceof Error ? err.message : String(err));
+
+export function parseArgv(argv: unknown): ParsedArgv {
+  const args: unknown[] = Array.isArray(argv) ? argv : [];
+  let dryRun = false;
+  let check = false;
+  let host = "all";
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--dry-run") {
+      dryRun = true;
+      continue;
+    }
+    if (a === "--check") {
+      check = true;
+      continue;
+    }
+    if (a === "--host") {
+      const v = args[++i];
+      if (typeof v !== "string" || !v) {
+        return { ok: false, error: "unknown host: " };
+      }
+      host = v;
+      continue;
+    }
+    if (typeof a === "string" && a.startsWith("--host=")) {
+      const v = a.slice("--host=".length);
+      if (!v) {
+        return { ok: false, error: "unknown host: " };
+      }
+      host = v;
+      continue;
+    }
+    return { ok: false, error: `unknown flag: ${a}` };
+  }
+  if (check && dryRun) return { ok: false, error: "--check and --dry-run do not combine" };
+  return { ok: true, dryRun, check, host };
+}
+
+export function resolveDest(home: string | null | undefined, dest: string | null | undefined): string {
+  if (!home) throw new Error("home required");
+  if (dest == null || dest === "") throw new Error("dest required");
+  const resolvedHome = path.resolve(home);
+  const resolved = path.resolve(resolvedHome, dest);
+  const prefix = resolvedHome.endsWith(path.sep) ? resolvedHome : resolvedHome + path.sep;
+  if (resolved !== resolvedHome && !resolved.startsWith(prefix)) {
+    throw new Error(`dest not under home: ${dest}`);
+  }
+  return resolved;
+}
+
+export function shouldSkip(segment: unknown, skipRe: RegExp | null | undefined): boolean {
+  if (!skipRe) return false;
+  return skipRe.test(String(segment));
+}
+
+function isPlainObject(v: unknown): v is JsonObject {
+  return v != null && typeof v === "object" && !Array.isArray(v) && !(v instanceof Date);
+}
+
+export function deepMerge(
+  dest: unknown,
+  source: unknown,
+  skipRe: RegExp | null | undefined,
+  keyPath: string[] = [],
+): JsonObject {
+  const out: JsonObject = isPlainObject(dest) ? { ...dest } : {};
+  if (!isPlainObject(source)) return out;
+  for (const [k, v] of Object.entries(source)) {
+    const nextPath = [...keyPath, k];
+    if (nextPath.some((seg) => shouldSkip(seg, skipRe))) continue;
+    const prev = out[k];
+    if (isPlainObject(v) && isPlainObject(prev)) {
+      out[k] = deepMerge(prev, v, skipRe, nextPath);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+export function loadManifest(workspaceRoot: string): Manifest {
+  const p = path.join(workspaceRoot, MANIFEST_REL);
+  const raw = fs.readFileSync(p, "utf8");
+  const manifest: unknown = JSON.parse(raw);
+  if (!isRecord(manifest)) {
+    throw new Error("invalid manifest");
+  }
+  const { skipKeyPattern, hosts } = manifest;
+  if (typeof skipKeyPattern !== "string") {
+    throw new Error("manifest skipKeyPattern required");
+  }
+  if (!Array.isArray(hosts)) {
+    throw new Error("manifest hosts required");
+  }
+  const checked: ManifestHost[] = [];
+  for (const h of hosts) {
+    if (!isRecord(h) || typeof h.id !== "string" || (h.format !== "json" && h.format !== "toml")) {
+      throw new Error("manifest host needs id and format json|toml");
+    }
+    if (typeof h.payload !== "string" || typeof h.dest !== "string") {
+      throw new Error(`manifest host ${h.id} needs payload and dest`);
+    }
+    checked.push({ ...h, id: h.id, format: h.format, payload: h.payload, dest: h.dest });
+  }
+  return { ...manifest, skipKeyPattern, hosts: checked };
+}
+
+export function hostIdsOf(manifest: Manifest): Set<string> {
+  return new Set([...manifest.hosts.map((h) => h.id), "all"]);
+}
+
+/** Parse payload or dest text as `format`; empty text is `{}`. Throws on bad syntax. */
+export function parseText(raw: unknown, format: SettingsFormat): JsonObject {
+  const s = String(raw ?? "");
+  if (!s.trim()) return {};
+  const v: unknown = format === "json" ? JSON.parse(s) : parseToml(s);
+  if (!isPlainObject(v)) throw new Error("not an object");
+  return v;
+}
+
+/** Read a dest file; a missing file is `{}`, anything unreadable throws `unreadable dest: <label>`. */
+export function readDest(destAbs: string, format: SettingsFormat, label: string): JsonObject {
+  let raw: string;
+  try {
+    raw = fs.readFileSync(destAbs, "utf8");
+  } catch (err) {
+    if (isRecord(err) && err.code === "ENOENT") return {};
+    throw new Error(`unreadable dest: ${label}`);
+  }
+  try {
+    return parseText(raw, format);
+  } catch {
+    throw new Error(`unreadable dest: ${label}`);
+  }
+}
+
+export const OVERLAY_DIR = ".repo/global-settings";
+
+/**
+ * Read a host payload; a missing file throws `missing payload: <rel>`, bad syntax `unreadable payload: <rel>`. A file of
+ * the payload's name under `<consumerRoot>/.repo/global-settings/` replaces the stock payload whole.
+ */
+export function readPayload(workspaceRoot: string, host: ManifestHost, consumerRoot?: string): JsonObject {
+  const overlay = consumerRoot === undefined ? null : path.join(consumerRoot, OVERLAY_DIR, path.basename(host.payload));
+  const abs = overlay !== null && fs.existsSync(overlay) ? overlay : path.join(workspaceRoot, host.payload);
+  let raw: string;
+  try {
+    raw = fs.readFileSync(abs, "utf8");
+  } catch (err) {
+    if (isRecord(err) && err.code === "ENOENT") throw new Error(`missing payload: ${host.payload}`);
+    throw new Error(`unreadable payload: ${host.payload}`);
+  }
+  try {
+    return parseText(raw, host.format);
+  } catch {
+    throw new Error(`unreadable payload: ${host.payload}`);
+  }
+}
+
+function stringifyDest(value: JsonObject, format: SettingsFormat): string {
+  const body = format === "json" ? JSON.stringify(value, null, 2) : stringifyToml(value);
+  return body.endsWith("\n") ? body : body + "\n";
+}
+
+function reportRow({ action, id, dest }: { action: string; id: string; dest: string }): ReportRow {
+  return { action, id, dest, line: `${action} ${id} ${dest}` };
+}
+
+/**
+ * Manifest and payloads come from `sourceRoot` (default `workspaceRoot`); a payload under `consumerRoot`'s
+ * `.repo/global-settings/` (default `workspaceRoot`) replaces the stock one. Only `home` is written.
+ */
+export function syncGlobals({
+  workspaceRoot,
+  sourceRoot,
+  consumerRoot,
+  home,
+  apply = false,
+  host = "all",
+}: {
+  workspaceRoot?: string;
+  sourceRoot?: string;
+  consumerRoot?: string;
+  home?: string;
+  apply?: boolean;
+  host?: string;
+} = {}): SyncResult {
+  const report: ReportRow[] = [];
+  const action = apply ? "apply" : "dry-run";
+  try {
+    const consumer = consumerRoot || workspaceRoot || process.cwd();
+    const ws = sourceRoot || workspaceRoot || process.cwd();
+    const manifest = loadManifest(ws);
+    if (!hostIdsOf(manifest).has(host)) {
+      return { ok: false, report, error: `unknown host: ${host}` };
+    }
+    const skipRe = new RegExp(manifest.skipKeyPattern, "i");
+    for (const h of manifest.hosts.filter((x) => host === "all" || x.id === host)) {
+      const source = readPayload(ws, h, consumer);
+      const destAbs = resolveDest(home, h.dest);
+      const merged = deepMerge(readDest(destAbs, h.format, h.dest), source, skipRe);
+      if (apply) {
+        fs.mkdirSync(path.dirname(destAbs), { recursive: true });
+        fs.writeFileSync(destAbs, stringifyDest(merged, h.format));
+      }
+      report.push(reportRow({ action, id: h.id, dest: h.dest }));
+    }
+    return { ok: true, report };
+  } catch (err) {
+    return { ok: false, report, error: errorText(err) };
+  }
+}
+
+/** `--check`: one line of per-host status, the hint on drift, then any project config error. */
+function runCheck(home: string, host: string): number {
+  const cwd = process.cwd();
+  let statuses: ReturnType<typeof checkHosts>;
+  try {
+    statuses = checkHosts({ home, workspaceRoot: cwd, sourceRoot: PACKAGE_ROOT, consumerRoot: cwd, host });
+  } catch (err) {
+    process.stderr.write(errorText(err) + "\n");
+    return 1;
+  }
+  process.stdout.write(checkLine(statuses) + "\n");
+  const hint = checkHint(statuses);
+  if (hint) process.stdout.write(hint + "\n");
+  const projectError = projectConfigError(cwd, home);
+  if (projectError) process.stderr.write(projectError + "\n");
+  return hint || projectError || statuses.some((s) => s.state !== "ok") ? 1 : 0;
+}
+
+export function main(argv: string[]): number {
+  try {
+    const parsed = parseArgv(argv);
+    if (!parsed.ok) {
+      process.stderr.write(parsed.error + "\n");
+      return 1;
+    }
+    const home = readEnv().HOME;
+    if (!home) {
+      process.stderr.write("HOME required\n");
+      return 1;
+    }
+    if (parsed.check) return runCheck(home, parsed.host);
+    const result = syncGlobals({
+      workspaceRoot: process.cwd(),
+      sourceRoot: PACKAGE_ROOT,
+      consumerRoot: process.cwd(),
+      home,
+      apply: !parsed.dryRun,
+      host: parsed.host,
+    });
+    for (const row of result.report) {
+      process.stdout.write(row.line + "\n");
+    }
+    if (!result.ok) {
+      process.stderr.write(result.error + "\n");
+      return 1;
+    }
+    return 0;
+  } catch (err) {
+    process.stderr.write(errorText(err) + "\n");
+    return 1;
+  }
+}

package/cli/scripts/turn-steps.ts

@@ -0,0 +1,249 @@
+/**
+ * The steps of `repo turn`, each over the change set: fmt, lint with the baseline gate, typecheck, related tests,
+ * then sync and check when their inputs changed. A step reports a summary label, whether it passed, the tool output
+ * to print when it failed, and the files it rewrote, which `--staged` restages.
+ */
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { CONFIG_FILE, type LintSkip } from "../config.ts";
+import { withoutSkipped } from "../check-magic.ts";
+import { scriptDiagnostics } from "../script-diagnostics.ts";
+import { readManifest } from "../sync/manifest.ts";
+import type { Change } from "./change-set.ts";
+import { captureBun, captureTool, type Captured } from "./lint.ts";
+import {
+  BASELINE_PATH,
+  countsOf,
+  type Counts as Baseline,
+  excessText,
+  gate,
+  lintReport,
+  readBaseline,
+  writeBaseline,
+  type Diagnostic,
+  type Excess,
+  type Result,
+} from "./lint-baseline.ts";
+
+/** typescript, a dependency, and vitest, an optional peer: null when the package at `cwd` cannot resolve it. */
+export type Bins = {
+  tsc: (args: string[], cwd: string) => Captured;
+  vitest: (args: string[], cwd: string) => Captured | null;
+};
+/** A change set to gate, with the root's packages, the bins it runs and the config's `lint.skip` entries. */
+export type Turn = {
+  root: string;
+  changes: readonly Change[];
+  packages: readonly string[];
+  bins: Bins;
+  skips: readonly LintSkip[];
+};
+export type StepResult = { label: string; ok: boolean; output: string[]; touched: string[] };
+/** A step; null when its inputs did not change. */
+export type Step = (turn: Turn) => StepResult | null;
+
+const LINTABLE = /\.(?:[cm]?[jt]sx?|vue|astro|svelte)$/;
+const LOCKFILES = new Set(["bun.lock", "bun.lockb", "package-lock.json", "yarn.lock", "pnpm-lock.yaml"]);
+const BIN = path.join(import.meta.dirname, "../../bin/repo.ts");
+
+const present = (turn: Turn) => turn.changes.filter((change) => !change.deleted).map((change) => change.rel);
+const text = (root: string, rel: string) => fs.readFileSync(path.join(root, rel), { encoding: "utf8", flag: "r" });
+const plural = (n: number, word: string) => `${n} ${word}${n === 1 ? "" : "s"}`;
+export const passed = (label: string, touched: string[] = []): StepResult => ({ label, ok: true, output: [], touched });
+export const failed = (label: string, output: string[], touched: string[] = []): StepResult => ({
+  label,
+  ok: false,
+  output,
+  touched,
+});
+
+/** The files of `files` whose text a tool rewrote between this call and the returned one. */
+function watch(root: string, files: readonly string[]): () => string[] {
+  const before = new Map(files.map((rel) => [rel, text(root, rel)]));
+  return () => files.filter((rel) => text(root, rel) !== before.get(rel));
+}
+
+export const fmtStep: Step = (turn) => {
+  const files = present(turn);
+  if (files.length === 0) return passed("fmt ok");
+  const rewritten = watch(turn.root, files);
+  const run = captureTool("oxfmt", ["--no-error-on-unmatched-pattern", ...files], turn.root);
+  const touched = rewritten();
+  if (run.code !== 0) return failed("fmt failed", [`${run.stdout}${run.stderr}`], touched);
+  return passed(touched.length === 0 ? "fmt ok" : `fmt ${touched.length} fixed`, touched);
+};
+
+/** The lint lines of each excess's rule in its file, then what to do about it. */
+function overOutput(over: readonly Excess[], diagnostics: readonly Diagnostic[]): string[] {
+  const lines = diagnostics
+    .filter((d) => over.some((e) => e.file === d.file && e.rule === d.rule))
+    .map((d) => `${d.line}\n`);
+  const fixes = over.map((e) => {
+    const added = e.has - e.allows;
+    return `repo turn: ${excessText(e)}; fix the ${added === 1 ? "new one" : `${added} new ones`}\n`;
+  });
+  return [...lines, ...fixes];
+}
+
+/** `lint --fix -f json` on `files`, then oxfmt on any file the fix rewrote. */
+function lintFix(root: string, files: readonly string[]): { report: Result<Diagnostic[]>; fixed: string[] } {
+  if (files.length === 0) return { report: { ok: true, value: [] }, fixed: [] };
+  const rewritten = watch(root, files);
+  const report = lintReport(root, ["--fix", ...files]);
+  const fixed = rewritten();
+  if (fixed.length > 0) captureTool("oxfmt", fixed, root);
+  return { report, fixed };
+}
+
+/**
+ * oxlint's `report` with the script hits of `files` after it, those a `lint.skip` entry turns off left out. The hits
+ * include the guards of sources a changed test imports, which may lie outside `files`.
+ */
+function withScripts(turn: Turn, files: readonly string[], report: Result<Diagnostic[]>): Result<Diagnostic[]> {
+  const scripts = report.ok ? scriptDiagnostics(turn.root, files) : report;
+  if (!report.ok || !scripts.ok) return scripts;
+  const reported = [...new Set([...files, ...scripts.value.map((d) => d.file)])];
+  return { ok: true, value: [...report.value, ...withoutSkipped(scripts.value, turn.skips, reported)] };
+}
+
+/**
+ * The excesses of the files outside the change set a changed test re-checked: only their script hits are known, so
+ * they can fail the turn but never lower the baseline.
+ */
+function outsideOver(baseline: Baseline, diagnostics: readonly Diagnostic[], linted: readonly string[]): Excess[] {
+  const outside = diagnostics.filter((d) => !linted.includes(d.file));
+  const files = [...new Set(outside.map((d) => d.file))];
+  return gate(baseline, countsOf(outside), files).over;
+}
+
+/** `lint --fix` on the lintable files, then the baseline gate over them and the deleted ones. */
+export const lintStep: Step = (turn) => {
+  const files = present(turn).filter((rel) => LINTABLE.test(rel));
+  const { report: oxlint, fixed } = lintFix(turn.root, files);
+  const report = withScripts(turn, files, oxlint);
+  const baseline = readBaseline(turn.root);
+  if (!report.ok || !baseline.ok) {
+    const errors = [report, baseline].flatMap((read) => (read.ok ? [] : read.errors));
+    return failed(
+      "lint failed",
+      errors.map((line) => `repo turn: ${line}\n`),
+      fixed,
+    );
+  }
+  const linted = turn.changes
+    .filter((change) => change.deleted || LINTABLE.test(change.rel))
+    .map((change) => change.rel);
+  const result = gate(baseline.value, countsOf(report.value), linted);
+  if (result.lowered.length > 0) writeBaseline(turn.root, result.next);
+  const touched = result.lowered.length > 0 ? [...fixed, BASELINE_PATH] : fixed;
+  const over = [...result.over, ...outsideOver(baseline.value, report.value, linted)];
+  if (over.length > 0) {
+    const count = over.reduce((sum, e) => sum + e.has - e.allows, 0);
+    return failed(`lint ${count} over baseline`, overOutput(over, report.value), touched);
+  }
+  const lowered = result.lowered.map((l) => `${l.file} ${l.rule} ${l.from} → ${l.to}`).join(", ");
+  return passed(lowered === "" ? "lint ok" : `lint ok, baseline lowered (${lowered})`, touched);
+};
+
+export const owners = (turn: Turn): string[] => [...new Set(turn.changes.map((change) => change.owner))].sort();
+export const dirName = (owner: string): string => owner || ".";
+
+type Counts = { passed: number; failed: number; total: number };
+
+/** vitest's `Tests  1 failed | 3 passed (4)` line, read from its default reporter. */
+export function countsOfRun(run: Captured): Counts {
+  const line = /^\s*Tests\s+(.*)$/m.exec(run.stdout)?.[1] ?? "";
+  const number = (pattern: RegExp) => Number(pattern.exec(line)?.[1] ?? 0);
+  return { passed: number(/(\d+) passed/), failed: number(/(\d+) failed/), total: number(/\((\d+)\)/) };
+}
+
+function testsLabel(counts: Counts, skipped: readonly string[], broke: boolean): string {
+  const none = skipped.length > 0 ? ` (no vitest in ${skipped.join(", ")})` : "";
+  if (counts.failed > 0) return `${plural(counts.total, "related test")}, ${counts.failed} failed${none}`;
+  if (broke) return `related tests failed${none}`;
+  if (counts.passed > 0) return `${plural(counts.passed, "related test")} passed${none}`;
+  return none === "" || counts.total > 0 ? `0 related tests${none}` : `related tests skipped${none}`;
+}
+
+/** One `vitest related --run` per owning package on its changed code files; null where vitest is not installed. */
+function relatedRuns(turn: Turn): { owner: string; run: Captured | null }[] {
+  return owners(turn).flatMap((owner) => {
+    const own = turn.changes
+      .filter((change) => !change.deleted && change.owner === owner && LINTABLE.test(change.rel))
+      .map((change) => path.posix.relative(owner, change.rel));
+    if (own.length === 0) return [];
+    const args = ["related", "--run", "--passWithNoTests", ...own];
+    return [{ owner, run: turn.bins.vitest(args, path.join(turn.root, owner)) }];
+  });
+}
+
+export const testsStep: Step = (turn) => {
+  const runs = relatedRuns(turn);
+  const skipped = runs.filter(({ run }) => run === null).map(({ owner }) => dirName(owner));
+  const ran = runs.flatMap(({ run }) => (run === null ? [] : [run]));
+  const counts = ran.map(countsOfRun).reduce(
+    (sum, next) => ({
+      passed: sum.passed + next.passed,
+      failed: sum.failed + next.failed,
+      total: sum.total + next.total,
+    }),
+    { passed: 0, failed: 0, total: 0 },
+  );
+  const bad = ran.filter((run) => run.code !== 0);
+  const label = testsLabel(counts, skipped, bad.length > 0);
+  return bad.length === 0
+    ? passed(label)
+    : failed(
+        label,
+        bad.map((run) => `${run.stdout}${run.stderr}`),
+      );
+};
+
+const isManifest = (turn: Turn, rel: string) =>
+  rel === "package.json" || turn.packages.some((dir) => rel === `${dir}/package.json`);
+
+/** Sync reads `.repo/` (but not the baseline, which turn itself writes), `references/`, the manifests and the config. */
+function syncReads(turn: Turn, rel: string): boolean {
+  const repoDir = rel.startsWith(".repo/") && rel !== BASELINE_PATH;
+  return repoDir || rel.startsWith("references/") || isManifest(turn, rel) || rel === CONFIG_FILE;
+}
+
+/** Check holds the manifests, lockfiles, `bunfig.toml`, the config and every tracked file sync writes. */
+function checkReads(turn: Turn, rel: string, outputs: ReadonlySet<string>): boolean {
+  const named = LOCKFILES.has(path.posix.basename(rel)) || rel === "bunfig.toml" || rel === CONFIG_FILE;
+  return named || isManifest(turn, rel) || outputs.has(rel);
+}
+
+/** What `git add -A` would stage now, each with its text (null when deleted). */
+function dirty(root: string): Map<string, string | null> {
+  const git = (args: string[]) =>
+    spawnSync("git", [...args, "-z"], { cwd: root, encoding: "utf8" })
+      .stdout.split("\0")
+      .filter(Boolean);
+  const rels = [...git(["diff", "--name-only"]), ...git(["ls-files", "--others", "--exclude-standard"])];
+  return new Map(rels.map((rel) => [rel, fs.existsSync(path.join(root, rel)) ? text(root, rel) : null]));
+}
+
+/** `repo sync` in the root, and the files it changed that git would stage. */
+function sync(root: string): { run: Captured; touched: string[] } {
+  const before = dirty(root);
+  const run = captureBun([BIN, "sync"], root);
+  const after = dirty(root);
+  return { run, touched: [...after].filter(([rel, now]) => before.get(rel) !== now).map(([rel]) => rel) };
+}
+
+/** `repo sync` when a file it reads changed; the files it rewrote are restaged under `--staged`. */
+export const syncStep: Step = (turn) => {
+  if (!turn.changes.some((change) => syncReads(turn, change.rel))) return null;
+  const { run, touched } = sync(turn.root);
+  return run.code === 0 ? passed("sync ok", touched) : failed("sync failed", [`${run.stdout}${run.stderr}`], touched);
+};
+
+/** `repo check` when a file it holds changed. */
+export const checkStep: Step = (turn) => {
+  const outputs = new Set(readManifest(turn.root).paths);
+  if (!turn.changes.some((change) => checkReads(turn, change.rel, outputs))) return null;
+  const run = captureBun([BIN, "check"], turn.root);
+  return run.code === 0 ? passed("check ok") : failed("check failed", [`${run.stdout}${run.stderr}`]);
+};