@ninhache/probe 0.3.0 → 0.4.0

package/README.md

@@ -39,7 +39,7 @@ Want `make check` too? See [Makefile](#makefile): it is optional.
 | Command                                                   | What it does                                                           |
 | --------------------------------------------------------- | ---------------------------------------------------------------------- |
 | `probe init`                                              | Create `.probe/` and the `.gitignore` entries                          |
-| `probe add <name> -p <port> [--host] [--path] [--expect]` | Add a service                                                          |
+| `probe add <name> -p <port> [--host] [--path] [--expect]` | Add a service (`--timeout <seconds>` gives it its own timeout)         |
 | `probe rm <name>`                                         | Remove a service                                                       |
 | `probe ls`                                                | List services                                                          |
 | `probe check [name...] [--json] [--timeout <seconds>]`    | Check all services, or the named ones                                  |
@@ -53,7 +53,8 @@ Exit codes: `0` all up, `1` a service is down, `2` usage or config error.
 `probe wait` is for scripts: `probe wait && pnpm test`. It checks at once, then again after 0.5 s, 1 s, 2 s, 4 s
 and every 5 s, for 60 s in total. `--timeout` sets the total, `--interval` the first pause, `--max-interval` the
 longest one. Unlike `check --timeout`, which is the time given to each service, `wait --timeout` covers the whole
-wait; each check inside it still gets 3 s. Progress goes to stderr, the final report to stdout; exit code `1` names the services still down.
+wait; each check inside it still gets 3 s, or the service's own `timeout`. Progress goes to stderr, the final
+report to stdout; exit code `1` names the services still down.
 
 `probe` works from any sub-directory: it walks up to the nearest `.probe/`.
 
@@ -62,13 +63,13 @@ wait; each check inside it still gets 3 s. Progress goes to stderr, the final re
 `probe` alone, on a terminal, opens a live list of your services and checks them every 2 s
 (`probe --interval 5` for another pace). Off a terminal, in CI or in a pipe, nothing changes: use `probe check`.
 
-| Key             | What it does                                     |
-| --------------- | ------------------------------------------------ |
-| `↑` `↓` `j` `k` | Move                                             |
-| `r`             | Check now                                        |
-| `Enter`         | Open the panel of the selected service (skip it) |
-| `o`             | Options: interval and timeout                    |
-| `q`             | Quit                                             |
+| Key             | What it does                           |
+| --------------- | -------------------------------------- |
+| `↑` `↓` `j` `k` | Move                                   |
+| `r`             | Check now                              |
+| `Enter`         | Open the panel of the selected service |
+| `o`             | Options: interval and timeout          |
+| `q`             | Quit                                   |
 
 What you change there is saved in `.probe/local.yml`, for your machine only:
 
@@ -81,6 +82,9 @@ services:
 A skipped service is left out of `probe check`, `probe wait` and the dashboard, and shown as `skipped`. Name it
 (`probe check db`) and it is checked anyway.
 
+The panel of a service also sets its timeout. That one is shared: it is written to `.probe/config.yml`, so
+commit it.
+
 ## Config
 
 `.probe/config.yml`:
@@ -91,14 +95,19 @@ services:
   api: { port: 3000, path: /health }
   front: { port: 5173 }
   admin: { host: 127.0.0.1, port: 8080, expect: [200, 204] }
+  db: { port: 5432, timeout: 10 }
 ```
 
-| Key      | Default     | Meaning                                |
-| -------- | ----------- | -------------------------------------- |
-| `port`   | required    | TCP port                               |
-| `host`   | `localhost` | Host name or IP                        |
-| `path`   | `/`         | Path requested with `GET`              |
-| `expect` | any 2xx     | Expected status, or a list of statuses |
+| Key       | Default     | Meaning                                 |
+| --------- | ----------- | --------------------------------------- |
+| `port`    | required    | TCP port                                |
+| `host`    | `localhost` | Host name or IP                         |
+| `path`    | `/`         | Path requested with `GET`               |
+| `expect`  | any 2xx     | Expected status, or a list of statuses  |
+| `timeout` | 3           | Seconds given to this service to answer |
+
+Which timeout applies: `--timeout` when you pass it, else the service's `timeout`, else 3 s (in the dashboard,
+the timeout set in its options). A config with a `timeout` needs `probe` 0.4.0 or later: older versions refuse it.
 
 Redirects are followed and the final status is judged, unless `expect` contains a 3xx: then the first response
 is judged as is.

package/dist/{chunk-ZCAUPLQS.js → chunk-HHTOVIAQ.js}

@@ -164,7 +164,12 @@ function getChecker(type) {
 }
 
 // src/checkers/run.ts
-async function runChecks(config, names, context, skipped = /* @__PURE__ */ new Set()) {
+function resolveTimeoutMs(service, options) {
+  const own = options.forceTimeout || service.timeout === void 0 ? void 0 : service.timeout;
+  const wanted = own === void 0 ? options.timeoutMs : Math.ceil(own * 1e3);
+  return Math.max(1, Math.min(wanted, options.maxTimeoutMs ?? wanted));
+}
+async function runChecks(config, names, options, skipped = /* @__PURE__ */ new Set()) {
   const known = Object.keys(config.services);
   const unknown = names.filter((name) => !known.includes(name));
   if (unknown.length > 0) {
@@ -189,7 +194,10 @@ async function runChecks(config, names, context, skipped = /* @__PURE__ */ new S
         };
         return result;
       }
-      return getChecker(type).check(name, service, context);
+      return getChecker(type).check(name, service, {
+        timeoutMs: resolveTimeoutMs(service, options),
+        signal: options.signal
+      });
     })
   );
 }
@@ -251,7 +259,7 @@ function formatServices(config, terminal, skipped = /* @__PURE__ */ new Set()) {
   const rows = Object.entries(config.services).map(([name, service]) => ({
     name,
     url: targetUrl(service),
-    notes: (service.expect === void 0 ? "" : `${GAP}expect ${service.expect}`) + (skipped.has(name) ? `${GAP}${SKIPPED}` : "")
+    notes: (service.expect === void 0 ? "" : `${GAP}expect ${service.expect}`) + (service.timeout === void 0 ? "" : `${GAP}timeout ${service.timeout}s`) + (skipped.has(name) ? `${GAP}${SKIPPED}` : "")
   }));
   const nameWidth = width(rows.map((row) => row.name));
   const fullWidth = width(rows.map((row) => " ".repeat(nameWidth) + GAP + row.url + row.notes));

package/dist/cli.js

@@ -34,7 +34,7 @@ import {
   isInteractive,
   runChecks,
   stripStyles
-} from "./chunk-ZCAUPLQS.js";
+} from "./chunk-HHTOVIAQ.js";
 import "./chunk-M3ASEG5F.js";
 
 // src/cli.ts
@@ -98,7 +98,9 @@ var serviceSchemaV1 = z.strictObject({
   host: z.string().min(1).default("localhost"),
   port: z.number().int().min(1).max(65535),
   path: z.string().startsWith("/").default("/"),
-  expect: z.union([statusCode, z.array(statusCode).min(1)]).optional()
+  expect: z.union([statusCode, z.array(statusCode).min(1)]).optional(),
+  /** Seconds given to this service to answer, instead of the default. */
+  timeout: z.number().positive().max(MAX_TIMEOUT_SECONDS).optional()
 });
 var configSchemaV1 = z.strictObject({
   schemaVersion: z.literal(1),
@@ -278,6 +280,15 @@ async function saveConfig(loaded, raw, options = {}) {
   await writeFile(loaded.paths.config, loaded.doc.toString());
   return { ...loaded, config, raw };
 }
+async function writeServiceTimeout(paths, name, seconds2) {
+  const loaded = await loadConfig(paths);
+  const services = loaded.raw.services ?? {};
+  if (!Object.hasOwn(services, name)) return false;
+  const { timeout: _previous, ...service } = services[name];
+  if (seconds2 !== void 0) service.timeout = seconds2;
+  await saveConfig(loaded, { ...loaded.raw, services: { ...services, [name]: service } });
+  return true;
+}
 
 // src/makefile/sync.ts
 import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
@@ -305,7 +316,7 @@ async function writeLock(paths, lock) {
 }
 
 // src/version.ts
-var CLI_VERSION = true ? "0.3.0" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.4.0" : "0.0.0-dev";
 
 // src/makefile/generator.ts
 import { createHash } from "crypto";
@@ -449,7 +460,11 @@ var add_default = defineCommand({
     port: { type: "string", alias: "p", description: "Port", required: true },
     host: { type: "string", description: "Host (default: localhost)" },
     path: { type: "string", description: "Path to request (default: /)" },
-    expect: { type: "string", description: "Expected status, e.g. 200 or 200,204 (default: 2xx)" }
+    expect: { type: "string", description: "Expected status, e.g. 200 or 200,204 (default: 2xx)" },
+    timeout: {
+      type: "string",
+      description: `Seconds to wait for this service (default: ${DEFAULT_TIMEOUT_SECONDS})`
+    }
   },
   async run({ args }) {
     const loaded = await openProject();
@@ -464,6 +479,10 @@ var add_default = defineCommand({
     if (args.host) service.host = args.host;
     if (args.path) service.path = args.path;
     if (args.expect) service.expect = parseExpect(String(args.expect));
+    if (args.timeout !== void 0) {
+      secondsToMs("--timeout", String(args.timeout));
+      service.timeout = Number(args.timeout);
+    }
     await saveServices(loaded, { ...services, [args.name]: service });
     console.log(`Added ${args.name}. Try: probe check ${args.name}`);
   }
@@ -583,15 +602,16 @@ var check_default = defineCommand2({
     json: { type: "boolean", description: "Print results as JSON" },
     timeout: {
       type: "string",
-      description: "Seconds to wait for each service",
-      default: String(DEFAULT_TIMEOUT_SECONDS)
+      // No citty default: a value given here must be told apart from none, it beats the services' own.
+      description: `Seconds to wait for each service (default: its own timeout, else ${DEFAULT_TIMEOUT_SECONDS})`
     }
   },
   async run({ args }) {
-    const timeoutMs = secondsToMs("--timeout", args.timeout);
+    const forceTimeout = args.timeout !== void 0;
+    const timeoutMs = secondsToMs("--timeout", args.timeout ?? String(DEFAULT_TIMEOUT_SECONDS));
     const { config, paths } = await openProject();
     const skipped = await readSkippedServices(paths);
-    const results = await runChecks(config, args._, { timeoutMs }, skipped);
+    const results = await runChecks(config, args._, { timeoutMs, forceTimeout }, skipped);
     if (args.json) {
       console.log(JSON.stringify(results, null, 2));
     } else if (results.length === 0) {
@@ -829,15 +849,16 @@ async function pollUntilUp(check, options) {
   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 left = Math.max(1, Math.ceil(remaining()));
+    const results = await check(Math.min(attemptTimeoutMs, left), left);
     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) {
+    const rest = remaining();
+    if (lastPass || rest <= 0) return { results, elapsedMs, timedOut: true };
+    if (pause >= rest) {
       lastPass = true;
-      await sleep(left - Math.min(WAIT_LAST_PASS_MS, left / 2));
+      await sleep(rest - Math.min(WAIT_LAST_PASS_MS, rest / 2));
     } else {
       await sleep(pause);
       pause = Math.min(pause * WAIT_BACKOFF_FACTOR, maxIntervalMs);
@@ -901,7 +922,13 @@ var wait_default = defineCommand9({
     const skipped = await readSkippedServices(paths);
     const report = progressReporter();
     const { results, timedOut } = await pollUntilUp(
-      (timeoutMs) => runChecks(config, args._, { timeoutMs }, skipped),
+      // A service with its own timeout keeps it here, within what is left of the total.
+      (_passMs, remainingMs) => runChecks(
+        config,
+        args._,
+        { timeoutMs: DEFAULT_TIMEOUT_SECONDS * 1e3, maxTimeoutMs: remainingMs },
+        skipped
+      ),
       {
         deadlineMs,
         attemptTimeoutMs: DEFAULT_TIMEOUT_SECONDS * 1e3,
@@ -987,7 +1014,7 @@ async function openedDashboard(rawArgs) {
     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");
+  const { openDashboard } = await import("./open-QTP4Z5QX.js");
   let settings = initialDashboardSettings(askedMs, await readDashboardPreferences(paths));
   let saving = Promise.resolve();
   const save = (write) => {
@@ -1002,7 +1029,8 @@ async function openedDashboard(rawArgs) {
       settings = next;
       save(() => writeDashboardPreferences(paths, changed));
     },
-    onSkipChange: (name, skip) => save(() => writeServiceSkip(paths, name, skip))
+    onSkipChange: (name, skip) => save(() => writeServiceSkip(paths, name, skip)),
+    onTimeoutChange: (name, seconds2) => save(() => writeServiceTimeout(paths, name, seconds2))
   });
   await saving;
   return true;

package/dist/{open-TQ6NPJ7V.js → open-QTP4Z5QX.js}

@@ -7,7 +7,7 @@ import {
   formatCheckResults,
   runChecks,
   truncate
-} from "./chunk-ZCAUPLQS.js";
+} from "./chunk-HHTOVIAQ.js";
 import {
   __commonJS,
   __export,
@@ -20252,6 +20252,12 @@ var SETTING_ROWS = [
   { key: "intervalMs", label: "Interval", choicesMs: DASHBOARD_INTERVAL_CHOICES_SECONDS.map(toMs) },
   { key: "timeoutMs", label: "Timeout", choicesMs: DASHBOARD_TIMEOUT_CHOICES_SECONDS.map(toMs) }
 ];
+function stepServiceTimeout(current, direction) {
+  const choices = DASHBOARD_TIMEOUT_CHOICES_SECONDS;
+  if (current === void 0) return direction === 1 ? choices[0] : void 0;
+  if (direction === 1) return choices.find((choice) => choice > current) ?? current;
+  return choices.findLast((choice) => choice < current);
+}
 function stepChoice(choices, current, direction) {
   const next = direction === 1 ? choices.find((choice) => choice > current) : choices.findLast((choice) => choice < current);
   return next ?? current;
@@ -20259,7 +20265,9 @@ function stepChoice(choices, current, direction) {
 
 // src/dashboard/Dashboard.tsx
 var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
-var SERVICE_ROWS = ["Skip"];
+var SERVICE_ROWS = ["Skip", "Timeout"];
+var TIMEOUT_ROW = SERVICE_ROWS.indexOf("Timeout");
+var NO_TIMEOUTS = {};
 var MARKER_WIDTH = 2;
 var PANEL_WIDTH = 30;
 var PANEL_FRAME_WIDTH = 4;
@@ -20268,9 +20276,11 @@ function Dashboard({
   terminal,
   settings: initial,
   skipped: initiallySkipped,
+  timeouts: initialTimeouts = NO_TIMEOUTS,
   check: check2,
   onSettingsChange,
-  onSkipChange
+  onSkipChange,
+  onTimeoutChange
 }) {
   const { exit } = useApp();
   const { columns } = use_window_size_default();
@@ -20278,6 +20288,7 @@ function Dashboard({
   const [selected, setSelected] = (0, import_react36.useState)(0);
   const [settings, setSettings] = (0, import_react36.useState)(initial);
   const [skipped, setSkipped] = (0, import_react36.useState)(() => new Set(initiallySkipped));
+  const [timeouts, setTimeouts] = (0, import_react36.useState)(initialTimeouts);
   const [panel, setPanel] = (0, import_react36.useState)(null);
   const skipPause = (0, import_react36.useRef)(() => {
   });
@@ -20287,7 +20298,7 @@ function Dashboard({
     const { signal } = controller;
     const loop = async () => {
       while (!signal.aborted) {
-        const next = await check2(signal, timeoutMs, skipped);
+        const next = await check2(signal, timeoutMs, skipped, timeouts);
         if (signal.aborted) return;
         setLatest(next);
         await new Promise((resolve) => {
@@ -20302,7 +20313,7 @@ function Dashboard({
     };
     void loop();
     return () => controller.abort();
-  }, [check2, intervalMs, timeoutMs, skipped]);
+  }, [check2, intervalMs, timeoutMs, skipped, timeouts]);
   const last = (latest?.length ?? 1) - 1;
   const current = Math.min(selected, last);
   const change = (rowIndex, direction) => {
@@ -20321,6 +20332,12 @@ function Dashboard({
     setSkipped(next);
     onSkipChange?.(name, skip);
   };
+  const changeTimeout = (name, direction) => {
+    const value = stepServiceTimeout(timeouts[name], direction);
+    if (value === timeouts[name]) return;
+    setTimeouts({ ...timeouts, [name]: value });
+    onTimeoutChange?.(name, value);
+  };
   use_input_default((input, key) => {
     const up2 = key.upArrow || input === "k";
     const down = key.downArrow || input === "j";
@@ -20342,6 +20359,7 @@ function Dashboard({
       setPanel({ ...panel, row: Math.max(0, Math.min(lastRow, panel.row + (down ? 1 : -1))) });
     } else if (left || right) {
       if (panel.kind === "options") change(panel.row, right ? 1 : -1);
+      else if (panel.row === TIMEOUT_ROW) changeTimeout(panel.name, right ? 1 : -1);
       else toggleSkip(panel.name);
     }
   });
@@ -20371,7 +20389,13 @@ function Dashboard({
   }).split("\n");
   const focused = results[current];
   const panelWidth = Math.min(PANEL_WIDTH, columns);
-  const panelRows = panel?.kind === "options" ? SETTING_ROWS.map((row) => [row.label, seconds(settings[row.key])]) : panel ? SERVICE_ROWS.map((label) => [label, skipped.has(panel.name) ? "yes" : "no"]) : [];
+  const panelRows = panel?.kind === "options" ? SETTING_ROWS.map((row) => [row.label, seconds(settings[row.key])]) : panel ? [
+    ["Skip", skipped.has(panel.name) ? "yes" : "no"],
+    [
+      "Timeout",
+      timeouts[panel.name] === void 0 ? "default" : `${timeouts[panel.name]}s`
+    ]
+  ] : [];
   const labelWidth = Math.max(0, ...panelRows.map(([label]) => label.length));
   const hint = panel === null ? `${unicode ? "\u2191\u2193 jk" : "jk"} move ${dot} r refresh ${dot} ${unicode ? "\u21B5" : "enter"} service ${dot} o options ${dot} q quit` : `${unicode ? "\u2191\u2193 jk" : "jk"} move ${dot} ${unicode ? "\u2190\u2192 hl" : "hl"} change ${dot} esc close`;
   return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(Box_default, { flexDirection: "column", children: [
@@ -20411,10 +20435,24 @@ function Dashboard({
 // src/dashboard/open.tsx
 var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1);
 async function openDashboard(config, terminal, state) {
-  const check2 = (signal, timeoutMs, skipped) => runChecks(config, [], { timeoutMs, signal }, skipped);
-  const app = render_default(/* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Dashboard, { terminal, check: check2, ...state }), {
-    alternateScreen: true
-  });
+  const check2 = (signal, timeoutMs, skipped, timeouts2) => {
+    const services = Object.fromEntries(
+      Object.entries(config.services).map(([name, service]) => [
+        name,
+        { ...service, timeout: timeouts2[name] }
+      ])
+    );
+    return runChecks({ ...config, services }, [], { timeoutMs, signal }, skipped);
+  };
+  const timeouts = Object.fromEntries(
+    Object.entries(config.services).flatMap(
+      ([name, { timeout }]) => timeout === void 0 ? [] : [[name, timeout]]
+    )
+  );
+  const app = render_default(
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Dashboard, { terminal, check: check2, timeouts, ...state }),
+    { alternateScreen: true }
+  );
   await app.waitUntilExit();
 }
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ninhache/probe",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Health checks for your local dev services, from the CLI or a generated Makefile",
   "license": "MIT",
   "author": "Ninhache",