@ninhache/probe 0.1.2 → 0.3.0

package/dist/cli.js

@@ -1,40 +1,53 @@
 #!/usr/bin/env node
+import { createRequire as __createRequire } from "node:module";
+const require = __createRequire(import.meta.url);
+import {
+  BACKUP_GLOB,
+  CONFIG_FILE,
+  DASHBOARD_INTERVAL_SECONDS,
+  DEFAULT_MAKEFILE,
+  DEFAULT_TIMEOUT_SECONDS,
+  DEFAULT_WAIT_INTERVAL_SECONDS,
+  DEFAULT_WAIT_MAX_INTERVAL_SECONDS,
+  DEFAULT_WAIT_TIMEOUT_SECONDS,
+  EXIT_DOWN,
+  EXIT_ERROR,
+  LOCAL_DRAFT_FILE,
+  LOCAL_FILE,
+  LOCAL_FILE_MODE,
+  LOCK_FILE,
+  MAX_TIMEOUT_SECONDS,
+  PACKAGE_NAME,
+  PROBE_DIR,
+  ProbeError,
+  REFRESH_COMMAND,
+  REGISTRY_LATEST_URL,
+  REGISTRY_TIMEOUT_MS,
+  UPDATE_CACHE_FILE,
+  UPDATE_CHECK_TTL_MS,
+  WAIT_BACKOFF_FACTOR,
+  WAIT_LAST_PASS_MS,
+  createColors,
+  detectTerminal,
+  formatCheckResults,
+  formatServices,
+  isInteractive,
+  runChecks,
+  stripStyles
+} from "./chunk-ZCAUPLQS.js";
+import "./chunk-M3ASEG5F.js";
 
 // src/cli.ts
-import { defineCommand as defineCommand9, runCommand, runMain, showUsage } from "citty";
+import {
+  defineCommand as defineCommand10,
+  renderUsage,
+  runCommand,
+  runMain
+} from "citty";
 
 // src/commands/add.ts
 import { defineCommand } from "citty";
 
-// src/constants.ts
-var PACKAGE_NAME = "@ninhache/probe";
-var PROBE_DIR = ".probe";
-var CONFIG_FILE = "config.yml";
-var LOCK_FILE = "lock.yml";
-var LOCAL_FILE = "local.yml";
-var BACKUP_GLOB = "*.bak.yml";
-var DEFAULT_MAKEFILE = "Makefile";
-var DEFAULT_CHECKER_TYPE = "http";
-var DEFAULT_TIMEOUT_SECONDS = 3;
-var REGISTRY_LATEST_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
-var REGISTRY_TIMEOUT_MS = 5e3;
-var UPDATE_CHECK_TTL_MS = 24 * 60 * 60 * 1e3;
-var UPDATE_CACHE_FILE = "latest.json";
-var REFRESH_COMMAND = "__refresh-update-cache";
-var EXIT_DOWN = 1;
-var EXIT_ERROR = 2;
-
-// src/errors.ts
-var ProbeError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "ProbeError";
-  }
-  code;
-  exitCode = EXIT_ERROR;
-};
-
 // src/config/discovery.ts
 import { statSync } from "fs";
 import { dirname, join, resolve } from "path";
@@ -292,7 +305,7 @@ async function writeLock(paths, lock) {
 }
 
 // src/version.ts
-var CLI_VERSION = true ? "0.1.2" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.3.0" : "0.0.0-dev";
 
 // src/makefile/generator.ts
 import { createHash } from "crypto";
@@ -382,35 +395,34 @@ async function blockState(paths, config) {
   return lock?.makefile.hash === hashBlock(block) ? "outdated" : "modified";
 }
 
-// src/ui/colors.ts
-function colorEnabled(stream, env) {
-  return Boolean(stream.isTTY) && !env.NO_COLOR;
-}
-function createColors(enabled) {
-  const wrap = (open, close) => (text) => enabled ? `\x1B[${open}m${text}\x1B[${close}m` : text;
-  return {
-    green: wrap(32, 39),
-    red: wrap(31, 39),
-    yellow: wrap(33, 39),
-    dim: wrap(2, 22),
-    bold: wrap(1, 22)
-  };
-}
-
 // src/commands/shared.ts
 function openProject() {
   return loadConfig(requireProbeDir(process.cwd()));
 }
+function stdoutTerminal() {
+  return detectTerminal(process.stdout, process.env);
+}
 function stdoutColors() {
-  return createColors(colorEnabled(process.stdout, process.env));
+  return createColors(stdoutTerminal().color);
+}
+function secondsToMs(option, value) {
+  const seconds2 = Number(value);
+  if (!Number.isFinite(seconds2) || seconds2 <= 0 || seconds2 > MAX_TIMEOUT_SECONDS) {
+    throw new ProbeError(
+      "USAGE",
+      `${option} expects seconds between 0 and ${MAX_TIMEOUT_SECONDS}, got "${value}".`
+    );
+  }
+  return Math.ceil(seconds2 * 1e3);
 }
 function rawServices(loaded) {
   return loaded.raw.services ?? {};
 }
 async function saveServices(loaded, services) {
-  const edited = await blockState(loaded.paths, loaded.config) === "modified";
+  const block = await blockState(loaded.paths, loaded.config);
   const saved = await saveConfig(loaded, { ...loaded.raw, services });
-  if (!edited) {
+  if (block === "missing") return;
+  if (block !== "modified") {
     await syncMakefile(saved.paths, saved.config);
     return;
   }
@@ -460,121 +472,111 @@ var add_default = defineCommand({
 // src/commands/check.ts
 import { defineCommand as defineCommand2 } from "citty";
 
-// src/checkers/http.ts
-var REASONS = {
-  ECONNREFUSED: "connection refused",
-  ECONNRESET: "connection reset",
-  ENOTFOUND: "host not found",
-  EAI_AGAIN: "host not found",
-  EHOSTUNREACH: "host unreachable"
-};
-function targetUrl(service) {
-  const bareIpv6 = service.host.includes(":") && !service.host.startsWith("[");
-  const host = bareIpv6 ? `[${service.host}]` : service.host;
-  return `http://${host}:${service.port}${service.path}`;
-}
-function isExpected(expect, status) {
-  if (expect === void 0) return status >= 200 && status < 300;
-  return Array.isArray(expect) ? expect.includes(status) : expect === status;
-}
-function expectsRedirect(expect) {
-  return [expect ?? []].flat().some((status) => status >= 300 && status < 400);
-}
-function describeExpected(expect) {
-  if (expect === void 0) return "2xx";
-  return Array.isArray(expect) ? expect.join(" or ") : String(expect);
-}
-function failureReason(error, timeoutMs) {
-  if (error instanceof Error && error.name === "TimeoutError") {
-    return `timeout after ${timeoutMs / 1e3}s`;
-  }
-  const cause = error?.cause;
-  const code = cause?.code ?? cause?.errors?.[0]?.code;
-  if (code) return REASONS[code] ?? code;
-  return error instanceof Error ? error.message : String(error);
-}
-var httpChecker = {
-  type: "http",
-  async check(name, service, { timeoutMs }) {
-    const target = targetUrl(service);
-    const base = { name, type: "http", target };
-    const started = performance.now();
-    const elapsed = () => Math.round(performance.now() - started);
-    try {
-      const response = await fetch(target, {
-        signal: AbortSignal.timeout(timeoutMs),
-        // Following a redirect hides its status: an expected 3xx could never match.
-        redirect: expectsRedirect(service.expect) ? "manual" : "follow"
-      });
-      const latencyMs = elapsed();
-      await response.body?.cancel();
-      const { status } = response;
-      if (isExpected(service.expect, status)) return { ...base, ok: true, status, latencyMs };
-      const error = `expected ${describeExpected(service.expect)}, got ${status}`;
-      return { ...base, ok: false, status, latencyMs, error };
-    } catch (error) {
-      return { ...base, ok: false, latencyMs: elapsed(), error: failureReason(error, timeoutMs) };
-    }
+// src/config/local.ts
+import { chmod, readFile as readFile4, realpath, rename, rm, stat, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname2, join as join4 } from "path";
+import { isMap as isMap2, isScalar as isScalar2, parseDocument as parseDocument2 } from "yaml";
+var SECTION = "dashboard";
+var KEYS = ["interval", "timeout"];
+var SERVICES = "services";
+var SKIP = "skip";
+function isDelay(value) {
+  return typeof value === "number" && value > 0 && value <= MAX_TIMEOUT_SECONDS;
+}
+async function readLocal(paths) {
+  try {
+    return await readFile4(paths.local, "utf8");
+  } catch {
+    return null;
   }
-};
-
-// src/checkers/registry.ts
-var checkers = new Map([httpChecker].map((checker) => [checker.type, checker]));
-function getChecker(type) {
-  const checker = checkers.get(type);
-  if (!checker) {
-    const known = [...checkers.keys()].join(", ");
-    throw new ProbeError("CHECKER_UNKNOWN", `unknown service type "${type}". Known: ${known}.`);
+}
+async function readDashboardPreferences(paths) {
+  const text = await readLocal(paths);
+  if (text === null) return {};
+  const doc = parseDocument2(text);
+  if (doc.errors.length > 0) return {};
+  const preferences = {};
+  for (const key of KEYS) {
+    const value = doc.getIn([SECTION, key]);
+    if (isDelay(value)) preferences[key] = value;
   }
-  return checker;
+  return preferences;
 }
-
-// src/checkers/run.ts
-async function runChecks(config, names, context) {
-  const known = Object.keys(config.services);
-  const unknown = names.filter((name) => !known.includes(name));
-  if (unknown.length > 0) {
-    throw new ProbeError(
-      "SERVICE_UNKNOWN",
-      `unknown service: ${unknown.join(", ")}. Known: ${known.join(", ") || "(none)"}.`
-    );
+function initialDashboardSettings(askedIntervalMs, saved) {
+  return {
+    intervalMs: askedIntervalMs ?? (saved.interval ?? DASHBOARD_INTERVAL_SECONDS) * 1e3,
+    timeoutMs: (saved.timeout ?? DEFAULT_TIMEOUT_SECONDS) * 1e3
+  };
+}
+function changedPreferences(previous, next) {
+  const changed = {};
+  if (next.intervalMs !== previous.intervalMs) changed.interval = next.intervalMs / 1e3;
+  if (next.timeoutMs !== previous.timeoutMs) changed.timeout = next.timeoutMs / 1e3;
+  return changed;
+}
+async function editLocal(paths, edit) {
+  const doc = parseDocument2(await readLocal(paths) ?? "");
+  if (doc.errors.length > 0) return false;
+  if (doc.contents !== null && !isMap2(doc.contents)) return false;
+  const outcome = edit(doc);
+  if (outcome !== true) return outcome === null;
+  const { contents } = doc;
+  const empty = isMap2(contents) && contents.items.length === 0 && !contents.comment;
+  const text = empty && !doc.comment && !doc.commentBefore ? "" : doc.toString();
+  const target = await realpath(paths.local).catch(() => paths.local);
+  const existing = await stat(target).catch(() => null);
+  const mode = existing ? existing.mode & 511 : LOCAL_FILE_MODE;
+  const draft = join4(dirname2(target), LOCAL_DRAFT_FILE);
+  try {
+    await writeFile4(draft, text, { mode });
+    await chmod(draft, mode);
+    await rename(draft, target);
+  } catch (error) {
+    await rm(draft, { force: true });
+    throw error;
   }
-  const selected = names.length > 0 ? [...new Set(names)] : known;
-  return Promise.all(
-    selected.map((name) => {
-      const service = config.services[name];
-      const type = service.type ?? DEFAULT_CHECKER_TYPE;
-      return getChecker(type).check(name, service, context);
-    })
-  );
+  return true;
+}
+function writeDashboardPreferences(paths, preferences) {
+  return editLocal(paths, (doc) => {
+    const section = doc.get(SECTION, true);
+    if (section !== void 0 && !isMap2(section)) return false;
+    for (const key of KEYS) {
+      if (preferences[key] !== void 0) doc.setIn([SECTION, key], preferences[key]);
+    }
+    return true;
+  });
 }
-
-// src/ui/report.ts
-function width(values) {
-  return Math.max(0, ...values.map((value) => value.length));
-}
-function formatCheckResults(results, colors) {
-  const nameWidth = width(results.map((result) => result.name));
-  const targetWidth = width(results.map((result) => result.target));
-  return results.map((result) => {
-    const mark = result.ok ? colors.green("\u2713") : colors.red("\u2717");
-    const name = colors.bold(result.name.padEnd(nameWidth));
-    const target = colors.dim(result.target.padEnd(targetWidth));
-    const outcome = result.ok ? `${colors.green(String(result.status))}  ${colors.dim(`${result.latencyMs}ms`)}` : colors.red(result.error ?? "down");
-    return `${mark} ${name}  ${target}  ${outcome}`;
-  }).join("\n");
-}
-function formatServices(config, colors) {
-  const entries = Object.entries(config.services);
-  const nameWidth = width(entries.map(([name]) => name));
-  return entries.map(([name, service]) => {
-    const expect = service.expect === void 0 ? "" : colors.dim(`  expect ${service.expect}`);
-    return `${colors.bold(name.padEnd(nameWidth))}  ${targetUrl(service)}${expect}`;
-  }).join("\n");
+async function readSkippedServices(paths) {
+  const text = await readLocal(paths);
+  if (text === null) return /* @__PURE__ */ new Set();
+  const doc = parseDocument2(text);
+  if (doc.errors.length > 0) return /* @__PURE__ */ new Set();
+  const services = doc.get(SERVICES, true);
+  if (!isMap2(services)) return /* @__PURE__ */ new Set();
+  const names = services.items.filter((pair) => isMap2(pair.value) && pair.value.get(SKIP) === true).map((pair) => String(isScalar2(pair.key) ? pair.key.value : pair.key));
+  return new Set(names);
+}
+function writeServiceSkip(paths, name, skip) {
+  return editLocal(paths, (doc) => {
+    const services = doc.get(SERVICES, true);
+    if (services !== void 0 && !isMap2(services)) return false;
+    const entry = services?.get(name, true);
+    if (entry !== void 0 && !isMap2(entry)) return false;
+    if (skip) {
+      if (entry?.get(SKIP) === true) return null;
+      doc.setIn([SERVICES, name, SKIP], true);
+      return true;
+    }
+    if (!services || !entry?.has(SKIP)) return null;
+    entry.delete(SKIP);
+    if (entry.items.length === 0) services.delete(name);
+    if (services.items.length === 0) doc.delete(SERVICES);
+    return true;
+  });
 }
 
 // src/commands/check.ts
-var MAX_TIMEOUT_SECONDS = 2147483;
 var check_default = defineCommand2({
   meta: { name: "check", description: "Check that services respond (all of them by default)" },
   args: {
@@ -586,21 +588,16 @@ var check_default = defineCommand2({
     }
   },
   async run({ args }) {
-    const seconds = Number(args.timeout);
-    if (!Number.isFinite(seconds) || seconds <= 0 || seconds > MAX_TIMEOUT_SECONDS) {
-      throw new ProbeError(
-        "USAGE",
-        `--timeout expects seconds between 0 and ${MAX_TIMEOUT_SECONDS}, got "${args.timeout}".`
-      );
-    }
-    const { config } = await openProject();
-    const results = await runChecks(config, args._, { timeoutMs: Math.ceil(seconds * 1e3) });
+    const timeoutMs = secondsToMs("--timeout", args.timeout);
+    const { config, paths } = await openProject();
+    const skipped = await readSkippedServices(paths);
+    const results = await runChecks(config, args._, { timeoutMs }, skipped);
     if (args.json) {
       console.log(JSON.stringify(results, null, 2));
     } else if (results.length === 0) {
       console.log("No services yet. Add one: probe add api -p 3000");
     } else {
-      console.log(formatCheckResults(results, stdoutColors()));
+      console.log(formatCheckResults(results, stdoutTerminal()));
     }
     if (results.some((result) => !result.ok)) process.exitCode = EXIT_DOWN;
   }
@@ -608,8 +605,8 @@ var check_default = defineCommand2({
 
 // src/commands/init.ts
 import { existsSync } from "fs";
-import { mkdir, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import { join as join4 } from "path";
+import { mkdir, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { join as join5 } from "path";
 import { defineCommand as defineCommand3 } from "citty";
 var IGNORED = [`${PROBE_DIR}/${LOCAL_FILE}`, `${PROBE_DIR}/${BACKUP_GLOB}`];
 var INITIAL_CONFIG = `# probe - local services to health-check. Edit by hand or with \`probe add\`.
@@ -617,19 +614,19 @@ schemaVersion: ${CURRENT_SCHEMA_VERSION}
 services: {}
 `;
 async function ignoreLocalFiles(root) {
-  const file = join4(root, ".gitignore");
-  const current = existsSync(file) ? await readFile4(file, "utf8") : "";
+  const file = join5(root, ".gitignore");
+  const current = existsSync(file) ? await readFile5(file, "utf8") : "";
   const lines = current.split("\n").map((line) => line.trim());
   const missing = IGNORED.filter((entry) => !lines.includes(entry));
   if (missing.length === 0) return;
   const separator = current === "" || current.endsWith("\n") ? "" : "\n";
-  await writeFile4(file, `${current}${separator}${missing.join("\n")}
+  await writeFile5(file, `${current}${separator}${missing.join("\n")}
 `);
 }
 var init_default = defineCommand3({
   meta: {
     name: "init",
-    description: "Create .probe/, the .gitignore entries and the Makefile block"
+    description: "Create .probe/ and the .gitignore entries"
   },
   async run() {
     const paths = pathsFor(process.cwd());
@@ -637,11 +634,9 @@ var init_default = defineCommand3({
       throw new ProbeError("ALREADY_INITIALIZED", `${PROBE_DIR}/ already exists here.`);
     }
     await mkdir(paths.dir);
-    await writeFile4(paths.config, INITIAL_CONFIG);
+    await writeFile5(paths.config, INITIAL_CONFIG);
     await ignoreLocalFiles(paths.root);
-    const { config } = await loadConfig(paths);
-    await syncMakefile(paths, config);
-    console.log(`Created ${PROBE_DIR}/ and the Makefile block. Next: probe add api -p 3000`);
+    console.log(`Created ${PROBE_DIR}/. Next: probe add api -p 3000`);
   }
 });
 
@@ -650,12 +645,12 @@ import { defineCommand as defineCommand4 } from "citty";
 var ls_default = defineCommand4({
   meta: { name: "ls", description: "List services" },
   async run() {
-    const { config } = await openProject();
+    const { config, paths } = await openProject();
     if (Object.keys(config.services).length === 0) {
       console.log("No services yet. Add one: probe add api -p 3000");
       return;
     }
-    console.log(formatServices(config, stdoutColors()));
+    console.log(formatServices(config, stdoutTerminal(), await readSkippedServices(paths)));
   }
 });
 
@@ -699,16 +694,16 @@ import { defineCommand as defineCommand7 } from "citty";
 import { spawn } from "child_process";
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 function cacheDir(env = process.env) {
-  return join5(env.XDG_CACHE_HOME || join5(homedir(), ".cache"), "probe");
+  return join6(env.XDG_CACHE_HOME || join6(homedir(), ".cache"), "probe");
 }
 function updateCheckDisabled(env = process.env) {
   return env.PROBE_NO_UPDATE_CHECK === "1" || Boolean(env.CI);
 }
 function readCache(dir) {
   try {
-    const cache = JSON.parse(readFileSync(join5(dir, UPDATE_CACHE_FILE), "utf8"));
+    const cache = JSON.parse(readFileSync(join6(dir, UPDATE_CACHE_FILE), "utf8"));
     return typeof cache.checkedAt === "number" ? cache : null;
   } catch {
     return null;
@@ -716,7 +711,7 @@ function readCache(dir) {
 }
 function writeCache(dir, cache) {
   mkdirSync(dir, { recursive: true });
-  writeFileSync(join5(dir, UPDATE_CACHE_FILE), JSON.stringify(cache));
+  writeFileSync(join6(dir, UPDATE_CACHE_FILE), JSON.stringify(cache));
 }
 function isNewer(latest, current) {
   const parse2 = (version) => (version.split("-")[0] ?? "").split(".").map(Number);
@@ -772,7 +767,7 @@ function describeBlock(state, colors) {
     case "outdated":
       return colors.yellow("out of date \u2192 run `probe sync`");
     case "missing":
-      return colors.yellow("no probe block \u2192 run `probe sync`");
+      return colors.dim("no probe block (optional) \u2192 `probe sync` adds one");
   }
 }
 function describeUpdate(colors) {
@@ -806,7 +801,10 @@ var status_default = defineCommand7({
 import { relative as relative2 } from "path";
 import { defineCommand as defineCommand8 } from "citty";
 var sync_default = defineCommand8({
-  meta: { name: "sync", description: "Regenerate the probe block of the Makefile" },
+  meta: {
+    name: "sync",
+    description: "Add or regenerate the probe block of the Makefile (optional)"
+  },
   async run() {
     const { config, paths } = await openProject();
     const { created, changed } = await syncMakefile(paths, config);
@@ -817,42 +815,219 @@ var sync_default = defineCommand8({
   }
 });
 
+// src/commands/wait.ts
+import { defineCommand as defineCommand9 } from "citty";
+
+// src/checkers/poll.ts
+import { setTimeout as delay } from "timers/promises";
+async function pollUntilUp(check, options) {
+  const { deadlineMs, attemptTimeoutMs, maxIntervalMs, onPass } = options;
+  const now = options.now ?? (() => performance.now());
+  const sleep = options.sleep ?? delay;
+  const started = now();
+  const remaining = () => deadlineMs - (now() - started);
+  let pause = Math.min(options.intervalMs, maxIntervalMs);
+  let lastPass = false;
+  while (true) {
+    const results = await check(Math.max(1, Math.ceil(Math.min(attemptTimeoutMs, remaining()))));
+    const elapsedMs = Math.round(now() - started);
+    onPass?.(results, elapsedMs);
+    if (results.every((result) => result.ok)) return { results, elapsedMs, timedOut: false };
+    const left = remaining();
+    if (lastPass || left <= 0) return { results, elapsedMs, timedOut: true };
+    if (pause >= left) {
+      lastPass = true;
+      await sleep(left - Math.min(WAIT_LAST_PASS_MS, left / 2));
+    } else {
+      await sleep(pause);
+      pause = Math.min(pause * WAIT_BACKOFF_FACTOR, maxIntervalMs);
+    }
+  }
+}
+
+// src/commands/wait.ts
+var seconds = (ms) => `${(ms / 1e3).toFixed(1)}s`;
+function progressReporter() {
+  let previous = null;
+  return (results, elapsedMs) => {
+    const lines = [];
+    if (previous === null) {
+      const down = results.filter((result) => !result.ok).map((result) => result.name);
+      if (down.length > 0) lines.push(`waiting for ${down.join(", ")}`);
+    } else {
+      for (const { name, ok } of results) {
+        if (previous.get(name) === ok) continue;
+        lines.push(ok ? `${name} up after ${seconds(elapsedMs)}` : `${name} down again`);
+      }
+    }
+    previous = new Map(results.map((result) => [result.name, result.ok]));
+    return lines;
+  };
+}
+var wait_default = defineCommand9({
+  meta: {
+    name: "wait",
+    description: "Check again and again until services are up (all of them by default)"
+  },
+  args: {
+    json: { type: "boolean", description: "Print the final results as JSON" },
+    timeout: {
+      type: "string",
+      description: "Seconds to wait in total, all checks included, before giving up",
+      default: String(DEFAULT_WAIT_TIMEOUT_SECONDS)
+    },
+    interval: {
+      type: "string",
+      description: "Seconds before the second check; the pause then doubles after each check",
+      default: String(DEFAULT_WAIT_INTERVAL_SECONDS)
+    },
+    "max-interval": {
+      type: "string",
+      description: "Longest pause between two checks, in seconds",
+      default: String(DEFAULT_WAIT_MAX_INTERVAL_SECONDS)
+    }
+  },
+  async run({ args }) {
+    const deadlineMs = secondsToMs("--timeout", args.timeout);
+    const intervalMs = secondsToMs("--interval", args.interval);
+    const maxIntervalMs = secondsToMs("--max-interval", args["max-interval"]);
+    if (intervalMs > maxIntervalMs) {
+      throw new ProbeError(
+        "USAGE",
+        `--interval (${args.interval}s) cannot be longer than --max-interval (${args["max-interval"]}s).`
+      );
+    }
+    const { config, paths } = await openProject();
+    const skipped = await readSkippedServices(paths);
+    const report = progressReporter();
+    const { results, timedOut } = await pollUntilUp(
+      (timeoutMs) => runChecks(config, args._, { timeoutMs }, skipped),
+      {
+        deadlineMs,
+        attemptTimeoutMs: DEFAULT_TIMEOUT_SECONDS * 1e3,
+        intervalMs,
+        maxIntervalMs,
+        onPass: (pass, elapsedMs) => {
+          for (const line of report(pass, elapsedMs)) console.error(line);
+        }
+      }
+    );
+    if (args.json) {
+      console.log(JSON.stringify(results, null, 2));
+    } else if (results.length === 0) {
+      console.log("No services yet. Add one: probe add api -p 3000");
+    } else {
+      console.log(formatCheckResults(results, stdoutTerminal()));
+    }
+    if (timedOut) {
+      const down = results.filter((result) => !result.ok).map((result) => result.name);
+      console.error(`probe: still down after ${deadlineMs / 1e3}s: ${down.join(", ")}`);
+      process.exitCode = EXIT_DOWN;
+    }
+  }
+});
+
 // src/cli.ts
-var main = defineCommand9({
+var main = defineCommand10({
   meta: {
     name: "probe",
     version: CLI_VERSION,
     description: "Health checks for your local dev services"
   },
-  subCommands: { init: init_default, add: add_default, rm: rm_default, ls: ls_default, check: check_default, status: status_default, sync: sync_default, migrate: migrate_default }
+  args: {
+    interval: {
+      type: "string",
+      valueHint: "seconds",
+      description: "Seconds between two refreshes of the dashboard (probe alone, on a terminal)",
+      default: String(DASHBOARD_INTERVAL_SECONDS)
+    }
+  },
+  subCommands: { init: init_default, add: add_default, rm: rm_default, ls: ls_default, check: check_default, wait: wait_default, status: status_default, sync: sync_default, migrate: migrate_default }
 });
+async function printUsage(command, parent) {
+  const usage = await renderUsage(command, parent);
+  console.log(`${stdoutTerminal().color ? usage : stripStyles(usage)}
+`);
+}
 function notifyUpdate(rawArgs) {
   const cliPath = process.argv[1];
   if (updateCheckDisabled() || !cliPath) return;
   scheduleRefresh(cacheDir(), cliPath);
-  if (!process.stderr.isTTY || rawArgs.includes("--json") || rawArgs[0] === "status") return;
+  if (!detectTerminal(process.stderr, process.env).isTTY || rawArgs.includes("--json") || rawArgs[0] === "status")
+    return;
   const notice = updateNotice(CLI_VERSION, cacheDir());
   if (notice) console.error(`
 ${notice}`);
 }
+var INTERVAL_OPTION = "--interval";
+function dashboardInterval(rawArgs) {
+  const [first, second, ...rest] = rawArgs;
+  if (first === void 0) return void 0;
+  if (first.startsWith(`${INTERVAL_OPTION}=`) && second === void 0)
+    return first.slice(INTERVAL_OPTION.length + 1);
+  if (first === INTERVAL_OPTION && rest.length === 0) return second ?? "";
+  return null;
+}
+async function openedDashboard(rawArgs) {
+  const interval = dashboardInterval(rawArgs);
+  if (interval === null) return false;
+  const asked = interval !== void 0;
+  const askedMs = asked ? secondsToMs(INTERVAL_OPTION, interval) : void 0;
+  if (!isInteractive(process.stdin, process.stdout, process.env)) {
+    if (!asked) return false;
+    throw new ProbeError(
+      "USAGE",
+      `${INTERVAL_OPTION} sets the refresh of the dashboard, which needs an interactive terminal.`
+    );
+  }
+  const paths = asked ? requireProbeDir(process.cwd()) : findProbeDir(process.cwd());
+  if (!paths) return false;
+  const { config } = await loadConfig(paths);
+  if (Object.keys(config.services).length === 0) {
+    if (!asked) return false;
+    throw new ProbeError("USAGE", "No services yet. Add one: probe add api -p 3000");
+  }
+  const { openDashboard } = await import("./open-TQ6NPJ7V.js");
+  let settings = initialDashboardSettings(askedMs, await readDashboardPreferences(paths));
+  let saving = Promise.resolve();
+  const save = (write) => {
+    saving = saving.then(write).catch(() => {
+    });
+  };
+  await openDashboard(config, stdoutTerminal(), {
+    settings,
+    skipped: await readSkippedServices(paths),
+    onSettingsChange: (next) => {
+      const changed = changedPreferences(settings, next);
+      settings = next;
+      save(() => writeDashboardPreferences(paths, changed));
+    },
+    onSkipChange: (name, skip) => save(() => writeServiceSkip(paths, name, skip))
+  });
+  await saving;
+  return true;
+}
 async function run(rawArgs) {
   if (rawArgs[0] === REFRESH_COMMAND) return refreshCache(cacheDir());
   const wantsHelp = rawArgs.includes("--help") || rawArgs.includes("-h");
   const wantsVersion = rawArgs.length === 1 && ["--version", "-v"].includes(rawArgs[0]);
-  if (wantsHelp || wantsVersion) return runMain(main, { rawArgs });
+  if (wantsHelp || wantsVersion) return runMain(main, { rawArgs, showUsage: printUsage });
+  let dashboard = false;
   try {
-    await runCommand(main, { rawArgs });
+    dashboard = await openedDashboard(rawArgs);
+    if (!dashboard) await runCommand(main, { rawArgs });
   } catch (error) {
     process.exitCode = EXIT_ERROR;
     if (error instanceof ProbeError) {
       console.error(`probe: ${error.message}`);
     } else if (error instanceof Error && error.name === "CLIError") {
-      if (rawArgs.length === 0) await showUsage(main);
+      if (rawArgs.length === 0) await printUsage(main);
       console.error(`probe: ${error.message.replace(/\.$/, "")}. See: probe --help`);
     } else {
       console.error(`probe: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
   notifyUpdate(rawArgs);
+  if (dashboard) process.exit();
 }
 await run(process.argv.slice(2));