@ninhache/probe 0.7.0 → 0.8.0

package/README.md

@@ -67,6 +67,20 @@ report to stdout; exit code `1` names the services still down.
 `probe add` alone, on a terminal, asks for the name, the port, the path and the expected status, one at a time:
 Enter alone keeps the default, Ctrl+C adds nothing. Off a terminal it needs its arguments, as before.
 
+On a terminal, `probe init` and `probe add` alone first show the services they find in the project, as a list to
+tick. Nothing is ticked at first, and nothing is written unless you tick it. They look at:
+
+- the compose file (`compose.yaml`, `compose.yml`, `docker-compose.yaml` or `docker-compose.yml`) and its
+  `override` file: the ports a service publishes (`"8080:80"`), under the name of the service. A variable in a
+  port takes its value from `.env`. Https, mail, database, cache and broker ports are left out.
+- `.env` and `.env.local`: `PORT`, and the `*_URL` that point to `http://localhost`. Only the host, the port and
+  the path are kept: no other value is kept, shown or written.
+- `package.json`: the port a script names (`--port 4000`), or the usual one of its dev server (vite, next, nuxt,
+  astro, angular).
+- the local ports 3000, 3001, 4200, 4321, 5173, 8000 and 8080, when an HTTP server answers there (one `GET /`
+  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`
 (`-y`) skips the question. Off a terminal, in a script or in CI, it removes at once, as before.
 

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

@@ -30,6 +30,9 @@ var REFRESH_COMMAND = "__refresh-update-cache";
 var COMPLETE_COMMAND = "__complete";
 var EXIT_DOWN = 1;
 var EXIT_ERROR = 2;
+var DETECT_PORTS = [3e3, 3001, 4200, 4321, 5173, 8e3, 8080];
+var DETECT_PORTS_ENV = "PROBE_DETECT_PORTS";
+var DETECT_TIMEOUT_MS = 300;
 
 // src/errors.ts
 var ProbeError = class extends Error {
@@ -359,14 +362,17 @@ export {
   COMPLETE_COMMAND,
   EXIT_DOWN,
   EXIT_ERROR,
+  DETECT_PORTS,
+  DETECT_PORTS_ENV,
+  DETECT_TIMEOUT_MS,
   ProbeError,
+  targetUrl,
+  curlCommand,
   createColors,
   detectTerminal,
   isInteractive,
   truncate,
   stripStyles,
-  targetUrl,
-  curlCommand,
   runChecks,
   formatCheckResults,
   formatServices

package/dist/cli.js

@@ -11,6 +11,9 @@ import {
   DEFAULT_WAIT_INTERVAL_SECONDS,
   DEFAULT_WAIT_MAX_INTERVAL_SECONDS,
   DEFAULT_WAIT_TIMEOUT_SECONDS,
+  DETECT_PORTS,
+  DETECT_PORTS_ENV,
+  DETECT_TIMEOUT_MS,
   EXIT_DOWN,
   EXIT_ERROR,
   LOCAL_DRAFT_FILE,
@@ -37,7 +40,7 @@ import {
   runChecks,
   stripStyles,
   targetUrl
-} from "./chunk-YTTYVEYF.js";
+} from "./chunk-Z4F2X5IS.js";
 import "./chunk-M3ASEG5F.js";
 
 // src/cli.ts
@@ -97,18 +100,311 @@ async function ask(message, question = {}, streams = {}) {
   if (isCancel(answer)) return null;
   return answer || (defaultValue ?? "");
 }
+async function choose(message, choices, streams = {}) {
+  const { multiselect, isCancel } = await import("./dist-SITQEC3X.js");
+  const options = choices.map((choice, value) => ({ value, ...choice }));
+  const picked = await multiselect({ message, options, required: false, ...streams });
+  return isCancel(picked) ? null : picked;
+}
+
+// src/detect/index.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+
+// src/detect/sources/compose.ts
+import { parse } from "yaml";
+
+// src/detect/shared.ts
+var DEFAULT_HOST = "localhost";
+var DEFAULT_NAME = "app";
+var NOT_HTTP_PORTS = [
+  25,
+  443,
+  465,
+  587,
+  1025,
+  1433,
+  2181,
+  3306,
+  5432,
+  5672,
+  6379,
+  8443,
+  9092,
+  11211,
+  27017
+];
+var isHttpPort = (port) => !NOT_HTTP_PORTS.includes(port);
+var address = (service) => `${service.host ?? DEFAULT_HOST}:${service.port}`;
+function serviceName(text) {
+  const name = text.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^[-_]+|[-_]+$/g, "");
+  return name || DEFAULT_NAME;
+}
+var ENV_LINE = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*?)\s*$/;
+function unquoted(value) {
+  const quote = value[0];
+  const quoted2 = (quote === '"' || quote === "'") && value.endsWith(quote) && value.length > 1;
+  return quoted2 ? value.slice(1, -1) : value;
+}
+function parseEnvFile(text) {
+  const entries = [];
+  for (const line of text.split("\n")) {
+    const [, key, raw] = ENV_LINE.exec(line) ?? [];
+    if (key && raw !== void 0) entries.push([key, unquoted(raw)]);
+  }
+  return entries;
+}
+
+// src/detect/sources/compose.ts
+var COMPOSE_FILES = ["compose.yaml", "compose.yml", "docker-compose.yaml", "docker-compose.yml"];
+var OVERRIDE_FILES = [
+  "compose.override.yaml",
+  "compose.override.yml",
+  "docker-compose.override.yaml",
+  "docker-compose.override.yml"
+];
+var VARIABLES_FILE = ".env";
+var VARIABLE = /\$\{([A-Za-z_][A-Za-z0-9_]*)(?:(:?-)([^}]*))?\}|\$([A-Za-z_][A-Za-z0-9_]*)/g;
+var PORT = /^\d+$/;
+var substituted = (text, variables) => text.replace(VARIABLE, (_match, braced, operator, fallback, bare) => {
+  const value = variables.get(braced ?? bare);
+  const missing = value === void 0 || operator === ":-" && value === "";
+  return missing ? fallback ?? "" : value;
+});
+function published(entry, variables) {
+  let host;
+  let container;
+  if (typeof entry === "string") {
+    const [mapping = "", protocol = "tcp"] = substituted(entry, variables).split("/");
+    if (protocol !== "tcp") return null;
+    const parts = mapping.split(":");
+    if (parts.length < 2) return null;
+    [host = "", container = ""] = parts.slice(-2);
+  } else if (entry && typeof entry === "object") {
+    const long = entry;
+    if ((long.protocol ?? "tcp") !== "tcp") return null;
+    host = substituted(String(long.published ?? ""), variables);
+    container = String(long.target ?? "");
+  } else {
+    return null;
+  }
+  if (!PORT.test(host) || !PORT.test(container)) return null;
+  return { host: Number(host), container: Number(container) };
+}
+function inFile(file, text, variables) {
+  let document;
+  try {
+    document = parse(text, { merge: true }) ?? {};
+  } catch {
+    return [];
+  }
+  if (!document.services || typeof document.services !== "object") return [];
+  const found = [];
+  for (const [name, definition] of Object.entries(document.services)) {
+    const ports = definition?.ports;
+    if (!Array.isArray(ports)) continue;
+    const reachable = ports.map((entry) => published(entry, variables)).filter((port) => port !== null).filter((port) => isHttpPort(port.host) && isHttpPort(port.container));
+    reachable.forEach(({ host }, index) => {
+      found.push({
+        // A service that publishes several ports: the first keeps its name.
+        name: serviceName(index === 0 ? name : `${name}-${host}`),
+        service: { port: host },
+        source: `${file} (${name} service)`
+      });
+    });
+  }
+  return found;
+}
+var composeSource = {
+  id: "compose",
+  async find({ read }) {
+    const variables = new Map(parseEnvFile(await read(VARIABLES_FILE) ?? ""));
+    const found = [];
+    for (const names of [COMPOSE_FILES, OVERRIDE_FILES]) {
+      for (const file of names) {
+        const text = await read(file);
+        if (text === null) continue;
+        found.push(...inFile(file, text, variables));
+        break;
+      }
+    }
+    return found;
+  }
+};
+
+// src/detect/sources/env.ts
+var ENV_FILES = [".env", ".env.local"];
+var LOCAL_HOSTS = [DEFAULT_HOST, "127.0.0.1", "::1"];
+var URL_KEY = /^(?:VITE_|NEXT_PUBLIC_|REACT_APP_|PUBLIC_)?(.*)_URL$/;
+function serviceOfUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return null;
+  }
+  const host = url.hostname.replace(/^\[|\]$/g, "");
+  if (url.protocol !== "http:" || !LOCAL_HOSTS.includes(host)) return null;
+  const service = { port: Number(url.port || 80) };
+  if (host !== DEFAULT_HOST) service.host = host;
+  if (url.pathname !== "/") service.path = url.pathname;
+  return service;
+}
+function inFile2(file, text) {
+  const found = [];
+  for (const [key, value] of parseEnvFile(text)) {
+    const source = `${file} (${key})`;
+    const urlName = URL_KEY.exec(key)?.[1];
+    if (key === "PORT" && /^\d+$/.test(value)) {
+      found.push({ name: DEFAULT_NAME, service: { port: Number(value) }, source });
+    } else if (urlName !== void 0) {
+      const service = serviceOfUrl(value);
+      if (service) found.push({ name: serviceName(urlName), service, source });
+    }
+  }
+  return found;
+}
+var envSource = {
+  id: "env",
+  async find({ read }) {
+    const found = [];
+    for (const file of ENV_FILES) {
+      const text = await read(file);
+      if (text !== null) found.push(...inFile2(file, text));
+    }
+    return found;
+  }
+};
+
+// src/detect/sources/package-json.ts
+var MANIFEST = "package.json";
+var SCRIPT_PORT = /(?:--port[= ]|-p |\bPORT=)(\d{2,5})\b/;
+var TOOL_PORTS = [
+  [/\bvite\b/, 5173],
+  [/\bnext\b/, 3e3],
+  [/\bnuxt\b/, 3e3],
+  [/\bastro\b/, 4321],
+  [/\bng serve\b/, 4200]
+];
+var MAIN_SCRIPTS = ["dev", "start", "serve"];
+function inManifest(text) {
+  let manifest;
+  try {
+    manifest = JSON.parse(text);
+  } catch {
+    return [];
+  }
+  if (!manifest.scripts || typeof manifest.scripts !== "object") return [];
+  const project = typeof manifest.name === "string" ? manifest.name.replace(/^@[^/]*\//, "") : "";
+  const found = [];
+  for (const [script, command] of Object.entries(manifest.scripts)) {
+    if (typeof command !== "string") continue;
+    const main2 = MAIN_SCRIPTS.includes(script);
+    const named = SCRIPT_PORT.exec(command)?.[1];
+    const usual = main2 ? TOOL_PORTS.find(([tool]) => tool.test(command))?.[1] : void 0;
+    const port = named ? Number(named) : usual;
+    if (port === void 0) continue;
+    const name = serviceName(main2 ? project : script);
+    found.push({ name, service: { port }, source: `${MANIFEST} (${script} script)` });
+  }
+  return found;
+}
+var packageJsonSource = {
+  id: "package-json",
+  async find({ read }) {
+    const text = await read(MANIFEST);
+    return text === null ? [] : inManifest(text);
+  }
+};
+
+// src/detect/sources/ports.ts
+function detectPorts(env) {
+  const listed = env[DETECT_PORTS_ENV];
+  if (listed === void 0) return [...DETECT_PORTS];
+  return listed.split(",").map((port) => Number(port.trim())).filter((port) => Number.isInteger(port) && port > 0 && port <= 65535);
+}
+async function answersHttp(port) {
+  const url = targetUrl(serviceSchemaV1.parse({ port }));
+  try {
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(DETECT_TIMEOUT_MS),
+      redirect: "manual"
+    });
+    await response.body?.cancel();
+    return true;
+  } catch {
+    return false;
+  }
+}
+var portsSource = {
+  id: "ports",
+  async find({ ports, answers, isKnown }) {
+    const tried = ports.filter((port) => !isKnown({ port }));
+    const open = await Promise.all(
+      tried.map(async (port) => await answers(port) ? port : null)
+    );
+    return open.filter((port) => port !== null).map(
+      (port) => ({
+        name: `port-${port}`,
+        service: { port },
+        source: `answers on ${DEFAULT_HOST}:${port}`
+      })
+    );
+  }
+};
+
+// src/detect/registry.ts
+var SOURCES = [
+  composeSource,
+  envSource,
+  packageJsonSource,
+  portsSource
+];
+
+// src/detect/index.ts
+async function detectServices(root, existing, { read, sources, ports, answers }) {
+  const names = new Set(Object.keys(existing));
+  const addresses = new Set(Object.values(existing).map(address));
+  const kept = [];
+  const context = {
+    ports,
+    answers,
+    read: (file) => read(join(root, file)),
+    isKnown: (service) => addresses.has(address(service))
+  };
+  for (const source of sources) {
+    for (const { name, service, source: origin } of await source.find(context)) {
+      const valid = serviceSchemaV1.safeParse(service).success && SERVICE_NAME_PATTERN.test(name);
+      if (!valid || !isHttpPort(service.port) || context.isKnown(service)) continue;
+      let free = name;
+      for (let suffix = 2; names.has(free); suffix++) free = `${name}-${suffix}`;
+      names.add(free);
+      addresses.add(address(service));
+      kept.push({ name: free, service, source: origin });
+    }
+  }
+  return kept;
+}
+function systemDeps(env) {
+  return {
+    read: (path) => readFile(path, "utf8").catch(() => null),
+    sources: SOURCES,
+    ports: detectPorts(env),
+    answers: answersHttp
+  };
+}
 
 // src/config/discovery.ts
 import { statSync } from "fs";
-import { dirname, join, resolve } from "path";
+import { dirname, join as join2, resolve } from "path";
 function pathsFor(root) {
-  const dir = join(root, PROBE_DIR);
+  const dir = join2(root, PROBE_DIR);
   return {
     root,
     dir,
-    config: join(dir, CONFIG_FILE),
-    lock: join(dir, LOCK_FILE),
-    local: join(dir, LOCAL_FILE)
+    config: join2(dir, CONFIG_FILE),
+    lock: join2(dir, LOCK_FILE),
+    local: join2(dir, LOCAL_FILE)
   };
 }
 function isDirectory(path) {
@@ -117,7 +413,7 @@ function isDirectory(path) {
 function findProbeDir(startDir) {
   let current = resolve(startDir);
   while (true) {
-    if (isDirectory(join(current, PROBE_DIR))) return pathsFor(current);
+    if (isDirectory(join2(current, PROBE_DIR))) return pathsFor(current);
     const parent = dirname(current);
     if (parent === current) return null;
     current = parent;
@@ -135,8 +431,8 @@ function requireProbeDir(startDir) {
 }
 
 // src/config/loader.ts
-import { copyFile, readFile, writeFile } from "fs/promises";
-import { join as join2, relative } from "path";
+import { copyFile, readFile as readFile2, writeFile } from "fs/promises";
+import { join as join3, relative } from "path";
 import { parseDocument } from "yaml";
 
 // src/config/migrations.ts
@@ -245,7 +541,7 @@ function reconcileDocument(doc, value) {
 async function readDocument(paths) {
   let text;
   try {
-    text = await readFile(paths.config, "utf8");
+    text = await readFile2(paths.config, "utf8");
   } catch {
     throw new ProbeError("CONFIG_MISSING", `cannot read ${paths.config}. Run \`probe init\`.`);
   }
@@ -278,7 +574,7 @@ ${formatIssues(result.error)}`
   return result.data;
 }
 function backupPath(paths, version) {
-  return join2(paths.dir, `config.v${version}.bak.yml`);
+  return join3(paths.dir, `config.v${version}.bak.yml`);
 }
 async function pendingMigration(paths, options = {}) {
   const { raw } = await readDocument(paths);
@@ -317,12 +613,12 @@ async function writeServiceTimeout(paths, name, seconds2) {
 }
 
 // src/makefile/sync.ts
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { join as join3 } from "path";
+import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import { join as join4 } from "path";
 
 // src/config/lock.ts
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { parse, stringify } from "yaml";
+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(),
@@ -331,7 +627,7 @@ var lockSchema = z2.object({
 var HEADER = "# Generated by probe. Do not edit.\n";
 async function readLock(paths) {
   try {
-    const result = lockSchema.safeParse(parse(await readFile2(paths.lock, "utf8")));
+    const result = lockSchema.safeParse(parse2(await readFile3(paths.lock, "utf8")));
     return result.success ? result.data : null;
   } catch {
     return null;
@@ -342,7 +638,7 @@ async function writeLock(paths, lock) {
 }
 
 // src/version.ts
-var CLI_VERSION = true ? "0.7.0" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.8.0" : "0.0.0-dev";
 
 // src/makefile/generator.ts
 import { createHash } from "crypto";
@@ -403,11 +699,11 @@ function replaceBlock(makefile, block) {
 
 // src/makefile/sync.ts
 function makefilePath(paths) {
-  return join3(paths.root, DEFAULT_MAKEFILE);
+  return join4(paths.root, DEFAULT_MAKEFILE);
 }
 async function readMakefile(paths) {
   try {
-    return await readFile3(makefilePath(paths), "utf8");
+    return await readFile4(makefilePath(paths), "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
@@ -475,6 +771,28 @@ async function saveServices(loaded, services) {
   );
 }
 
+// src/commands/detected.ts
+async function offerDetected(loaded) {
+  const services = rawServices(loaded);
+  const candidates = await detectServices(loaded.paths.root, services, systemDeps(process.env));
+  if (candidates.length === 0) return [];
+  const urls = candidates.map(({ service }) => targetUrl(serviceSchemaV1.parse(service)));
+  const nameWidth = Math.max(...candidates.map(({ name }) => name.length));
+  const urlWidth = Math.max(...urls.map((url) => url.length));
+  const choices = candidates.map(({ name, source }, index) => ({
+    label: `${name.padEnd(nameWidth)}  ${(urls[index] ?? "").padEnd(urlWidth)}  ${source}`
+  }));
+  const picked = await choose("Services found here: which ones to add?", choices);
+  if (picked === null) return null;
+  const added = picked.map((index) => candidates[index]).filter((candidate) => !!candidate);
+  if (added.length === 0) return [];
+  const entries = Object.fromEntries(added.map(({ name, service }) => [name, service]));
+  await saveServices(loaded, { ...services, ...entries });
+  const names = added.map(({ name }) => name);
+  console.log(`Added ${names.join(", ")}. Try: probe check`);
+  return names;
+}
+
 // src/commands/add.ts
 function parseInteger(value, flag) {
   if (!/^\d+$/.test(value)) {
@@ -509,6 +827,12 @@ function expectProblem(expect) {
 async function guidedAdd() {
   const loaded = await openProject();
   const services = rawServices(loaded);
+  const detected = await offerDetected(loaded);
+  if (detected === null) {
+    console.log("Nothing added.");
+    return;
+  }
+  if (detected.length > 0) return;
   const answers = [];
   const questions = [
     {
@@ -584,8 +908,8 @@ var add_default = defineCommand({
 import { defineCommand as defineCommand2 } from "citty";
 
 // 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 { chmod, readFile as readFile5, realpath, rename, rm, stat, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname2, join as join5 } from "path";
 import { isMap as isMap2, isScalar as isScalar2, parseDocument as parseDocument2 } from "yaml";
 var SECTION = "dashboard";
 var KEYS = ["interval", "timeout"];
@@ -596,7 +920,7 @@ function isDelay(value) {
 }
 async function readLocal(paths) {
   try {
-    return await readFile4(paths.local, "utf8");
+    return await readFile5(paths.local, "utf8");
   } catch {
     return null;
   }
@@ -637,7 +961,7 @@ async function editLocal(paths, edit) {
   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);
+  const draft = join5(dirname2(target), LOCAL_DRAFT_FILE);
   try {
     await writeFile4(draft, text, { mode });
     await chmod(draft, mode);
@@ -896,8 +1220,8 @@ var curl_default = defineCommand4({
 
 // src/commands/init.ts
 import { existsSync } from "fs";
-import { mkdir, readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-import { join as join5 } from "path";
+import { mkdir, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import { join as join6 } from "path";
 import { defineCommand as defineCommand5 } 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\`.
@@ -905,8 +1229,8 @@ schemaVersion: ${CURRENT_SCHEMA_VERSION}
 services: {}
 `;
 async function ignoreLocalFiles(root) {
-  const file = join5(root, ".gitignore");
-  const current = existsSync(file) ? await readFile5(file, "utf8") : "";
+  const file = join6(root, ".gitignore");
+  const current = existsSync(file) ? await readFile6(file, "utf8") : "";
   const lines = current.split("\n").map((line) => line.trim());
   const missing = IGNORED.filter((entry) => !lines.includes(entry));
   if (missing.length === 0) return;
@@ -930,7 +1254,14 @@ var init_default = defineCommand5({
   },
   async run() {
     await initProject(process.cwd());
-    console.log(`Created ${PROBE_DIR}/. Next: probe add api -p 3000`);
+    const next = "Next: probe add api -p 3000";
+    if (!isInteractive(process.stdin, process.stdout, process.env)) {
+      console.log(`Created ${PROBE_DIR}/. ${next}`);
+      return;
+    }
+    console.log(`Created ${PROBE_DIR}/.`);
+    const added = await offerDetected(await openProject());
+    if (!added || added.length === 0) console.log(next);
   }
 });
 
@@ -1032,16 +1363,16 @@ import { defineCommand as defineCommand10 } from "citty";
 import { spawn } from "child_process";
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
 import { homedir } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 function cacheDir(env = process.env) {
-  return join6(env.XDG_CACHE_HOME || join6(homedir(), ".cache"), "probe");
+  return join7(env.XDG_CACHE_HOME || join7(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(join6(dir, UPDATE_CACHE_FILE), "utf8"));
+    const cache = JSON.parse(readFileSync(join7(dir, UPDATE_CACHE_FILE), "utf8"));
     return typeof cache.checkedAt === "number" ? cache : null;
   } catch {
     return null;
@@ -1049,11 +1380,11 @@ function readCache(dir) {
 }
 function writeCache(dir, cache) {
   mkdirSync(dir, { recursive: true });
-  writeFileSync(join6(dir, UPDATE_CACHE_FILE), JSON.stringify(cache));
+  writeFileSync(join7(dir, UPDATE_CACHE_FILE), JSON.stringify(cache));
 }
 function isNewer(latest, current) {
-  const parse3 = (version) => (version.split("-")[0] ?? "").split(".").map(Number);
-  const [a, b] = [parse3(latest), parse3(current)];
+  const parse4 = (version) => (version.split("-")[0] ?? "").split(".").map(Number);
+  const [a, b] = [parse4(latest), parse4(current)];
   for (let index = 0; index < 3; index++) {
     const difference = (a[index] || 0) - (b[index] || 0);
     if (difference !== 0) return difference > 0;
@@ -1273,13 +1604,13 @@ var wait_default = defineCommand12({
 });
 
 // src/completion/services.ts
-import { readFile as readFile6 } from "fs/promises";
-import { parse as parse2 } from "yaml";
+import { readFile as readFile7 } from "fs/promises";
+import { parse as parse3 } from "yaml";
 async function completableServices(cwd) {
   try {
     const paths = findProbeDir(cwd);
     if (!paths) return [];
-    const raw = parse2(await readFile6(paths.config, "utf8"));
+    const raw = parse3(await readFile7(paths.config, "utf8"));
     const services = raw?.services;
     if (typeof services !== "object" || services === null) return [];
     return Object.keys(services).filter((name) => SERVICE_NAME_PATTERN.test(name));
@@ -1479,7 +1810,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-T3OQH2O4.js");
+  const { openDashboard } = await import("./open-2H7PHDYL.js");
   let settings = initialDashboardSettings(askedMs, await readDashboardPreferences(paths));
   const saves = createSaveQueue();
   const local = `${PROBE_DIR}/${LOCAL_FILE}`;

package/dist/{open-T3OQH2O4.js → open-2H7PHDYL.js}

@@ -7,7 +7,7 @@ import {
   formatCheckResults,
   runChecks,
   truncate
-} from "./chunk-YTTYVEYF.js";
+} from "./chunk-Z4F2X5IS.js";
 import {
   __commonJS,
   __export,

package/package.json

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