@ninhache/probe 0.8.0 → 0.10.0

package/README.md

@@ -81,7 +81,7 @@ tick. Nothing is ticked at first, and nothing is written unless you tick it. The
   each, redirects not followed).
   `PROBE_DETECT_PORTS=4000,4001` tries other ports, `PROBE_DETECT_PORTS=` none.
 
-`probe rm` is the one command that deletes something. On a terminal it asks first, with "No" selected: `--yes`
+`probe rm` deletes something, so on a terminal it asks first, with "No" selected: `--yes`
 (`-y`) skips the question. Off a terminal, in a script or in CI, it removes at once, as before.
 
 `probe open` uses `open` on macOS and `xdg-open` elsewhere. Without it, the URL is printed and the exit code is
@@ -109,15 +109,38 @@ of macOS.
 `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 |
-| `o`             | Options: interval and timeout          |
-| `q`             | Quit                                   |
-
-What you change there is saved in `.probe/local.yml`, for your machine only:
+| Key             | What it does                                   |
+| --------------- | ---------------------------------------------- |
+| `↑` `↓` `j` `k` | Move                                           |
+| `r`             | Check now                                      |
+| `Enter`         | Open the detail of the selected service        |
+| `u`             | Open its URL in the browser                    |
+| `c`             | Copy its curl command                          |
+| `/`             | Filter by name; `Enter` keeps it, `Esc` clears |
+| `a`             | Add a service                                  |
+| `e`             | Edit the selected service                      |
+| `d`             | Remove the selected service, after a question  |
+| `:`             | Find a command by what it does; `Enter` runs   |
+| `o`             | Options: interval and timeout                  |
+| `?`             | Every key; `?` or `Esc` closes                 |
+| `q`             | Quit                                           |
+
+The bar at the bottom shows the keys you need first; `?` lists them all.
+
+`c` uses `pbcopy` on macOS, `wl-copy` or `xclip` on Linux. Without one of them, the command is shown instead,
+to copy by hand.
+
+`a` and `e` open a form: name, port, host, path, expected status. `↑` `↓` or `Tab` change field, `Enter` saves,
+`Esc` cancels. A field left empty takes its default. `d` asks first: only `y` removes. All three write
+`.probe/config.yml` the way `probe add` and `probe rm` do: comments kept, [Makefile](#makefile) block kept up to
+date. While you type, in the filter, the form or the command palette, `q` and `?` are letters.
+
+`Enter` shows the last answer of the selected service above its two settings: status, latencies of this
+session, headers and the first lines of the body; for a service that is down, what failed and what to try. The
+value of a header that can carry a secret (`Authorization`, `Set-Cookie`, anything named after a token or a key)
+is replaced by `(hidden)`. None of it is written anywhere, and `probe check --json` prints what it printed before.
+
+The panels save what you change in `.probe/local.yml`, for your machine only:
 
 ```yaml
 dashboard: { interval: 5, timeout: 3 }
@@ -180,7 +203,7 @@ outside the block is yours and is never touched. Without a block, no command cre
 # <<< probe
 ```
 
-Once the block is there, `probe add` and `probe rm` keep it up to date. Commit the `Makefile` and
+Once the block is there, `probe add`, `probe rm` and the dashboard keep it up to date. Commit the `Makefile` and
 `.probe/lock.yml`.
 
 Targets: `help`, `check`, `status`, `probe` (opens the [dashboard](#dashboard)) and one `check-<name>` per

package/dist/{chunk-Z4F2X5IS.js → chunk-VSQVZK7F.js}

@@ -14,6 +14,9 @@ var DEFAULT_MAKEFILE = "Makefile";
 var DEFAULT_CHECKER_TYPE = "http";
 var DEFAULT_TIMEOUT_SECONDS = 3;
 var DASHBOARD_INTERVAL_SECONDS = 2;
+var DASHBOARD_HISTORY_LENGTH = 30;
+var RESPONSE_BODY_BYTES = 2048;
+var RESPONSE_BODY_WAIT_MS = 500;
 var DASHBOARD_INTERVAL_CHOICES_SECONDS = [0.5, 1, 2, 5, 10, 30, 60];
 var DASHBOARD_TIMEOUT_CHOICES_SECONDS = [1, 2, 3, 5, 10, 30];
 var MAX_TIMEOUT_SECONDS = 2147483;
@@ -162,6 +165,79 @@ function diagnoseStatus(service, status) {
   return { error, hint: `the service answers: check \`path\` and \`expect\` in ${CONFIG}` };
 }
 
+// src/checkers/response.ts
+var HIDDEN_VALUE = "(hidden)";
+var SENSITIVE_HEADER = /auth|cookie|token|secret|key|session|password|credential/i;
+var TEXT_TYPE = /^text\/|json|xml|javascript|yaml|x-www-form-urlencoded/i;
+var NUL = 0;
+var FIRST_PRINTABLE = 32;
+var DELETE = 127;
+var LAST_C1_CONTROL = 159;
+var REPLACEMENT = "\uFFFD";
+function isControl(character) {
+  const code = character.codePointAt(0) ?? NUL;
+  return code < FIRST_PRINTABLE || code >= DELETE && code <= LAST_C1_CONTROL;
+}
+function printable(text, kept = "") {
+  return Array.from(text).filter((character) => kept.includes(character) || !isControl(character)).join("");
+}
+async function readStart(body) {
+  const reader = body.getReader();
+  const chunks = [];
+  let size = 0;
+  let ended = false;
+  let timer;
+  const late = new Promise((resolve) => {
+    timer = setTimeout(() => resolve("late"), RESPONSE_BODY_WAIT_MS);
+  });
+  try {
+    while (size < RESPONSE_BODY_BYTES) {
+      const read = reader.read();
+      read.catch(() => {
+      });
+      const next = await Promise.race([read, late]);
+      if (next === "late") break;
+      if (next.done) {
+        ended = true;
+        break;
+      }
+      chunks.push(next.value);
+      size += next.value.length;
+    }
+  } catch {
+  } finally {
+    clearTimeout(timer);
+    void reader.cancel().catch(() => {
+    });
+  }
+  return {
+    bytes: Buffer.concat(chunks).subarray(0, RESPONSE_BODY_BYTES),
+    cut: !ended || size > RESPONSE_BODY_BYTES
+  };
+}
+async function describeResponse(response) {
+  const headers = [...response.headers].map(([name, value]) => [
+    printable(name),
+    SENSITIVE_HEADER.test(name) ? HIDDEN_VALUE : printable(value)
+  ]);
+  const detail = { statusText: printable(response.statusText), headers };
+  if (!response.body) return detail;
+  const type = printable(response.headers.get("content-type")?.split(";")[0] ?? "").trim();
+  if (type && !TEXT_TYPE.test(type)) {
+    void response.body.cancel().catch(() => {
+    });
+    return { ...detail, bodyNote: `${type} body, not shown` };
+  }
+  const { bytes, cut } = await readStart(response.body);
+  if (bytes.length === 0) return detail;
+  if (bytes.includes(NUL)) return { ...detail, bodyNote: "binary body, not shown" };
+  const decoded = new TextDecoder().decode(bytes).replaceAll("	", "  ");
+  const text = printable(cut ? decoded.replace(new RegExp(`${REPLACEMENT}+$`), "") : decoded, "\n");
+  const body = text.trimEnd();
+  if (!body) return detail;
+  return cut ? { ...detail, body, bodyCut: true } : { ...detail, body };
+}
+
 // src/checkers/http.ts
 function targetUrl(service) {
   const bareIpv6 = service.host.includes(":") && !service.host.startsWith("[");
@@ -183,7 +259,7 @@ function expectsRedirect(expect) {
 }
 var httpChecker = {
   type: "http",
-  async check(name, service, { timeoutMs, signal }) {
+  async check(name, service, { timeoutMs, signal, detail }) {
     const target = targetUrl(service);
     const base = { name, type: "http", target };
     const started = performance.now();
@@ -196,10 +272,20 @@ var httpChecker = {
         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 };
-      return { ...base, ok: false, status, latencyMs, ...diagnoseStatus(service, status) };
+      const described = detail ? { response: await describeResponse(response) } : {};
+      if (!detail) await response.body?.cancel();
+      if (isExpected(service.expect, status)) {
+        return { ...base, ok: true, status, latencyMs, ...described };
+      }
+      return {
+        ...base,
+        ok: false,
+        status,
+        latencyMs,
+        ...diagnoseStatus(service, status),
+        ...described
+      };
     } catch (error) {
       const diagnosis = diagnoseFailure(error, service, timeoutMs);
       return { ...base, ok: false, latencyMs: elapsed(), ...diagnosis };
@@ -251,12 +337,68 @@ async function runChecks(config, names, options, skipped = /* @__PURE__ */ new S
       }
       return getChecker(type).check(name, service, {
         timeoutMs: resolveTimeoutMs(service, options),
-        signal: options.signal
+        signal: options.signal,
+        detail: options.detail
       });
     })
   );
 }
 
+// src/config/schema.ts
+import { z } from "zod";
+var CURRENT_SCHEMA_VERSION = 1;
+var SERVICE_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
+var statusCode = z.number().int().min(100).max(599);
+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(),
+  /** 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),
+  services: z.record(
+    z.string().regex(SERVICE_NAME_PATTERN, "letters, digits, _ and - only"),
+    serviceSchemaV1
+  ).nullish().transform((services) => services ?? {})
+});
+var schemas = {
+  1: configSchemaV1
+};
+
+// src/config/service-input.ts
+var INTEGER = /^\d+$/;
+function schemaProblem(schema, value) {
+  const result = schema.safeParse(value);
+  return result.success ? void 0 : result.error.issues[0]?.message;
+}
+function parseExpectList(value) {
+  const codes = value.split(",").map((code) => Number(code.trim()));
+  return codes.length === 1 ? codes[0] : codes;
+}
+function nameProblem(name, taken) {
+  if (!SERVICE_NAME_PATTERN.test(name)) return "Letters, digits, _ and - only, e.g. api";
+  if ([...taken].includes(name)) return `${name} already exists`;
+  return void 0;
+}
+function portProblem(port) {
+  if (!INTEGER.test(port)) return "A port number, e.g. 3000";
+  return schemaProblem(serviceSchemaV1.shape.port, Number(port)) && "A port between 1 and 65535";
+}
+function hostProblem(host) {
+  return /\s|\//.test(host) || host === "" ? "A host name or an IP, e.g. localhost" : void 0;
+}
+function pathProblem(path) {
+  return schemaProblem(serviceSchemaV1.shape.path, path) && "A path that starts with /";
+}
+function expectProblem(expect) {
+  const codes = expect.split(",").map((code) => code.trim());
+  if (!codes.every((code) => INTEGER.test(code))) return "A status, or several: 200 or 200,204";
+  return schemaProblem(serviceSchemaV1.shape.expect, parseExpectList(expect)) && "Statuses go from 100 to 599";
+}
+
 // src/ui/colors.ts
 function createColors(enabled) {
   const wrap = (open, close) => (text) => enabled ? `\x1B[${open}m${text}\x1B[${close}m` : text;
@@ -334,6 +476,22 @@ function formatServices(config, terminal, skipped = /* @__PURE__ */ new Set()) {
   }).join("\n");
 }
 
+// src/open-url.ts
+import { spawn as nodeSpawn } from "child_process";
+function openerCommand(platform) {
+  return platform === "darwin" ? "open" : "xdg-open";
+}
+function openUrl(url, platform = process.platform, spawn = nodeSpawn) {
+  return new Promise((resolve) => {
+    const child = spawn(openerCommand(platform), [url], { detached: true, stdio: "ignore" });
+    child.once("error", () => resolve(false));
+    child.once("spawn", () => {
+      child.unref();
+      resolve(true);
+    });
+  });
+}
+
 export {
   PACKAGE_NAME,
   PROBE_DIR,
@@ -346,6 +504,7 @@ export {
   DEFAULT_MAKEFILE,
   DEFAULT_TIMEOUT_SECONDS,
   DASHBOARD_INTERVAL_SECONDS,
+  DASHBOARD_HISTORY_LENGTH,
   DASHBOARD_INTERVAL_CHOICES_SECONDS,
   DASHBOARD_TIMEOUT_CHOICES_SECONDS,
   MAX_TIMEOUT_SECONDS,
@@ -365,6 +524,16 @@ export {
   DETECT_PORTS,
   DETECT_PORTS_ENV,
   DETECT_TIMEOUT_MS,
+  CURRENT_SCHEMA_VERSION,
+  SERVICE_NAME_PATTERN,
+  serviceSchemaV1,
+  schemas,
+  parseExpectList,
+  nameProblem,
+  portProblem,
+  hostProblem,
+  pathProblem,
+  expectProblem,
   ProbeError,
   targetUrl,
   curlCommand,
@@ -375,5 +544,7 @@ export {
   stripStyles,
   runChecks,
   formatCheckResults,
-  formatServices
+  formatServices,
+  openerCommand,
+  openUrl
 };

package/dist/cli.js

@@ -5,6 +5,7 @@ import {
   BACKUP_GLOB,
   COMPLETE_COMMAND,
   CONFIG_FILE,
+  CURRENT_SCHEMA_VERSION,
   DASHBOARD_INTERVAL_SECONDS,
   DEFAULT_MAKEFILE,
   DEFAULT_TIMEOUT_SECONDS,
@@ -27,6 +28,7 @@ import {
   REFRESH_COMMAND,
   REGISTRY_LATEST_URL,
   REGISTRY_TIMEOUT_MS,
+  SERVICE_NAME_PATTERN,
   UPDATE_CACHE_FILE,
   UPDATE_CHECK_TTL_MS,
   WAIT_BACKOFF_FACTOR,
@@ -34,13 +36,21 @@ import {
   createColors,
   curlCommand,
   detectTerminal,
+  expectProblem,
   formatCheckResults,
   formatServices,
   isInteractive,
+  nameProblem,
+  openUrl,
+  openerCommand,
+  pathProblem,
+  portProblem,
   runChecks,
+  schemas,
+  serviceSchemaV1,
   stripStyles,
   targetUrl
-} from "./chunk-Z4F2X5IS.js";
+} from "./chunk-VSQVZK7F.js";
 import "./chunk-M3ASEG5F.js";
 
 // src/cli.ts
@@ -54,30 +64,6 @@ import {
 // src/commands/add.ts
 import { defineCommand } from "citty";
 
-// src/config/schema.ts
-import { z } from "zod";
-var CURRENT_SCHEMA_VERSION = 1;
-var SERVICE_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
-var statusCode = z.number().int().min(100).max(599);
-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(),
-  /** 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),
-  services: z.record(
-    z.string().regex(SERVICE_NAME_PATTERN, "letters, digits, _ and - only"),
-    serviceSchemaV1
-  ).nullish().transform((services) => services ?? {})
-});
-var schemas = {
-  1: configSchemaV1
-};
-
 // src/ui/prompt.ts
 async function confirm(message, streams = {}) {
   const { confirm: ask2, isCancel } = await import("./dist-SITQEC3X.js");
@@ -619,10 +605,10 @@ import { join as join4 } from "path";
 // src/config/lock.ts
 import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
 import { parse as parse2, stringify } from "yaml";
-import { z as z2 } from "zod";
-var lockSchema = z2.object({
-  cliVersion: z2.string(),
-  makefile: z2.object({ hash: z2.string() })
+import { z } from "zod";
+var lockSchema = z.object({
+  cliVersion: z.string(),
+  makefile: z.object({ hash: z.string() })
 });
 var HEADER = "# Generated by probe. Do not edit.\n";
 async function readLock(paths) {
@@ -638,7 +624,7 @@ async function writeLock(paths, lock) {
 }
 
 // src/version.ts
-var CLI_VERSION = true ? "0.8.0" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.10.0" : "0.0.0-dev";
 
 // src/makefile/generator.ts
 import { createHash } from "crypto";
@@ -759,16 +745,21 @@ function rawServices(loaded) {
   return loaded.raw.services ?? {};
 }
 async function saveServices(loaded, services) {
+  const { warning } = await writeServices(loaded, services);
+  if (warning) console.error(`probe: ${warning}`);
+}
+async function writeServices(loaded, services) {
   const block = await blockState(loaded.paths, loaded.config);
   const saved = await saveConfig(loaded, { ...loaded.raw, services });
-  if (block === "missing") return;
+  if (block === "missing") return { saved };
   if (block !== "modified") {
     await syncMakefile(saved.paths, saved.config);
-    return;
+    return { saved };
   }
-  console.error(
-    "probe: the Makefile block was edited by hand, left as is. Run `probe sync` to regenerate it."
-  );
+  return {
+    saved,
+    warning: "the Makefile block was edited by hand, left as is. Run `probe sync` to regenerate it."
+  };
 }
 
 // src/commands/detected.ts
@@ -804,26 +795,7 @@ function parseExpect(value) {
   const codes = value.split(",").map((code) => parseInteger(code.trim(), "--expect"));
   return codes.length === 1 ? codes[0] : codes;
 }
-var INTEGER = /^\d+$/;
 var DEFAULT_PATH = "/";
-function schemaProblem(schema, value) {
-  const result = schema.safeParse(value);
-  return result.success ? void 0 : result.error.issues[0]?.message;
-}
-function nameProblem(name, services) {
-  if (!SERVICE_NAME_PATTERN.test(name)) return "Letters, digits, _ and - only, e.g. api";
-  if (Object.hasOwn(services, name)) return `${name} already exists`;
-  return void 0;
-}
-function portProblem(port) {
-  if (!INTEGER.test(port)) return "A port number, e.g. 3000";
-  return schemaProblem(serviceSchemaV1.shape.port, Number(port)) && "A port between 1 and 65535";
-}
-function expectProblem(expect) {
-  const codes = expect.split(",").map((code) => code.trim());
-  if (!codes.every((code) => INTEGER.test(code))) return "A status, or several: 200 or 200,204";
-  return schemaProblem(serviceSchemaV1.shape.expect, parseExpect(expect)) && "Statuses go from 100 to 599";
-}
 async function guidedAdd() {
   const loaded = await openProject();
   const services = rawServices(loaded);
@@ -838,14 +810,14 @@ async function guidedAdd() {
     {
       message: "Service name",
       placeholder: "api",
-      validate: (v) => nameProblem(v, services)
+      validate: (v) => nameProblem(v, Object.keys(services))
     },
     { message: "Port", placeholder: "3000", validate: portProblem },
     {
       message: "Path to request",
       placeholder: DEFAULT_PATH,
       defaultValue: DEFAULT_PATH,
-      validate: (v) => schemaProblem(serviceSchemaV1.shape.path, v)
+      validate: pathProblem
     },
     {
       message: "Expected status",
@@ -1295,24 +1267,6 @@ var migrate_default = defineCommand7({
 
 // src/commands/open.ts
 import { defineCommand as defineCommand8 } from "citty";
-
-// src/open-url.ts
-import { spawn as nodeSpawn } from "child_process";
-function openerCommand(platform) {
-  return platform === "darwin" ? "open" : "xdg-open";
-}
-function openUrl(url, platform = process.platform, spawn2 = nodeSpawn) {
-  return new Promise((resolve2) => {
-    const child = spawn2(openerCommand(platform), [url], { detached: true, stdio: "ignore" });
-    child.once("error", () => resolve2(false));
-    child.once("spawn", () => {
-      child.unref();
-      resolve2(true);
-    });
-  });
-}
-
-// src/commands/open.ts
 var open_default = defineCommand8({
   meta: { name: "open", description: "Open the URL of a service in the browser" },
   args: {
@@ -1356,6 +1310,38 @@ var rm_default = defineCommand9({
   }
 });
 
+// src/commands/service-writes.ts
+import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
+var DEFAULTS = { host: "localhost", path: "/", expect: void 0 };
+var FIELD_KEYS = ["host", "port", "path", "expect"];
+var sameValue = (a, b) => isDeepStrictEqual2([a].flat(), [b].flat());
+function withFields(service, fields, current) {
+  const next = { ...service };
+  for (const key of FIELD_KEYS) {
+    if (current && sameValue(fields[key], current[key])) continue;
+    if (isDeepStrictEqual2(fields[key], DEFAULTS[key])) delete next[key];
+    else next[key] = fields[key];
+  }
+  return next;
+}
+async function writeService(paths, write) {
+  const loaded = await loadConfig(paths);
+  const services = rawServices(loaded);
+  const exists = Object.hasOwn(services, write.name);
+  if (exists === (write.kind === "add")) return null;
+  const { [write.name]: previous, ...others } = services;
+  const next = write.kind === "remove" ? others : {
+    ...services,
+    [write.name]: withFields(
+      previous ?? {},
+      write.fields,
+      loaded.config.services[write.name]
+    )
+  };
+  const { saved, warning } = await writeServices(loaded, next);
+  return { config: saved.config, warning };
+}
+
 // src/commands/status.ts
 import { defineCommand as defineCommand10 } from "citty";
 
@@ -1810,7 +1796,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-2H7PHDYL.js");
+  const { openDashboard } = await import("./open-W2TWG636.js");
   let settings = initialDashboardSettings(askedMs, await readDashboardPreferences(paths));
   const saves = createSaveQueue();
   const local = `${PROBE_DIR}/${LOCAL_FILE}`;
@@ -1828,7 +1814,19 @@ async function openedDashboard(rawArgs) {
       `${PROBE_DIR}/${CONFIG_FILE}`,
       () => writeServiceTimeout(paths, name, seconds2),
       `${name} is no longer in ${PROBE_DIR}/${CONFIG_FILE}`
-    )
+    ),
+    onServiceWrite: async (write) => {
+      let written = null;
+      const failure = await saves.save(
+        `${PROBE_DIR}/${CONFIG_FILE}`,
+        async () => {
+          written = await writeService(paths, write);
+          return written !== null;
+        },
+        write.kind === "add" ? `${write.name} is already in ${PROBE_DIR}/${CONFIG_FILE}` : `${write.name} is no longer in ${PROBE_DIR}/${CONFIG_FILE}`
+      );
+      return { failure, ...written };
+    }
   });
   await saves.idle();
   for (const failure of saves.failures()) console.error(`probe: not saved: ${failure}`);