@ninhache/probe 0.5.0 → 0.7.0

package/dist/cli.js

@@ -3,6 +3,7 @@ import { createRequire as __createRequire } from "node:module";
 const require = __createRequire(import.meta.url);
 import {
   BACKUP_GLOB,
+  COMPLETE_COMMAND,
   CONFIG_FILE,
   DASHBOARD_INTERVAL_SECONDS,
   DEFAULT_MAKEFILE,
@@ -28,18 +29,20 @@ import {
   WAIT_BACKOFF_FACTOR,
   WAIT_LAST_PASS_MS,
   createColors,
+  curlCommand,
   detectTerminal,
   formatCheckResults,
   formatServices,
   isInteractive,
   runChecks,
-  stripStyles
-} from "./chunk-4VXL4OTD.js";
+  stripStyles,
+  targetUrl
+} from "./chunk-YTTYVEYF.js";
 import "./chunk-M3ASEG5F.js";
 
 // src/cli.ts
 import {
-  defineCommand as defineCommand10,
+  defineCommand as defineCommand13,
   renderUsage,
   runCommand,
   runMain
@@ -48,6 +51,53 @@ 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");
+  const answer = await ask2({ message, initialValue: false, ...streams });
+  return !isCancel(answer) && answer;
+}
+async function ask(message, question = {}, streams = {}) {
+  const { text, isCancel } = await import("./dist-SITQEC3X.js");
+  const { placeholder, defaultValue, validate: validate2 } = question;
+  const answer = await text({
+    message,
+    placeholder,
+    defaultValue,
+    validate: (typed) => {
+      const value = typed ?? "";
+      return value === "" && defaultValue !== void 0 ? void 0 : validate2?.(value);
+    },
+    ...streams
+  });
+  if (isCancel(answer)) return null;
+  return answer || (defaultValue ?? "");
+}
+
 // src/config/discovery.ts
 import { statSync } from "fs";
 import { dirname, join, resolve } from "path";
@@ -89,30 +139,6 @@ import { copyFile, readFile, writeFile } from "fs/promises";
 import { join as join2, relative } from "path";
 import { parseDocument } from "yaml";
 
-// 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/migrations.ts
 var migrations = {};
 function formatIssues(error) {
@@ -316,7 +342,7 @@ async function writeLock(paths, lock) {
 }
 
 // src/version.ts
-var CLI_VERSION = true ? "0.5.0" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.7.0" : "0.0.0-dev";
 
 // src/makefile/generator.ts
 import { createHash } from "crypto";
@@ -331,13 +357,15 @@ function renderBlock(serviceNames) {
   return [
     BLOCK_START,
     `PROBE ?= $(shell command -v probe >/dev/null 2>&1 && echo probe || echo "${fallback}")`,
-    `.PHONY: ${["help", "check", "status", ...targets].join(" ")}`,
+    `.PHONY: ${["help", "check", "status", "probe", ...targets].join(" ")}`,
     "help: ## List available targets",
     `	${HELP_RECIPE}`,
     "check: ## Check that every service responds",
     "	@$(PROBE) check",
     "status: ## Show probe status",
     "	@$(PROBE) status",
+    "probe: ## Open the dashboard",
+    "	@$(PROBE)",
     ...serviceNames.flatMap((name) => [
       `check-${name}: ## Check ${name}`,
       `	@$(PROBE) check ${name}`
@@ -426,6 +454,11 @@ function secondsToMs(option, value) {
   }
   return Math.ceil(seconds2 * 1e3);
 }
+function namedService(config, name) {
+  const service = Object.hasOwn(config.services, name) ? config.services[name] : void 0;
+  if (!service) throw new ProbeError("SERVICE_UNKNOWN", `unknown service "${name}". See: probe ls`);
+  return service;
+}
 function rawServices(loaded) {
   return loaded.raw.services ?? {};
 }
@@ -453,6 +486,65 @@ 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);
+  const answers = [];
+  const questions = [
+    {
+      message: "Service name",
+      placeholder: "api",
+      validate: (v) => nameProblem(v, services)
+    },
+    { message: "Port", placeholder: "3000", validate: portProblem },
+    {
+      message: "Path to request",
+      placeholder: DEFAULT_PATH,
+      defaultValue: DEFAULT_PATH,
+      validate: (v) => schemaProblem(serviceSchemaV1.shape.path, v)
+    },
+    {
+      message: "Expected status",
+      placeholder: "any 2xx",
+      defaultValue: "",
+      validate: expectProblem
+    }
+  ];
+  for (const { message, ...question } of questions) {
+    const answer = await ask(message, question);
+    if (answer === null) {
+      console.log("Nothing added.");
+      return;
+    }
+    answers.push(answer);
+  }
+  const [name, port, path, expect] = answers;
+  const service = { port: Number(port) };
+  if (path !== DEFAULT_PATH) service.path = path;
+  if (expect) service.expect = parseExpect(expect);
+  await saveServices(loaded, { ...services, [name]: service });
+  console.log(`Added ${name}. Try: probe check ${name}`);
+}
 var add_default = defineCommand({
   meta: { name: "add", description: "Add a service" },
   args: {
@@ -466,25 +558,25 @@ var add_default = defineCommand({
       description: `Seconds to wait for this service (default: ${DEFAULT_TIMEOUT_SECONDS})`
     }
   },
-  async run({ args }) {
+  async run({ args: args2 }) {
     const loaded = await openProject();
     const services = rawServices(loaded);
-    if (Object.hasOwn(services, args.name)) {
+    if (Object.hasOwn(services, args2.name)) {
       throw new ProbeError(
         "SERVICE_EXISTS",
-        `service "${args.name}" already exists. Remove it first: probe rm ${args.name}`
+        `service "${args2.name}" already exists. Remove it first: probe rm ${args2.name}`
       );
     }
-    const service = { port: parseInteger(String(args.port), "--port") };
-    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);
+    const service = { port: parseInteger(String(args2.port), "--port") };
+    if (args2.host) service.host = args2.host;
+    if (args2.path) service.path = args2.path;
+    if (args2.expect) service.expect = parseExpect(String(args2.expect));
+    if (args2.timeout !== void 0) {
+      secondsToMs("--timeout", String(args2.timeout));
+      service.timeout = Number(args2.timeout);
     }
-    await saveServices(loaded, { ...services, [args.name]: service });
-    console.log(`Added ${args.name}. Try: probe check ${args.name}`);
+    await saveServices(loaded, { ...services, [args2.name]: service });
+    console.log(`Added ${args2.name}. Try: probe check ${args2.name}`);
   }
 });
 
@@ -606,13 +698,13 @@ var check_default = defineCommand2({
       description: `Seconds to wait for each service (default: its own timeout, else ${DEFAULT_TIMEOUT_SECONDS})`
     }
   },
-  async run({ args }) {
-    const forceTimeout = args.timeout !== void 0;
-    const timeoutMs = secondsToMs("--timeout", args.timeout ?? String(DEFAULT_TIMEOUT_SECONDS));
+  async run({ args: args2 }) {
+    const forceTimeout = args2.timeout !== void 0;
+    const timeoutMs = secondsToMs("--timeout", args2.timeout ?? String(DEFAULT_TIMEOUT_SECONDS));
     const { config, paths } = await openProject();
     const skipped = await readSkippedServices(paths);
-    const results = await runChecks(config, args._, { timeoutMs, forceTimeout }, skipped);
-    if (args.json) {
+    const results = await runChecks(config, args2._, { timeoutMs, forceTimeout }, skipped);
+    if (args2.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");
@@ -623,11 +715,190 @@ var check_default = defineCommand2({
   }
 });
 
+// src/commands/completion.ts
+import { defineCommand as defineCommand3 } from "citty";
+
+// src/completion/spec.ts
+var SHELLS = ["zsh", "bash", "fish"];
+var COMPLETION_COMMAND = "completion";
+var SERVICE_COMMANDS = ["rm", "check", "wait", "open", "curl"];
+var ROOT_OPTIONS = ["--interval", "--help", "--version"];
+var SERVICES_QUERY = `probe ${COMPLETE_COMMAND} services 2>/dev/null`;
+var HELP_OPTION = "--help";
+function completionSpec(commands2) {
+  return Object.entries(commands2).map(([name, command]) => {
+    const meta2 = command.meta ?? {};
+    const args2 = command.args ?? {};
+    const options = Object.entries(args2).filter(([, arg]) => arg.type !== "positional").map(([option]) => `--${option}`);
+    return {
+      name,
+      description: meta2.description ?? "",
+      options: [...options, HELP_OPTION],
+      words: name === COMPLETION_COMMAND ? [...SHELLS] : [],
+      services: SERVICE_COMMANDS.includes(name)
+    };
+  });
+}
+
+// src/completion/bash.ts
+function bashScript(commands2) {
+  const cases = (pick) => commands2.filter((command) => pick(command).length > 0).map((command) => `      ${command.name}) words="${pick(command).join(" ")}" ;;`);
+  const withServices = commands2.filter((command) => command.services).map(({ name }) => name);
+  return [
+    '# bash completion for probe. Load it with: eval "$(probe completion bash)"',
+    "_probe() {",
+    `  local cur="\${COMP_WORDS[COMP_CWORD]}" cmd="" words="" i`,
+    "  for ((i = 1; i < COMP_CWORD; i++)); do",
+    `    case "\${COMP_WORDS[i]}" in`,
+    "      -*) ;;",
+    `      *) cmd="\${COMP_WORDS[i]}"; break ;;`,
+    "    esac",
+    "  done",
+    '  if [ -z "$cmd" ]; then',
+    '    case "$cur" in',
+    `      -*) words="${ROOT_OPTIONS.join(" ")}" ;;`,
+    `      *) words="${commands2.map(({ name }) => name).join(" ")}" ;;`,
+    "    esac",
+    `  elif [ "\${cur#-}" != "$cur" ]; then`,
+    '    case "$cmd" in',
+    ...cases((command) => command.options),
+    "    esac",
+    "  else",
+    '    case "$cmd" in',
+    `      ${withServices.join("|")}) words="$(${SERVICES_QUERY})" ;;`,
+    ...cases((command) => command.words),
+    "    esac",
+    "  fi",
+    '  COMPREPLY=($(compgen -W "$words" -- "$cur"))',
+    "}",
+    "complete -F _probe probe",
+    ""
+  ].join("\n");
+}
+
+// src/completion/fish.ts
+var quoted = (text) => `'${text.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+var longOption = (option) => `-l ${option.replace(/^--/, "")}`;
+function fishScript(commands2) {
+  const inCommand = (names) => `-n '__fish_seen_subcommand_from ${names.join(" ")}'`;
+  const withServices = commands2.filter((command) => command.services).map(({ name }) => name);
+  return [
+    "# fish completion for probe. Load it with: probe completion fish | source",
+    "function __probe_services",
+    `    ${SERVICES_QUERY}`,
+    "end",
+    // No file names: probe takes none.
+    "complete -c probe -f",
+    ...ROOT_OPTIONS.map(
+      (option) => `complete -c probe -n __fish_use_subcommand ${longOption(option)}`
+    ),
+    ...commands2.map(
+      ({ name, description }) => `complete -c probe -n __fish_use_subcommand -a ${name} -d ${quoted(description)}`
+    ),
+    `complete -c probe ${inCommand(withServices)} -a '(__probe_services)'`,
+    ...commands2.flatMap((command) => [
+      ...command.options.map(
+        (option) => `complete -c probe ${inCommand([command.name])} ${longOption(option)}`
+      ),
+      ...command.words.length > 0 ? [`complete -c probe ${inCommand([command.name])} -a ${quoted(command.words.join(" "))}`] : []
+    ]),
+    ""
+  ].join("\n");
+}
+
+// src/completion/zsh.ts
+function described({ name, description }) {
+  const text = `${name}:${description.replaceAll(":", "\\:")}`;
+  return `'${text.replaceAll("'", "'\\''")}'`;
+}
+function zshScript(commands2) {
+  const cases = (pick) => commands2.filter((command) => pick(command).length > 0).map((command) => `    ${command.name}) compadd -- ${pick(command).join(" ")} ;;`);
+  const withServices = commands2.filter((command) => command.services).map(({ name }) => name);
+  return [
+    "#compdef probe",
+    '# zsh completion for probe. Load it after compinit with: eval "$(probe completion zsh)"',
+    "_probe() {",
+    "  local -a commands services",
+    "  commands=(",
+    ...commands2.map((command) => `    ${described(command)}`),
+    "  )",
+    "  if (( CURRENT == 2 )); then",
+    "    if [[ $words[CURRENT] == -* ]]; then",
+    `      compadd -- ${ROOT_OPTIONS.join(" ")}`,
+    "    else",
+    "      _describe 'command' commands",
+    "    fi",
+    "    return",
+    "  fi",
+    "  if [[ $words[CURRENT] == -* ]]; then",
+    "    case $words[2] in",
+    ...cases((command) => command.options).map((line) => `  ${line}`),
+    "    esac",
+    "    return",
+    "  fi",
+    "  case $words[2] in",
+    `    ${withServices.join("|")})`,
+    `      services=(\${(f)"$(${SERVICES_QUERY})"})`,
+    "      compadd -a services ;;",
+    ...cases((command) => command.words),
+    "  esac",
+    "}",
+    "if (( $+functions[compdef] )); then compdef _probe probe; fi",
+    "# Saved as _probe in $fpath, this file is the function itself: run it.",
+    'if [[ $funcstack[1] == _probe ]]; then _probe "$@"; fi',
+    ""
+  ].join("\n");
+}
+
+// src/commands/completion.ts
+var SCRIPTS = {
+  zsh: zshScript,
+  bash: bashScript,
+  fish: fishScript
+};
+var meta = {
+  name: COMPLETION_COMMAND,
+  description: `Print the shell completion script (${SHELLS.join(", ")})`
+};
+var args = {
+  shell: { type: "positional", description: SHELLS.join(", "), required: true }
+};
+function completion(others) {
+  const commands2 = { ...others, [COMPLETION_COMMAND]: { meta, args } };
+  return defineCommand3({
+    meta,
+    args,
+    run({ args: { shell } }) {
+      const script = Object.hasOwn(SCRIPTS, shell) ? SCRIPTS[shell] : void 0;
+      if (!script) {
+        throw new ProbeError(
+          "USAGE",
+          `no completion for the shell "${shell}". Supported: ${SHELLS.join(", ")}.`
+        );
+      }
+      process.stdout.write(script(completionSpec(commands2)));
+    }
+  });
+}
+
+// src/commands/curl.ts
+import { defineCommand as defineCommand4 } from "citty";
+var curl_default = defineCommand4({
+  meta: { name: "curl", description: "Print the curl command that requests a service" },
+  args: {
+    name: { type: "positional", description: "Service name", required: true }
+  },
+  async run({ args: args2 }) {
+    const { config } = await openProject();
+    console.log(curlCommand(namedService(config, args2.name)));
+  }
+});
+
 // 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 { defineCommand as defineCommand3 } from "citty";
+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\`.
 schemaVersion: ${CURRENT_SCHEMA_VERSION}
@@ -643,26 +914,29 @@ async function ignoreLocalFiles(root) {
   await writeFile5(file, `${current}${separator}${missing.join("\n")}
 `);
 }
-var init_default = defineCommand3({
+async function initProject(root) {
+  const paths = pathsFor(root);
+  if (existsSync(paths.dir)) {
+    throw new ProbeError("ALREADY_INITIALIZED", `${PROBE_DIR}/ already exists here.`);
+  }
+  await mkdir(paths.dir);
+  await writeFile5(paths.config, INITIAL_CONFIG);
+  await ignoreLocalFiles(paths.root);
+}
+var init_default = defineCommand5({
   meta: {
     name: "init",
     description: "Create .probe/ and the .gitignore entries"
   },
   async run() {
-    const paths = pathsFor(process.cwd());
-    if (existsSync(paths.dir)) {
-      throw new ProbeError("ALREADY_INITIALIZED", `${PROBE_DIR}/ already exists here.`);
-    }
-    await mkdir(paths.dir);
-    await writeFile5(paths.config, INITIAL_CONFIG);
-    await ignoreLocalFiles(paths.root);
+    await initProject(process.cwd());
     console.log(`Created ${PROBE_DIR}/. Next: probe add api -p 3000`);
   }
 });
 
 // src/commands/ls.ts
-import { defineCommand as defineCommand4 } from "citty";
-var ls_default = defineCommand4({
+import { defineCommand as defineCommand6 } from "citty";
+var ls_default = defineCommand6({
   meta: { name: "ls", description: "List services" },
   async run() {
     const { config, paths } = await openProject();
@@ -675,8 +949,8 @@ var ls_default = defineCommand4({
 });
 
 // src/commands/migrate.ts
-import { defineCommand as defineCommand5 } from "citty";
-var migrate_default = defineCommand5({
+import { defineCommand as defineCommand7 } from "citty";
+var migrate_default = defineCommand7({
   meta: { name: "migrate", description: "Migrate the config to the current schema version" },
   async run() {
     const paths = requireProbeDir(process.cwd());
@@ -688,27 +962,71 @@ var migrate_default = defineCommand5({
   }
 });
 
+// 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: {
+    name: { type: "positional", description: "Service name", required: true }
+  },
+  async run({ args: args2 }) {
+    const { config } = await openProject();
+    const url = targetUrl(namedService(config, args2.name));
+    if (await openUrl(url)) {
+      console.log(`Opened ${url}`);
+      return;
+    }
+    console.log(url);
+    console.error(`probe: ${openerCommand(process.platform)} not found, open the URL yourself.`);
+    process.exitCode = EXIT_DOWN;
+  }
+});
+
 // src/commands/rm.ts
-import { defineCommand as defineCommand6 } from "citty";
-var rm_default = defineCommand6({
+import { defineCommand as defineCommand9 } from "citty";
+var rm_default = defineCommand9({
   meta: { name: "rm", description: "Remove a service" },
   args: {
-    name: { type: "positional", description: "Service name", required: true }
+    name: { type: "positional", description: "Service name", required: true },
+    yes: { type: "boolean", alias: "y", description: "Remove without asking" }
   },
-  async run({ args }) {
+  async run({ args: args2 }) {
     const loaded = await openProject();
     const services = rawServices(loaded);
-    if (!Object.hasOwn(services, args.name)) {
-      throw new ProbeError("SERVICE_UNKNOWN", `unknown service "${args.name}". See: probe ls`);
+    if (!Object.hasOwn(services, args2.name)) {
+      throw new ProbeError("SERVICE_UNKNOWN", `unknown service "${args2.name}". See: probe ls`);
+    }
+    const asks = !args2.yes && isInteractive(process.stdin, process.stdout, process.env);
+    if (asks && !await confirm(`Remove ${args2.name}?`)) {
+      console.log("Nothing removed.");
+      return;
     }
-    const { [args.name]: _removed, ...rest } = services;
+    const { [args2.name]: _removed, ...rest } = services;
     await saveServices(loaded, rest);
-    console.log(`Removed ${args.name}.`);
+    console.log(`Removed ${args2.name}.`);
   }
 });
 
 // src/commands/status.ts
-import { defineCommand as defineCommand7 } from "citty";
+import { defineCommand as defineCommand10 } from "citty";
 
 // src/update/notifier.ts
 import { spawn } from "child_process";
@@ -734,8 +1052,8 @@ function writeCache(dir, cache) {
   writeFileSync(join6(dir, UPDATE_CACHE_FILE), JSON.stringify(cache));
 }
 function isNewer(latest, current) {
-  const parse2 = (version) => (version.split("-")[0] ?? "").split(".").map(Number);
-  const [a, b] = [parse2(latest), parse2(current)];
+  const parse3 = (version) => (version.split("-")[0] ?? "").split(".").map(Number);
+  const [a, b] = [parse3(latest), parse3(current)];
   for (let index = 0; index < 3; index++) {
     const difference = (a[index] || 0) - (b[index] || 0);
     if (difference !== 0) return difference > 0;
@@ -797,7 +1115,7 @@ function describeUpdate(colors) {
   if (!readCache(cacheDir())?.latest) return colors.dim(`not checked yet (${CLI_VERSION})`);
   return colors.green(`up to date (${CLI_VERSION})`);
 }
-var status_default = defineCommand7({
+var status_default = defineCommand10({
   meta: { name: "status", description: "Show pending migration, Makefile state and updates" },
   async run() {
     const colors = stdoutColors();
@@ -819,8 +1137,8 @@ var status_default = defineCommand7({
 
 // src/commands/sync.ts
 import { relative as relative2 } from "path";
-import { defineCommand as defineCommand8 } from "citty";
-var sync_default = defineCommand8({
+import { defineCommand as defineCommand11 } from "citty";
+var sync_default = defineCommand11({
   meta: {
     name: "sync",
     description: "Add or regenerate the probe block of the Makefile (optional)"
@@ -836,7 +1154,7 @@ var sync_default = defineCommand8({
 });
 
 // src/commands/wait.ts
-import { defineCommand as defineCommand9 } from "citty";
+import { defineCommand as defineCommand12 } from "citty";
 
 // src/checkers/poll.ts
 import { setTimeout as delay } from "timers/promises";
@@ -885,7 +1203,7 @@ function progressReporter() {
     return lines;
   };
 }
-var wait_default = defineCommand9({
+var wait_default = defineCommand12({
   meta: {
     name: "wait",
     description: "Check again and again until services are up (all of them by default)"
@@ -908,14 +1226,14 @@ var wait_default = defineCommand9({
       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"]);
+  async run({ args: args2 }) {
+    const deadlineMs = secondsToMs("--timeout", args2.timeout);
+    const intervalMs = secondsToMs("--interval", args2.interval);
+    const maxIntervalMs = secondsToMs("--max-interval", args2["max-interval"]);
     if (intervalMs > maxIntervalMs) {
       throw new ProbeError(
         "USAGE",
-        `--interval (${args.interval}s) cannot be longer than --max-interval (${args["max-interval"]}s).`
+        `--interval (${args2.interval}s) cannot be longer than --max-interval (${args2["max-interval"]}s).`
       );
     }
     const { config, paths } = await openProject();
@@ -925,7 +1243,7 @@ var wait_default = defineCommand9({
       // A service with its own timeout keeps it here, within what is left of the total.
       (_passMs, remainingMs) => runChecks(
         config,
-        args._,
+        args2._,
         { timeoutMs: DEFAULT_TIMEOUT_SECONDS * 1e3, maxTimeoutMs: remainingMs },
         skipped
       ),
@@ -939,7 +1257,7 @@ var wait_default = defineCommand9({
         }
       }
     );
-    if (args.json) {
+    if (args2.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");
@@ -954,6 +1272,22 @@ var wait_default = defineCommand9({
   }
 });
 
+// src/completion/services.ts
+import { readFile as readFile6 } from "fs/promises";
+import { parse as parse2 } from "yaml";
+async function completableServices(cwd) {
+  try {
+    const paths = findProbeDir(cwd);
+    if (!paths) return [];
+    const raw = parse2(await readFile6(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));
+  } catch {
+    return [];
+  }
+}
+
 // src/dashboard/saves.ts
 function describe(file, error) {
   const code = error?.code;
@@ -984,7 +1318,7 @@ function createSaveQueue() {
 }
 
 // src/suggest.ts
-var SHORT_WORD = 3;
+var SHORT_WORD = 4;
 var TYPOS_SHORT = 1;
 var TYPOS_LONG = 2;
 function typoDistance(a, b) {
@@ -1036,7 +1370,10 @@ var EXAMPLES = {
     { command: "probe add admin -p 8080 --expect 200,204", note: "Accept these statuses only" },
     { command: "probe add db -p 5432 --timeout 10", note: "Give it 10 s to answer" }
   ],
-  rm: [{ command: "probe rm api", note: "Remove the service named api" }],
+  rm: [
+    { command: "probe rm api", note: "Remove the service named api" },
+    { command: "probe rm api --yes", note: "Remove it without the question" }
+  ],
   ls: [{ command: "probe ls", note: "List the services and their URL" }],
   check: [
     { command: "probe check", note: "Check every service" },
@@ -1049,9 +1386,19 @@ var EXAMPLES = {
     { command: "probe wait api --timeout 120", note: "Wait for api, 2 minutes at most" },
     { command: "probe wait --interval 1 --max-interval 10", note: "Check less often" }
   ],
+  open: [{ command: "probe open front", note: "Open the URL of front in the browser" }],
+  curl: [
+    { command: "probe curl api", note: "Print the curl command for api" },
+    { command: "probe curl api | sh", note: "Run it" }
+  ],
   status: [{ command: "probe status", note: "Version, migration, Makefile block" }],
   sync: [{ command: "probe sync", note: "Write the probe block of the Makefile" }],
-  migrate: [{ command: "probe migrate", note: "Bring .probe/config.yml up to date" }]
+  migrate: [{ command: "probe migrate", note: "Bring .probe/config.yml up to date" }],
+  completion: [
+    { command: "probe completion zsh", note: 'In ~/.zshrc: eval "$(probe completion zsh)"' },
+    { command: "probe completion bash", note: 'In ~/.bashrc: eval "$(probe completion bash)"' },
+    { command: "probe completion fish | source", note: "In ~/.config/fish/config.fish" }
+  ]
 };
 function formatExamples(name, color) {
   const examples = EXAMPLES[name ?? ROOT] ?? [];
@@ -1067,7 +1414,8 @@ function formatExamples(name, color) {
 }
 
 // src/cli.ts
-var main = defineCommand10({
+var commands = { init: init_default, add: add_default, rm: rm_default, ls: ls_default, check: check_default, wait: wait_default, open: open_default, curl: curl_default, status: status_default, sync: sync_default, migrate: migrate_default };
+var main = defineCommand13({
   meta: {
     name: "probe",
     version: CLI_VERSION,
@@ -1081,13 +1429,13 @@ var main = defineCommand10({
       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 }
+  subCommands: { ...commands, completion: completion(commands) }
 });
 async function printUsage(command, parent) {
   const usage = await renderUsage(command, parent);
   const { color } = stdoutTerminal();
-  const meta = await (typeof command.meta === "function" ? command.meta() : command.meta);
-  const examples = formatExamples(command === main ? void 0 : meta?.name, color);
+  const meta2 = await (typeof command.meta === "function" ? command.meta() : command.meta);
+  const examples = formatExamples(command === main ? void 0 : meta2?.name, color);
   console.log(`${color ? usage : stripStyles(usage)}
 ${examples ? `
 ${examples}
@@ -1095,7 +1443,7 @@ ${examples}
 }
 function notifyUpdate(rawArgs) {
   const cliPath = process.argv[1];
-  if (updateCheckDisabled() || !cliPath) return;
+  if (updateCheckDisabled() || !cliPath || rawArgs[0] === COMPLETION_COMMAND) return;
   scheduleRefresh(cacheDir(), cliPath);
   if (!detectTerminal(process.stderr, process.env).isTTY || rawArgs.includes("--json") || rawArgs[0] === "status")
     return;
@@ -1131,7 +1479,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-WH6VGPQT.js");
+  const { openDashboard } = await import("./open-T3OQH2O4.js");
   let settings = initialDashboardSettings(askedMs, await readDashboardPreferences(paths));
   const saves = createSaveQueue();
   const local = `${PROBE_DIR}/${LOCAL_FILE}`;
@@ -1155,6 +1503,23 @@ async function openedDashboard(rawArgs) {
   for (const failure of saves.failures()) console.error(`probe: not saved: ${failure}`);
   return true;
 }
+async function offeredInit(error, rawArgs) {
+  if (!(error instanceof ProbeError) || error.code !== "NO_PROBE_DIR") return false;
+  if (rawArgs.includes("--json")) return false;
+  if (!isInteractive(process.stdin, process.stdout, process.env)) return false;
+  const root = process.cwd();
+  if (!await confirm(`No ${PROBE_DIR}/ here. Create it in ${root}?`)) return false;
+  await initProject(root);
+  console.log(`Created ${PROBE_DIR}/.`);
+  return true;
+}
+function wantsGuidedAdd(rawArgs) {
+  return rawArgs.length === 1 && rawArgs[0] === "add" && isInteractive(process.stdin, process.stdout, process.env);
+}
+async function dispatch(rawArgs) {
+  if (wantsGuidedAdd(rawArgs)) return guidedAdd();
+  if (!await openedDashboard(rawArgs)) await runCommand(main, { rawArgs });
+}
 var UNKNOWN_COMMAND = "E_UNKNOWN_COMMAND";
 function didYouMean(error, rawArgs) {
   if (error.code !== UNKNOWN_COMMAND) return "";
@@ -1167,13 +1532,23 @@ function flushed(stream) {
     stream.write("", () => done());
   });
 }
+async function printCompletions(kind) {
+  if (kind !== "services") return;
+  for (const name of await completableServices(process.cwd())) console.log(name);
+}
 async function run(rawArgs) {
   if (rawArgs[0] === REFRESH_COMMAND) return refreshCache(cacheDir());
+  if (rawArgs[0] === COMPLETE_COMMAND) return printCompletions(rawArgs[1]);
   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, showUsage: printUsage });
   try {
-    if (!await openedDashboard(rawArgs)) await runCommand(main, { rawArgs });
+    try {
+      await dispatch(rawArgs);
+    } catch (error) {
+      if (!await offeredInit(error, rawArgs)) throw error;
+      await dispatch(rawArgs);
+    }
   } catch (error) {
     process.exitCode = EXIT_ERROR;
     if (error instanceof ProbeError) {