@number10/ci-runner-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,852 @@
+#!/usr/bin/env node
+import { resolve as m, dirname as R, relative as k } from "node:path";
+import { watch as j } from "node:fs";
+import { spawn as T } from "node:child_process";
+import { readFile as v, mkdtemp as A, writeFile as P, rm as N } from "node:fs/promises";
+import { tmpdir as _ } from "node:os";
+import { pathToFileURL as W } from "node:url";
+import b from "typescript";
+const D = (t, e) => {
+  let r, s = "pretty", n = !1, o = !1, i = !1, p = !1, c = e;
+  for (let u = 0; u < t.length; u += 1) {
+    const d = t[u];
+    if (d) {
+      if (d === "--help" || d === "-h") {
+        p = !0;
+        continue;
+      }
+      if (d === "--verbose") {
+        n = !0;
+        continue;
+      }
+      if (d === "--watch") {
+        o = !0;
+        continue;
+      }
+      if (d === "--fail-fast") {
+        i = !0;
+        continue;
+      }
+      if (d === "--format") {
+        const a = t[u + 1];
+        if (!a)
+          throw new Error("--format requires a value");
+        if (a !== "pretty" && a !== "json")
+          throw new Error('--format must be "pretty" or "json"');
+        s = a, u += 1;
+        continue;
+      }
+      if (d.startsWith("--format=")) {
+        const a = d.slice(9);
+        if (a !== "pretty" && a !== "json")
+          throw new Error('--format must be "pretty" or "json"');
+        s = a;
+        continue;
+      }
+      if (d === "--config") {
+        const a = t[u + 1];
+        if (!a)
+          throw new Error("--config requires a value");
+        r = a, u += 1;
+        continue;
+      }
+      if (d.startsWith("--config=")) {
+        r = d.slice(9);
+        continue;
+      }
+      if (d === "--cwd") {
+        const a = t[u + 1];
+        if (!a)
+          throw new Error("--cwd requires a value");
+        c = m(e, a), u += 1;
+        continue;
+      }
+      if (d.startsWith("--cwd=")) {
+        c = m(e, d.slice(6));
+        continue;
+      }
+      throw new Error(`Unknown argument: ${d}`);
+    }
+  }
+  return {
+    cwd: c,
+    configPath: r,
+    format: s,
+    verbose: n,
+    watch: o,
+    failFast: i,
+    help: p
+  };
+}, F = () => [
+  "Usage: ci-runner [options]",
+  "",
+  "Options:",
+  "  --config <path>     Config file path (default: ci.config.ts or ci.config.json)",
+  "  --format <type>     Output format: pretty | json (default: pretty)",
+  "  --verbose           Show stdout/stderr for successful steps",
+  "  --watch             Re-run on file changes",
+  "  --fail-fast         Stop after first non-optional failure",
+  "  --cwd <path>        Base working directory",
+  "  -h, --help          Show this help"
+].join(`
+`), B = () => async (t) => {
+  const e = Date.now();
+  return await new Promise((r) => {
+    const s = { ...process.env, ...t.env }, n = T(t.command, {
+      cwd: t.cwd,
+      env: s,
+      shell: !0,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let o = "", i = "", p = !1, c, u = !1;
+    const d = typeof t.timeoutMs == "number" && t.timeoutMs > 0 ? setTimeout(() => {
+      p = !0, n.kill("SIGTERM");
+    }, t.timeoutMs) : null;
+    n.stdout.on("data", (a) => {
+      o += a.toString("utf8");
+    }), n.stderr.on("data", (a) => {
+      i += a.toString("utf8");
+    }), n.on("error", (a) => {
+      c = a;
+    }), n.on("close", (a, w) => {
+      if (u)
+        return;
+      u = !0, d && clearTimeout(d);
+      const M = Date.now() - e;
+      r({
+        successful: !p && a === 0 && c === void 0,
+        timedOut: p,
+        durationMs: M,
+        exitCode: a,
+        signal: w,
+        stdout: o,
+        stderr: i,
+        error: c
+      });
+    });
+  });
+};
+class H {
+  parsers;
+  /**
+   * Creates a parser registry.
+   *
+   * @param parsers Initial parser list.
+   */
+  constructor(e = []) {
+    this.parsers = [...e];
+  }
+  /**
+   * Adds a parser to the registry.
+   *
+   * @param parser Parser instance.
+   */
+  register(e) {
+    this.parsers.push(e);
+  }
+  /**
+   * Parses output using the first matching parser that returns a metric.
+   *
+   * @param step Step definition.
+   * @param output Step output payload.
+   * @returns Parsed metric or null.
+   */
+  parse(e, r) {
+    for (const s of this.parsers) {
+      if (!s.matches(e))
+        continue;
+      const n = s.parse(r);
+      if (n)
+        return n;
+    }
+    return null;
+  }
+}
+const S = (t, e = 2) => JSON.stringify(t, null, e);
+class I {
+  options;
+  /**
+   * Creates a pipeline runner.
+   *
+   * @param options Runtime options.
+   */
+  constructor(e) {
+    this.options = {
+      ...e,
+      continueOnError: e.continueOnError ?? !0,
+      now: e.now ?? Date.now,
+      sleep: e.sleep ?? ((r) => new Promise((s) => {
+        setTimeout(s, r);
+      }))
+    };
+  }
+  /**
+   * Executes all configured pipeline steps.
+   *
+   * @returns Final pipeline result.
+   */
+  async run() {
+    const e = this.options.now(), r = [];
+    await this.emitPipelineStart();
+    for (const [p, c] of this.options.steps.entries()) {
+      await this.emitStepStart(c, p);
+      const u = await this.executeStep(c);
+      r.push(u), await this.emitStepComplete(u, p);
+      const d = u.status === "failed" || u.status === "timed_out";
+      if (!this.options.continueOnError && d)
+        break;
+    }
+    const s = this.options.now(), n = q(r, s - e), o = n.failed > 0 || n.timedOut > 0 ? 1 : 0, i = {
+      steps: r,
+      summary: n,
+      exitCode: o,
+      startedAt: e,
+      finishedAt: s
+    };
+    return await this.emitPipelineComplete(i), i;
+  }
+  async executeStep(e) {
+    const r = this.options.now(), s = V(e), n = { ...this.options.env, ...e.env };
+    let o = 0, i = null;
+    for (; o < s.maxAttempts; ) {
+      o += 1;
+      const c = await this.options.executor({
+        command: e.command,
+        cwd: e.cwd ?? this.options.cwd ?? process.cwd(),
+        env: n,
+        timeoutMs: e.timeoutMs
+      });
+      if (i = c, c.successful)
+        return this.buildStepResult({
+          step: e,
+          status: "passed",
+          reason: void 0,
+          attempts: o,
+          startedAt: r,
+          output: c
+        });
+      const u = c.timedOut, d = s.retryOnTimeout && u, a = !u;
+      if (o < s.maxAttempts && (a || d) && s.maxAttempts > 1) {
+        s.delayMs > 0 && await this.options.sleep(s.delayMs);
+        continue;
+      }
+      return this.buildFailedResult(e, o, r, c);
+    }
+    const p = z();
+    return this.buildStepResult({
+      step: e,
+      status: "failed",
+      reason: "command_failed",
+      attempts: o,
+      startedAt: r,
+      output: i ?? p
+    });
+  }
+  buildFailedResult(e, r, s, n) {
+    return e.optional ? this.buildStepResult({
+      step: e,
+      status: "skipped",
+      reason: "optional_step_failed",
+      attempts: r,
+      startedAt: s,
+      output: n
+    }) : n.timedOut ? this.buildStepResult({
+      step: e,
+      status: "timed_out",
+      reason: "command_timeout",
+      attempts: r,
+      startedAt: s,
+      output: n
+    }) : this.buildStepResult({
+      step: e,
+      status: "failed",
+      reason: "command_failed",
+      attempts: r,
+      startedAt: s,
+      output: n
+    });
+  }
+  buildStepResult(e) {
+    const r = this.options.now(), s = this.options.parserResolver?.parse(e.step, e.output) ?? null;
+    return {
+      id: e.step.id,
+      name: e.step.name,
+      status: e.status,
+      reason: e.reason,
+      attempts: e.attempts,
+      retried: e.attempts > 1,
+      startedAt: e.startedAt,
+      finishedAt: r,
+      durationMs: r - e.startedAt,
+      output: {
+        exitCode: e.output.exitCode,
+        signal: e.output.signal,
+        stdout: e.output.stdout,
+        stderr: e.output.stderr
+      },
+      metrics: s
+    };
+  }
+  async emitPipelineStart() {
+    const e = this.options.reporters ?? [];
+    for (const r of e)
+      await r.onPipelineStart?.(this.options.steps);
+  }
+  async emitStepStart(e, r) {
+    const s = this.options.reporters ?? [];
+    for (const n of s)
+      await n.onStepStart?.(e, r);
+  }
+  async emitStepComplete(e, r) {
+    const s = this.options.reporters ?? [];
+    for (const n of s)
+      await n.onStepComplete?.(e, r);
+  }
+  async emitPipelineComplete(e) {
+    const r = this.options.reporters ?? [];
+    for (const s of r)
+      await s.onPipelineComplete?.(e);
+  }
+}
+const L = (t) => new I(t), V = (t) => {
+  const e = Math.max(1, t.retry?.maxAttempts ?? 1), r = Math.max(0, t.retry?.delayMs ?? 0), s = t.retry?.retryOnTimeout ?? !1;
+  return {
+    maxAttempts: e,
+    delayMs: r,
+    retryOnTimeout: s
+  };
+}, q = (t, e) => {
+  const r = t.filter((i) => i.status === "passed").length, s = t.filter((i) => i.status === "failed").length, n = t.filter((i) => i.status === "skipped").length, o = t.filter((i) => i.status === "timed_out").length;
+  return {
+    total: t.length,
+    passed: r,
+    failed: s,
+    skipped: n,
+    timedOut: o,
+    durationMs: e
+  };
+}, z = () => ({
+  successful: !1,
+  timedOut: !1,
+  durationMs: 0,
+  exitCode: null,
+  signal: null,
+  stdout: "",
+  stderr: ""
+}), U = (t, e, r) => {
+  const s = t.cwd ? m(e, t.cwd) : e, n = { ...process.env, ...t.env }, o = [], i = [];
+  for (const c of t.steps) {
+    const u = J(c, n);
+    if (u) {
+      i.push({
+        id: c.id,
+        name: c.name,
+        reason: u.reason,
+        requiredEnv: u.requiredEnv
+      });
+      continue;
+    }
+    o.push(G(c, s));
+  }
+  const p = r ? !1 : t.continueOnError ?? !0;
+  return {
+    steps: o,
+    excludedSteps: i,
+    cwd: s,
+    env: n,
+    continueOnError: p
+  };
+}, G = (t, e) => ({
+  id: t.id,
+  name: t.name,
+  command: t.command,
+  cwd: t.cwd ? m(e, t.cwd) : e,
+  env: t.env,
+  optional: t.optional,
+  timeoutMs: t.timeoutMs,
+  retry: t.retry
+}), J = (t, e) => {
+  if (t.enabled === !1)
+    return { reason: "disabled" };
+  const r = t.when?.env;
+  if (!r)
+    return null;
+  const s = {};
+  for (const [n, o] of Object.entries(r))
+    e[n] !== o && (s[n] = o);
+  return Object.keys(s).length > 0 ? {
+    reason: "env_mismatch",
+    requiredEnv: s
+  } : null;
+}, K = async (t, e) => {
+  const r = await Q(t, e);
+  if (!r)
+    throw new Error("No config file found. Expected ci.config.ts or ci.config.json");
+  const s = await X(r);
+  return {
+    config: tt(s),
+    configFilePath: r
+  };
+}, Q = async (t, e) => {
+  if (e)
+    return m(t, e);
+  const r = [m(t, "ci.config.ts"), m(t, "ci.config.json")];
+  for (const s of r)
+    try {
+      return await v(s, "utf8"), s;
+    } catch {
+      continue;
+    }
+  return null;
+}, X = async (t) => {
+  if (t.endsWith(".json")) {
+    const e = await v(t, "utf8");
+    return JSON.parse(e);
+  }
+  if (t.endsWith(".ts"))
+    return await Y(t);
+  throw new Error(`Unsupported config extension: ${t}`);
+}, Y = async (t) => {
+  const e = await v(t, "utf8"), r = b.transpileModule(e, {
+    compilerOptions: {
+      module: b.ModuleKind.ESNext,
+      target: b.ScriptTarget.ES2022,
+      esModuleInterop: !0
+    },
+    fileName: t,
+    reportDiagnostics: !0
+  });
+  if (r.diagnostics && r.diagnostics.length > 0) {
+    const o = b.formatDiagnosticsWithColorAndContext(r.diagnostics, {
+      getCurrentDirectory: () => R(t),
+      getCanonicalFileName: (i) => i,
+      getNewLine: () => `
+`
+    });
+    throw new Error(`Failed to transpile ${t}
+${o}`);
+  }
+  const s = await A(m(_(), "ci-runner-config-")), n = m(s, "config.mjs");
+  try {
+    await P(n, r.outputText, "utf8");
+    const i = await import(`${W(n).href}?v=${Date.now()}`);
+    if (i.default !== void 0)
+      return Z(i.default);
+    if (i.config !== void 0)
+      return i.config;
+    throw new Error(`Config module ${t} must export default or named "config"`);
+  } finally {
+    await N(s, { recursive: !0, force: !0 });
+  }
+}, Z = (t) => f(t) && "default" in t ? t.default : t, tt = (t) => {
+  if (!f(t))
+    throw new Error("Config must be an object");
+  const e = t.steps;
+  if (!Array.isArray(e))
+    throw new Error("Config must provide a steps array");
+  const r = e.map(et), s = y(t.continueOnError, "continueOnError"), n = O(t.env, "env"), o = E(t.cwd, "cwd"), i = rt(t.output);
+  return {
+    steps: r,
+    continueOnError: s,
+    env: n,
+    cwd: o,
+    output: i
+  };
+}, et = (t, e) => {
+  if (!f(t))
+    throw new Error(`steps[${e}] must be an object`);
+  const r = $(t.id, `steps[${e}].id`), s = $(t.name, `steps[${e}].name`), n = $(t.command, `steps[${e}].command`), o = y(t.enabled, `steps[${e}].enabled`), i = E(t.cwd, `steps[${e}].cwd`), p = O(t.env, `steps[${e}].env`), c = y(t.optional, `steps[${e}].optional`), u = x(t.timeoutMs, `steps[${e}].timeoutMs`), d = st(t.retry, `steps[${e}].retry`), a = nt(t.when, `steps[${e}].when`);
+  return {
+    id: r,
+    name: s,
+    command: n,
+    enabled: o,
+    cwd: i,
+    env: p,
+    optional: c,
+    timeoutMs: u,
+    retry: d,
+    when: a
+  };
+}, rt = (t) => {
+  if (t === void 0)
+    return;
+  if (!f(t))
+    throw new Error("output must be an object");
+  const e = t.format;
+  if (e !== void 0 && e !== "pretty" && e !== "json")
+    throw new Error('output.format must be "pretty" or "json"');
+  const r = y(t.verbose, "output.verbose");
+  return {
+    format: e,
+    verbose: r
+  };
+}, st = (t, e) => {
+  if (t === void 0)
+    return;
+  if (!f(t))
+    throw new Error(`${e} must be an object`);
+  const r = ot(t.maxAttempts, `${e}.maxAttempts`), s = x(t.delayMs, `${e}.delayMs`), n = y(t.retryOnTimeout, `${e}.retryOnTimeout`);
+  return {
+    maxAttempts: r,
+    delayMs: s,
+    retryOnTimeout: n
+  };
+}, nt = (t, e) => {
+  if (t === void 0)
+    return;
+  if (!f(t))
+    throw new Error(`${e} must be an object`);
+  return {
+    env: O(t.env, `${e}.env`)
+  };
+}, $ = (t, e) => {
+  if (typeof t != "string" || t.length === 0)
+    throw new Error(`${e} must be a non-empty string`);
+  return t;
+}, ot = (t, e) => {
+  if (typeof t != "number" || Number.isNaN(t))
+    throw new Error(`${e} must be a valid number`);
+  return t;
+}, E = (t, e) => {
+  if (t !== void 0) {
+    if (typeof t != "string")
+      throw new Error(`${e} must be a string`);
+    return t;
+  }
+}, x = (t, e) => {
+  if (t !== void 0) {
+    if (typeof t != "number" || Number.isNaN(t))
+      throw new Error(`${e} must be a valid number`);
+    return t;
+  }
+}, y = (t, e) => {
+  if (t !== void 0) {
+    if (typeof t != "boolean")
+      throw new Error(`${e} must be a boolean`);
+    return t;
+  }
+}, O = (t, e) => {
+  if (t === void 0)
+    return;
+  if (!f(t))
+    throw new Error(`${e} must be an object`);
+  const r = Object.entries(t), s = {};
+  for (const [n, o] of r) {
+    if (typeof o != "string")
+      throw new Error(`${e}.${n} must be a string`);
+    s[n] = o;
+  }
+  return s;
+}, f = (t) => typeof t == "object" && t !== null && !Array.isArray(t), it = () => [
+  {
+    id: "vitest-summary-parser",
+    matches: (t) => h(t, "vitest"),
+    parse: (t) => {
+      const r = g(`${t.stdout}
+${t.stderr}`).match(/\bTests?\s+(\d+)\s+passed\b/i);
+      return r ? {
+        label: "tests_passed",
+        value: Number(r[1])
+      } : null;
+    }
+  },
+  {
+    id: "playwright-summary-parser",
+    matches: (t) => h(t, "playwright") || h(t, "e2e"),
+    parse: (t) => {
+      const r = g(`${t.stdout}
+${t.stderr}`).match(/^\s*(\d+)\s+passed(?:\s|\()/im);
+      return r ? {
+        label: "tests_passed",
+        value: Number(r[1])
+      } : null;
+    }
+  },
+  {
+    id: "generic-tests-parser",
+    matches: (t) => h(t, "test"),
+    parse: (t) => {
+      const r = g(`${t.stdout}
+${t.stderr}`).match(/(^|\s)(\d+)\s+passed(\s|$)/i);
+      return r ? {
+        label: "tests_passed",
+        value: Number(r[2])
+      } : null;
+    }
+  },
+  {
+    id: "lint-warning-summary-parser",
+    matches: (t) => h(t, "lint"),
+    parse: (t) => {
+      const e = g(`${t.stdout}
+${t.stderr}`), r = ct(e);
+      return r === null ? null : {
+        label: "warnings",
+        value: r
+      };
+    }
+  },
+  {
+    id: "workspace-task-summary-parser",
+    matches: () => !0,
+    parse: (t) => {
+      const e = g(`${t.stdout}
+${t.stderr}`);
+      return at(e);
+    }
+  }
+], at = (t) => {
+  const e = t.match(/Tasks:\s*\d+\s+\w+,\s*(\d+)\s+total/i);
+  if (e)
+    return {
+      label: "tasks",
+      value: Number(e[1])
+    };
+  const r = t.match(
+    /Scope:\s*(?:all\s+)?(\d+)(?:\s+of\s+\d+)?\s+workspace\s+projects?/i
+  );
+  if (r)
+    return {
+      label: "tasks",
+      value: Number(r[1])
+    };
+  const s = t.match(/Successfully ran target .* for (\d+) projects?/i);
+  if (s)
+    return {
+      label: "tasks",
+      value: Number(s[1])
+    };
+  const n = ut(t);
+  return n.length > 0 ? {
+    label: "tasks",
+    value: n.length
+  } : null;
+}, ct = (t) => {
+  const e = [
+    ...t.matchAll(/✖\s+\d+\s+problems?\s+\(\s*\d+\s+errors?,\s*(\d+)\s+warnings?\s*\)/gi)
+  ];
+  return e.length === 0 ? null : e.reduce((s, n) => {
+    const o = n[1];
+    return o ? s + Number(o) : s;
+  }, 0);
+}, ut = (t) => {
+  const r = (t.match(/(^|\n)(?!\s*[|│])([^\n$]+?\s+[a-z0-9:_-]+\$\s[^\n]*)/gi) ?? []).map((s) => s.replace(/^\s+/, "").trim()).map((s) => s.replace(/\s+/g, " "));
+  return [...new Set(r)];
+}, h = (t, e) => `${t.id} ${t.name} ${t.command}`.toLowerCase().includes(e), g = (t) => t.replace(/\x1b\[[0-9;]*m/g, "");
+class dt {
+  options;
+  /**
+   * Creates a pretty reporter.
+   *
+   * @param options Reporter options.
+   */
+  constructor(e) {
+    this.options = e;
+  }
+  /**
+   * Handles pipeline start.
+   *
+   * @param steps Pipeline steps.
+   */
+  onPipelineStart(e) {
+    process.stdout.write(l(`ci-runner: executing ${e.length} steps
+`, "blue"));
+  }
+  /**
+   * Handles step start.
+   *
+   * @param step Current step.
+   */
+  onStepStart(e) {
+    process.stdout.write(l(`-> ${e.name}
+`, "blue"));
+  }
+  /**
+   * Handles step completion.
+   *
+   * @param result Step result.
+   */
+  onStepComplete(e) {
+    const r = `${e.durationMs}ms`;
+    if (e.status === "passed") {
+      const s = e.metrics && typeof e.metrics.value == "number" ? ` (${e.metrics.value} ${e.metrics.label})` : "";
+      process.stdout.write(l(`✓ ${e.name} ${r}${s}
+`, "green")), this.options.verbose && this.printOutput(e);
+      return;
+    }
+    if (e.status === "skipped") {
+      process.stdout.write(
+        l(
+          `ℹ ${e.name} skipped (${e.reason ?? "no reason"}, ${r})
+`,
+          "yellow"
+        )
+      );
+      const s = pt(e);
+      if (s) {
+        process.stdout.write(l(`  note: missing script "${s}"
+`, "yellow")), this.options.verbose && this.printOutput(e);
+        return;
+      }
+      this.printOutput(e);
+      return;
+    }
+    process.stdout.write(
+      l(
+        `✗ ${e.name} ${e.status} (${e.reason ?? "no reason"}, ${r})
+`,
+        "red"
+      )
+    ), this.printOutput(e);
+  }
+  /**
+   * Handles pipeline completion.
+   *
+   * @param result Pipeline result.
+   */
+  onPipelineComplete(e) {
+    const r = e.summary;
+    if (process.stdout.write(`
+`), process.stdout.write(
+      `Summary: total=${r.total} passed=${r.passed} skipped=${r.skipped} failed=${r.failed} timedOut=${r.timedOut} duration=${r.durationMs}ms
+`
+    ), e.exitCode === 0) {
+      process.stdout.write(l(`Result: ✅ PASS
+`, "green"));
+      return;
+    }
+    process.stdout.write(l(`Result: FAIL
+`, "red"));
+  }
+  printOutput(e) {
+    const r = e.output.stdout.trim(), s = e.output.stderr.trim();
+    r && (process.stdout.write(l(`  stdout:
+`, "yellow")), process.stdout.write(C(r)), process.stdout.write(`
+`)), s && (process.stdout.write(l(`  stderr:
+`, "yellow")), process.stdout.write(C(s)), process.stdout.write(`
+`));
+  }
+}
+const C = (t) => t.split(`
+`).map((e) => `    ${e}`).join(`
+`), l = (t, e) => `${{
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m"
+}[e]}${t}\x1B[0m`, pt = (t) => {
+  const r = `${t.output.stdout}
+${t.output.stderr}`.match(/Missing script:\s*"?([a-z0-9:_-]+)"?/i);
+  return !r || !r[1] ? null : r[1];
+}, lt = async (t) => {
+  const e = await K(t.cwd, t.configPath), r = e.config.output?.format ?? t.format, s = e.config.output?.verbose ?? t.verbose, n = async () => {
+    const o = U(e.config, t.cwd, t.failFast);
+    mt(o.excludedSteps, r);
+    const i = new H(it());
+    return await L({
+      ...o,
+      executor: B(),
+      parserResolver: i,
+      reporters: r === "pretty" ? [new dt({ verbose: s })] : []
+    }).run();
+  };
+  if (!t.watch) {
+    const o = await n();
+    return r === "json" && process.stdout.write(`${S(o)}
+`), o.exitCode;
+  }
+  return await wt(t.cwd, e.configFilePath, r, n);
+}, mt = (t, e) => {
+  if (!(e !== "pretty" || t.length === 0))
+    for (const r of t) {
+      if (r.reason === "disabled") {
+        process.stdout.write(`ℹ️  Skipping ${r.name} (enabled=false)
+`);
+        continue;
+      }
+      if (r.reason === "env_mismatch" && r.requiredEnv) {
+        process.stdout.write(
+          `ℹ️  Skipping ${r.name} (set ${ft(r.requiredEnv)} to enable)
+`
+        );
+        continue;
+      }
+      process.stdout.write(`ℹ️  Skipping ${r.name}
+`);
+    }
+}, ft = (t) => Object.entries(t).sort(([e], [r]) => e.localeCompare(r)).map(([e, r]) => `${e}=${r}`).join(" "), wt = async (t, e, r, s) => {
+  const n = await s();
+  r === "json" && process.stdout.write(`${S(n)}
+`), process.stdout.write(`Watch mode enabled. Waiting for file changes...
+`);
+  let o = n.exitCode, i = !1, p = !1, c = null;
+  const u = async () => {
+    if (i) {
+      p = !0;
+      return;
+    }
+    i = !0;
+    try {
+      do {
+        p = !1;
+        const a = await s();
+        o = a.exitCode, r === "json" && process.stdout.write(`${S(a)}
+`);
+      } while (p);
+    } finally {
+      i = !1;
+    }
+  }, d = ht(t, e, () => {
+    c && clearTimeout(c), c = setTimeout(() => {
+      u();
+    }, 250);
+  });
+  return await new Promise((a) => {
+    const w = () => {
+      d.close(), c && clearTimeout(c), a();
+    };
+    process.on("SIGINT", w), process.on("SIGTERM", w);
+  }), o;
+}, ht = (t, e, r) => {
+  const s = ["node_modules", ".git", "dist", "coverage", "out", "build", ".tmp"];
+  try {
+    const n = j(t, { recursive: !0 }, (o, i) => {
+      if (!i)
+        return;
+      const p = i.toString();
+      if (gt(p, s))
+        return;
+      const c = k(t, e), u = p === c ? `${p} (config)` : p;
+      process.stdout.write(`
+Change detected: ${u}
+`), r();
+    });
+    return {
+      close: () => n.close()
+    };
+  } catch {
+    return process.stdout.write(
+      `Watch mode is not supported recursively on this platform. Running once without watch.
+`
+    ), {
+      close: () => {
+      }
+    };
+  }
+}, gt = (t, e) => e.some((r) => t === r || t.startsWith(`${r}/`)), yt = async () => {
+  const t = D(process.argv.slice(2), process.cwd());
+  if (t.help) {
+    process.stdout.write(`${F()}
+`), process.exitCode = 0;
+    return;
+  }
+  const e = await lt(t);
+  process.exitCode = e;
+};
+yt().catch((t) => {
+  const e = t instanceof Error ? `${t.name}: ${t.message}` : String(t);
+  process.stderr.write(`${e}
+`), process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map