@ninhache/probe 0.6.0 → 0.8.0

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
@@ -51,17 +54,357 @@ 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 ?? "");
+}
+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) {
@@ -70,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;
@@ -88,34 +431,10 @@ 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/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) {
@@ -222,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\`.`);
   }
@@ -255,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);
@@ -294,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(),
@@ -308,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;
@@ -319,7 +638,7 @@ async function writeLock(paths, lock) {
 }
 
 // src/version.ts
-var CLI_VERSION = true ? "0.6.0" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.8.0" : "0.0.0-dev";
 
 // src/makefile/generator.ts
 import { createHash } from "crypto";
@@ -380,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;
@@ -452,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)) {
@@ -463,6 +804,71 @@ 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 detected = await offerDetected(loaded);
+  if (detected === null) {
+    console.log("Nothing added.");
+    return;
+  }
+  if (detected.length > 0) return;
+  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: {
@@ -502,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"];
@@ -514,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;
   }
@@ -555,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);
@@ -814,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\`.
@@ -823,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;
@@ -832,20 +1238,30 @@ async function ignoreLocalFiles(root) {
   await writeFile5(file, `${current}${separator}${missing.join("\n")}
 `);
 }
+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 initProject(process.cwd());
+    const next = "Next: probe add api -p 3000";
+    if (!isInteractive(process.stdin, process.stdout, process.env)) {
+      console.log(`Created ${PROBE_DIR}/. ${next}`);
+      return;
     }
-    await mkdir(paths.dir);
-    await writeFile5(paths.config, INITIAL_CONFIG);
-    await ignoreLocalFiles(paths.root);
-    console.log(`Created ${PROBE_DIR}/. Next: probe add api -p 3000`);
+    console.log(`Created ${PROBE_DIR}/.`);
+    const added = await offerDetected(await openProject());
+    if (!added || added.length === 0) console.log(next);
   }
 });
 
@@ -920,7 +1336,8 @@ 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: args2 }) {
     const loaded = await openProject();
@@ -928,6 +1345,11 @@ var rm_default = defineCommand9({
     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 { [args2.name]: _removed, ...rest } = services;
     await saveServices(loaded, rest);
     console.log(`Removed ${args2.name}.`);
@@ -941,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;
@@ -958,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;
@@ -1182,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));
@@ -1279,7 +1701,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" },
@@ -1385,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}`;
@@ -1409,6 +1834,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 "";
@@ -1432,7 +1874,12 @@ async function run(rawArgs) {
   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) {