@workerstack/repo 0.0.0-stage → 0.1.0

package/cli/scripts/ci-wait.ts

@@ -0,0 +1,175 @@
+/**
+ * `repo ci wait`: finds the newest `ci` run for HEAD on the current branch, waits for it, and exits 0 when it passed,
+ * 2 when a newer run on the branch superseded it (it was cancelled), 1 when it failed (with the failed jobs and their
+ * logs) or could not be found.
+ */
+import { z } from "zod";
+import {
+  CONCLUSION_CANCELLED,
+  CONCLUSION_SUCCESS,
+  EXIT_FAILED,
+  EXIT_PASSED,
+  EXIT_SUPERSEDED,
+  GH_AUTH,
+  GH_LIST_BRANCH,
+  GH_LIST_COMMIT,
+  GH_LOGS,
+  GH_VIEW,
+  GH_WATCH,
+  GIT_BRANCH,
+  GIT_HEAD,
+  GIT_REMOTES,
+  GIVE_UP_MS,
+  MS_PER_SECOND,
+  NOT_FAILED,
+  POLL_MS,
+  SHA_SHOWN,
+} from "./ci-wait.constants.ts";
+import { realSleep, spawnRunner, type Runner } from "./ci-wait-run.ts";
+
+export type { Runner } from "./ci-wait-run.ts";
+export type WaitDeps = {
+  cwd: string;
+  stdout: (s: string) => void;
+  stderr: (s: string) => void;
+  /** Milliseconds; the clock the wait for the run is measured on. */
+  now?: () => number;
+  sleep?: (ms: number) => Promise<void>;
+  git?: Runner;
+  gh?: Runner;
+  /** The commit and branch to wait on; skips the HEAD, branch and remote checks and keeps the gh login check. */
+  target?: Target;
+};
+/** How the wait for HEAD's run ended: `error` carries the line `repo ci wait` prints and a shorter `detail`. */
+export type WaitOutcome =
+  | { kind: "passed" }
+  | { kind: "failed" }
+  | { kind: "superseded" }
+  | { kind: "error"; line: string; detail: string };
+type Io = Required<Omit<WaitDeps, "target">>;
+/** A commit and the branch whose `ci` run for it is waited on. */
+export type Target = { sha: string; branch: string };
+type RunInfo = { databaseId: number; createdAt: string; headBranch: string };
+
+const runsSchema = () => z.array(z.object({ databaseId: z.number(), createdAt: z.string(), headBranch: z.string() }));
+const branchRunsSchema = () => z.array(z.object({ databaseId: z.number(), createdAt: z.string() }));
+const viewSchema = () =>
+  z.object({
+    conclusion: z.string(),
+    jobs: z.array(z.object({ name: z.string(), conclusion: z.string() })),
+  });
+
+/** The JSON in a gh run's stdout, parsed against `schema`; null when the run failed or the text is not that. */
+export function readJson<T>(got: { code: number; stdout: string }, schema: z.ZodType<T>): T | null {
+  if (got.code !== 0) return null;
+  try {
+    const parsed = schema.safeParse(JSON.parse(got.stdout));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+
+const newestFirst = <T extends { createdAt: string }>(runs: T[]): T[] =>
+  [...runs].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+
+const GH_LOGIN = "gh is not installed or not logged in; run `gh auth login`";
+
+/** HEAD and the current branch, or why there is nothing to wait on. */
+function locate(io: Io): Target | { error: string } {
+  const head = io.git(GIT_HEAD.slice(), io.cwd);
+  const sha = head.stdout.trim();
+  if (head.code !== 0 || sha === "") {
+    return { error: `cannot read HEAD (${head.stderr.trim()}); run it inside a git checkout` };
+  }
+  if (io.git(GIT_REMOTES(sha), io.cwd).stdout.trim() === "") {
+    return { error: `${sha.slice(0, SHA_SHOWN)} is not on any remote branch; push it first` };
+  }
+  if (io.gh(GH_AUTH.slice(), io.cwd).code !== 0) return { error: GH_LOGIN };
+  return { sha, branch: io.git(GIT_BRANCH.slice(), io.cwd).stdout.trim() };
+}
+
+/** The given target once gh is logged in, or why there is nothing to wait on. */
+function givenTarget(io: Io, target: Target): Target | { error: string } {
+  return io.gh(GH_AUTH.slice(), io.cwd).code === 0 ? target : { error: GH_LOGIN };
+}
+
+/** The newest run of HEAD on the branch, looking every `POLL_MS` until `GIVE_UP_MS` have passed since `started`. */
+async function findRun(io: Io, target: Target, started: number): Promise<RunInfo | null> {
+  const runs = readJson(io.gh(GH_LIST_COMMIT(target.sha), io.cwd), runsSchema()) ?? [];
+  const [newest] = newestFirst(runs.filter((run) => run.headBranch === target.branch));
+  if (newest !== undefined) return newest;
+  if (io.now() - started >= GIVE_UP_MS) return null;
+  await io.sleep(POLL_MS);
+  return findRun(io, target, started);
+}
+
+/** The newest run on the branch that was created after `run`. */
+function newerRun(io: Io, run: RunInfo): { databaseId: number } | undefined {
+  const runs = readJson(io.gh(GH_LIST_BRANCH(run.headBranch), io.cwd), branchRunsSchema()) ?? [];
+  return newestFirst(runs.filter((other) => other.createdAt > run.createdAt))[0];
+}
+
+/** Prints the failed line and the failed steps' logs. */
+function failure(io: Io, run: RunInfo, view: z.infer<ReturnType<typeof viewSchema>> | null): WaitOutcome {
+  const names = (view?.jobs ?? []).filter((item) => !NOT_FAILED.includes(item.conclusion)).map((item) => item.name);
+  const what = names.length > 0 ? names.join(", ") : `ci ${view?.conclusion || "run has no result"}`;
+  io.stdout(`failed: ${what}; logs below\n`);
+  const logs = io.gh(GH_LOGS(run.databaseId), io.cwd);
+  io.stdout(logs.code === 0 ? logs.stdout : "logs expired\n");
+  return { kind: "failed" };
+}
+
+/** Watches `run` to its end, then reads its result and reports it. */
+function conclude(io: Io, run: RunInfo): WaitOutcome {
+  io.gh(GH_WATCH(run.databaseId), io.cwd);
+  const view = readJson(io.gh(GH_VIEW(run.databaseId), io.cwd), viewSchema());
+  if (view?.conclusion === CONCLUSION_SUCCESS) {
+    io.stdout("passed\n");
+    return { kind: "passed" };
+  }
+  const newer = view?.conclusion === CONCLUSION_CANCELLED ? newerRun(io, run) : undefined;
+  if (newer !== undefined) {
+    io.stdout(`superseded by run ${newer.databaseId} on ${run.headBranch}\n`);
+    return { kind: "superseded" };
+  }
+  return failure(io, run, view);
+}
+
+/**
+ * Waits for the newest `ci` run of HEAD and reports how it ended, printing what the run printed: the waiting line, then
+ * passed, the failed jobs with their logs, or the run that superseded it. A missing run, remote or gh login is `error`.
+ */
+export async function waitFor(deps: WaitDeps): Promise<WaitOutcome> {
+  const io: Io = {
+    cwd: deps.cwd,
+    stdout: deps.stdout,
+    stderr: deps.stderr,
+    now: deps.now ?? Date.now,
+    sleep: deps.sleep ?? realSleep,
+    git: deps.git ?? spawnRunner("git"),
+    gh: deps.gh ?? spawnRunner("gh"),
+  };
+  const target = deps.target === undefined ? locate(io) : givenTarget(io, deps.target);
+  if ("error" in target) return { kind: "error", line: target.error, detail: target.error };
+  const short = target.sha.slice(0, SHA_SHOWN);
+  const run = await findRun(io, target, io.now());
+  if (run === null) {
+    const waited = `${GIVE_UP_MS / MS_PER_SECOND}s`;
+    return {
+      kind: "error",
+      line: `no ci run for ${short} after ${waited}; check the workflow ran`,
+      detail: `no ci run after ${waited}`,
+    };
+  }
+  io.stdout(`waiting for ci on ${short} (run ${run.databaseId})…\n`);
+  return conclude(io, run);
+}
+
+const EXIT_OF = { passed: EXIT_PASSED, failed: EXIT_FAILED, superseded: EXIT_SUPERSEDED, error: EXIT_FAILED };
+
+export async function waitMain(deps: WaitDeps): Promise<number> {
+  const outcome = await waitFor(deps);
+  if (outcome.kind === "error") deps.stderr(`repo ci wait: ${outcome.line}\n`);
+  return EXIT_OF[outcome.kind];
+}

package/cli/scripts/ci.constants.ts

@@ -0,0 +1,15 @@
+/** A tsconfig file name in the root or a package directory. */
+export const TSCONFIG_FILE: RegExp = /^tsconfig.*\.json$/;
+/** A path segment under which a package is a fixture or an install, never typechecked. */
+export const SKIPPED_SEGMENTS: readonly string[] = ["fixtures", `${"node"}_modules`];
+export const TSC_ARGS: readonly string[] = ["--noEmit", "-p"];
+export const VITEST_RUN_ARGS: readonly string[] = ["run", "--coverage"];
+/** The same run without coverage, so no per-file floor applies. */
+export const VITEST_RUN_NO_COVERAGE_ARGS: readonly string[] = ["run"];
+export const SUMMARY_SEPARATOR = " · ";
+export const MS_PER_SECOND = 1000;
+export const USAGE = "use repo ci [--no-coverage] [--report <file>], repo ci skips <dir> or repo ci wait";
+export const REPORT_FLAG = "--report";
+export const NO_COVERAGE_FLAG = "--no-coverage";
+export const SKIPS_COMMAND = "skips";
+export const WAIT_COMMAND = "wait";

package/cli/scripts/ci.ts

@@ -0,0 +1,208 @@
+/**
+ * `repo ci`: every gate of the repo in one call, in order and all of them: `repo check`, `repo fmt --check`,
+ * `tsc --noEmit -p` on every tsconfig of the root and each workspace package, and `vitest run --coverage`. Each gate
+ * prints its line when it ends, with its output under it when it failed, then one summary line; exit 1 when any failed.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { CONFIG_FILE, findRoot } from "../config.ts";
+import { readWorkspace } from "../sync/workspace.ts";
+import { REPORT_JSON_FILE, REPORT_OUTPUT_FLAG, REPORT_REPORTERS, REPORT_TEMP_PREFIX } from "./ci-skips.constants.ts";
+import { skipsMain, writeReport } from "./ci-skips.ts";
+import { waitMain, type WaitDeps } from "./ci-wait.ts";
+import {
+  MS_PER_SECOND,
+  REPORT_FLAG,
+  SKIPPED_SEGMENTS,
+  SKIPS_COMMAND,
+  SUMMARY_SEPARATOR,
+  TSCONFIG_FILE,
+  TSC_ARGS,
+  USAGE,
+  NO_COVERAGE_FLAG,
+  VITEST_RUN_ARGS,
+  VITEST_RUN_NO_COVERAGE_ARGS,
+  WAIT_COMMAND,
+} from "./ci.constants.ts";
+import { captureBun, type Captured } from "./lint.ts";
+import { BINS } from "./turn.ts";
+import { countsOfRun, type Bins } from "./turn-steps.ts";
+
+export type CiDeps = {
+  cwd?: string;
+  stdout?: (s: string) => void;
+  stderr?: (s: string) => void;
+  /** Milliseconds; the clock the gate times come from. */
+  now?: () => number;
+  bins?: Bins;
+  /** Runs `repo <args>` in a directory. */
+  repo?: (args: string[], cwd: string) => Captured;
+} & Pick<WaitDeps, "git" | "gh" | "sleep">;
+/** Where `repo ci` runs and writes. */
+type Io = { cwd: string; stdout: (s: string) => void; stderr: (s: string) => void };
+type Ctx = Required<Pick<CiDeps, "bins" | "repo">> & { root: string; json: string | undefined; coverage: boolean };
+type Command =
+  | { kind: "gates"; report?: string; coverage: boolean }
+  | { kind: "skips"; dir: string }
+  | { kind: "wait" }
+  | { kind: "usage" };
+/** A gate's outcome; `ran` is false when no tool ran, so there is no time to show. */
+type Gate = { label: string; ok: boolean; output: string[]; ran: boolean };
+
+const pass = (label: string, ran = true): Gate => ({ label, ok: true, output: [], ran });
+const fail = (label: string, output: string[], ran = true): Gate => ({ label, ok: false, output, ran });
+const plural = (n: number, word: string) => `${n} ${word}${n === 1 ? "" : "s"}`;
+const textOf = (run: Captured) => `${run.stdout}${run.stderr}`;
+
+/** `repo <args>` run by this checkout's bin. */
+const runRepo = (args: string[], cwd: string): Captured =>
+  captureBun([path.join(import.meta.dirname, "../../bin/repo.ts"), ...args], cwd);
+
+/** `repo <args>` as the gate `name`. */
+function repoGate(name: string, args: string[], ctx: Ctx): Gate {
+  const run = ctx.repo(args, ctx.root);
+  return run.code === 0 ? pass(`${name} ok`) : fail(`${name} failed`, [textOf(run)]);
+}
+
+/** The root-relative tsconfigs of the root and each package that is not a fixture or an install. */
+function tsconfigs(root: string): { ok: true; files: string[] } | { ok: false; errors: string[] } {
+  const workspace = readWorkspace(root);
+  if (!workspace.ok) return workspace;
+  const dirs = workspace.workspace.packages
+    .map((pkg) => pkg.dir)
+    .filter((dir) => !dir.split("/").some((segment) => SKIPPED_SEGMENTS.includes(segment)));
+  const files = [".", ...dirs].flatMap((dir) =>
+    fs
+      .readdirSync(path.join(root, dir), { withFileTypes: true })
+      .filter((entry) => entry.isFile() && TSCONFIG_FILE.test(entry.name))
+      .map((entry) => path.posix.join(dir, entry.name))
+      .sort(),
+  );
+  return { ok: true, files };
+}
+
+function typecheckGate(ctx: Ctx): Gate {
+  const found = tsconfigs(ctx.root);
+  if (!found.ok)
+    return fail(
+      "typecheck failed",
+      found.errors.map((line) => `${line}\n`),
+    );
+  if (found.files.length === 0) return pass("typecheck skipped (no tsconfig.json)", false);
+  const runs = found.files.map((file) => ({ file, run: ctx.bins.tsc([...TSC_ARGS, file], ctx.root) }));
+  const bad = runs.filter(({ run }) => run.code !== 0);
+  if (bad.length === 0) return pass(`typecheck ${plural(found.files.length, "config")}`);
+  return fail(
+    `typecheck failed (${bad.map(({ file }) => file).join(", ")})`,
+    bad.map(({ run }) => textOf(run)),
+  );
+}
+
+function testsGate(ctx: Ctx): Gate {
+  const reporting = ctx.json === undefined ? [] : [...REPORT_REPORTERS, `${REPORT_OUTPUT_FLAG}${ctx.json}`];
+  const base = ctx.coverage ? VITEST_RUN_ARGS : VITEST_RUN_NO_COVERAGE_ARGS;
+  const run = ctx.bins.vitest([...base, ...reporting], ctx.root);
+  if (run === null) return pass("tests skipped (no vitest in .)", false);
+  const counts = countsOfRun(run);
+  if (run.code === 0) return pass(`${plural(counts.passed, "test")} passed`);
+  const detail = counts.failed > 0 ? ` (${counts.failed} failed, ${counts.passed} passed)` : "";
+  return fail(`tests failed${detail}`, [textOf(run)]);
+}
+
+/** Runs each gate in order, printing its line as it ends and its output under it when it failed. */
+function runGates(ctx: Ctx, now: () => number, stdout: (s: string) => void): Gate[] {
+  const gates: ((ctx: Ctx) => Gate)[] = [
+    (c) => repoGate("check", ["check"], c),
+    (c) => repoGate("fmt", ["fmt", "--check"], c),
+    typecheckGate,
+    testsGate,
+  ];
+  return gates.map((run) => {
+    const started = now();
+    const gate = run(ctx);
+    const seconds = ((now() - started) / MS_PER_SECOND).toFixed(1);
+    stdout(`ci: ${gate.label}${gate.ran ? ` (${seconds}s)` : ""}\n`);
+    for (const chunk of gate.output) stdout(chunk.endsWith("\n") ? chunk : `${chunk}\n`);
+    return gate;
+  });
+}
+
+/** The gates run that `--no-coverage` and `--report <file>`, in any order, ask for; null for anything else. */
+function gateFlags(argv: string[]): Command | null {
+  const command: Command = { kind: "gates", coverage: true };
+  for (let i = 0; i < argv.length; i++) {
+    const next = argv[i + 1];
+    if (argv[i] === NO_COVERAGE_FLAG) command.coverage = false;
+    else if (argv[i] === REPORT_FLAG && next !== undefined) {
+      command.report = next;
+      i++;
+    } else return null;
+  }
+  return command;
+}
+
+/** What `argv` asks for. */
+function parse(argv: string[]): Command {
+  const [first, second, ...rest] = argv;
+  if (first === SKIPS_COMMAND && second !== undefined && rest.length === 0) return { kind: "skips", dir: second };
+  if (first === WAIT_COMMAND && second === undefined) return { kind: "wait" };
+  return gateFlags(argv) ?? { kind: "usage" };
+}
+
+/** The context to run the gates in, or why `repo ci` cannot start; `json` is where vitest writes its report. */
+function prepare(
+  cwd: string,
+  deps: CiDeps,
+  run: { json: string | undefined; coverage: boolean },
+): { ctx: Ctx } | { error: string } {
+  const root = findRoot(cwd);
+  if (root === null) return { error: `no ${CONFIG_FILE} in ${cwd} or any parent; run \`bun repo init\`` };
+  return { ctx: { root, json: run.json, coverage: run.coverage, bins: deps.bins ?? BINS, repo: deps.repo ?? runRepo } };
+}
+
+/** Runs the gates, and writes the skip report to `report` after them when asked for one. */
+function gatesMain({ report, coverage }: { report?: string; coverage: boolean }, deps: CiDeps, io: Io): number {
+  const temp = report === undefined ? undefined : fs.mkdtempSync(path.join(os.tmpdir(), REPORT_TEMP_PREFIX));
+  const json = temp === undefined ? undefined : path.join(temp, REPORT_JSON_FILE);
+  try {
+    const prepared = prepare(io.cwd, deps, { json, coverage });
+    if ("error" in prepared) {
+      io.stderr(`repo ci: ${prepared.error}\n`);
+      return 1;
+    }
+    const gates = runGates(prepared.ctx, deps.now ?? Date.now, io.stdout);
+    io.stdout(`ci: ${gates.map((gate) => gate.label).join(SUMMARY_SEPARATOR)}\n`);
+    if (report !== undefined && json !== undefined && !writeTo({ report, json, root: prepared.ctx.root }, io)) return 1;
+    return gates.every((gate) => gate.ok) ? 0 : 1;
+  } finally {
+    if (temp !== undefined) fs.rmSync(temp, { recursive: true, force: true });
+  }
+}
+
+/** Writes the report file from the JSON at `json`; false, with the reason on stderr, when it cannot be written. */
+function writeTo({ report, json, root }: { report: string; json: string; root: string }, io: Io): boolean {
+  try {
+    writeReport(path.resolve(io.cwd, report), json, root);
+    return true;
+  } catch (error) {
+    io.stderr(
+      `repo ci: cannot write ${report}: ${(error /* writeFileSync throws Errors, with a message */ as Error).message}\n`,
+    );
+    return false;
+  }
+}
+
+export function main(argv: string[], deps: CiDeps = {}): number | Promise<number> {
+  const command = parse(argv);
+  const io: Io = {
+    cwd: deps.cwd ?? process.cwd(),
+    stdout: deps.stdout ?? ((s: string) => process.stdout.write(s)),
+    stderr: deps.stderr ?? ((s: string) => process.stderr.write(s)),
+  };
+  if (command.kind === "skips") return skipsMain(command.dir, io);
+  if (command.kind === "wait") return waitMain({ ...deps, ...io });
+  if (command.kind === "gates") return gatesMain(command, deps, io);
+  io.stderr(`repo ci: ${USAGE}\n`);
+  return 1;
+}