@ninhache/probe 0.6.0 → 0.7.0

package/README.md

@@ -41,7 +41,7 @@ Want `make check` too? See [Makefile](#makefile): it is optional.
 | --------------------------------------------------------- | ---------------------------------------------------------------------- |
 | `probe init`                                              | Create `.probe/` and the `.gitignore` entries                          |
 | `probe add <name> -p <port> [--host] [--path] [--expect]` | Add a service (`--timeout <seconds>` gives it its own timeout)         |
-| `probe rm <name>`                                         | Remove a service                                                       |
+| `probe rm <name> [--yes]`                                 | Remove a service                                                       |
 | `probe ls`                                                | List services                                                          |
 | `probe check [name...] [--json] [--timeout <seconds>]`    | Check all services, or the named ones                                  |
 | `probe wait [name...] [--json] [--timeout <seconds>]`     | Check again until every service is up, or give up after the timeout    |
@@ -64,10 +64,17 @@ longest one. Unlike `check --timeout`, which is the time given to each service,
 wait; each check inside it still gets 3 s, or the service's own `timeout`. Progress goes to stderr, the final
 report to stdout; exit code `1` names the services still down.
 
+`probe 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.
+
+`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.
+
 `probe open` uses `open` on macOS and `xdg-open` elsewhere. Without it, the URL is printed and the exit code is
 `1`. `probe curl api` prints a command to copy, or to run: `probe curl api | sh`.
 
-`probe` works from any sub-directory: it walks up to the nearest `.probe/`.
+`probe` works from any sub-directory: it walks up to the nearest `.probe/`. When there is none, on a terminal,
+it offers to create it where you are, then runs your command. Off a terminal it stops with exit code `2`.
 
 ## Completion
 

package/dist/cli.js

@@ -51,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";
@@ -92,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) {
@@ -319,7 +342,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.7.0" : "0.0.0-dev";
 
 // src/makefile/generator.ts
 import { createHash } from "crypto";
@@ -463,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: {
@@ -832,19 +914,22 @@ 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 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`);
   }
 });
@@ -920,7 +1005,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 +1014,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}.`);
@@ -1279,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" },
@@ -1409,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 "";
@@ -1432,7 +1543,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) {