@monster-orange/den 0.4.5 → 0.4.6

package/src/ui/cli/doctor-onboard.ts

@@ -0,0 +1,291 @@
+/**
+ * `doctor --json`'s onboarding checks (ON-2): what an agent setting Den up
+ * needs to know, each `ok`, `warn` or `fail`, with a command the agent can
+ * run (`fix`) or a question for the person (`ask`).
+ *
+ * - node: Node 22.13 or later.
+ * - git: on PATH.
+ * - docker: only when a registered repo needs it (a compose file or block,
+ *   or a docker command), then installed and its daemon answering.
+ * - web: the web server answers at its URL (and is this distribution's).
+ * - mcp: Den's MCP one-shot (`<cli> mcp --call workspaces`) gets an answer
+ *   from that web server: the path every agent's tools take.
+ *
+ * Every probe is injected (OnboardDeps), so tests never depend on this
+ * machine's Docker, Node or web server. defaultOnboardDeps() wires the real
+ * ones; only the docker and mcp probes spawn, each bounded by a timeout.
+ */
+import { spawnSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { product } from "../../shared/product.js";
+import { getDistRoot } from "../../shared/paths.js";
+import { readManifest } from "../../shared/manifest/read-manifest.js";
+import {
+  DEN_SERVICES_DIR,
+  readWorkspacesFile,
+} from "../../shared/environment-manager/workspaces.js";
+import { readWebPort } from "../../shared/edge/config.js";
+import { DEFAULT_PORT } from "../../shared/constants.js";
+import { needsDocker } from "./repo-detect.js";
+import type { WebProbe } from "./mcp-connect.js";
+
+export type CheckStatus = "ok" | "warn" | "fail";
+
+export interface OnboardCheck {
+  id: string;
+  status: CheckStatus;
+  detail: string;
+  /** A command the agent can run to fix it. */
+  fix?: string;
+  /** A question for the person, when only they can fix it. */
+  ask?: string;
+  /** The web server's URL and port (the web check). */
+  url?: string;
+  port?: number;
+}
+
+export interface OnboardDeps {
+  /** process.versions.node */
+  nodeVersion: string;
+  platform: NodeJS.Platform;
+  /** Whether an executable is on PATH. */
+  which: (bin: string) => boolean;
+  /** The registered repos that need Docker. */
+  dockerRepos: () => string[];
+  /** Whether the Docker daemon answers (`docker info`). */
+  dockerUp: () => boolean;
+  webUrl: string;
+  probeWeb: (url: string) => Promise<WebProbe>;
+  /** The MCP one-shot against the web server: exit 0, or why not. */
+  mcpCall: () => { ok: boolean; detail?: string };
+  /** The command an agent runs, e.g. `./bin/acme`. */
+  bin: string;
+}
+
+export const MIN_NODE = [22, 13] as const;
+
+/** Whether `version` ("22.13.0", "v24.1.0") is at least 22.13. */
+export function nodeOk(version: string): boolean {
+  const [maj, min] = version.replace(/^v/, "").split(".").map(Number);
+  if (!Number.isFinite(maj)) return false;
+  return (
+    maj > MIN_NODE[0] || (maj === MIN_NODE[0] && (min ?? 0) >= MIN_NODE[1])
+  );
+}
+
+export async function onboardingChecks(
+  d: OnboardDeps,
+): Promise<OnboardCheck[]> {
+  const out: OnboardCheck[] = [];
+  const mac = d.platform === "darwin";
+
+  out.push(
+    nodeOk(d.nodeVersion)
+      ? { id: "node", status: "ok", detail: `Node ${d.nodeVersion}` }
+      : {
+          id: "node",
+          status: "fail",
+          detail: `Node ${d.nodeVersion} is older than ${MIN_NODE.join(".")}`,
+          fix: "nvm install 22 && nvm use 22",
+          ask: `Den needs Node ${MIN_NODE.join(".")} or later. May I install it with your usual Node installer (nvm, or brew install node)?`,
+        },
+  );
+
+  out.push(
+    d.which("git")
+      ? { id: "git", status: "ok", detail: "git is on PATH" }
+      : {
+          id: "git",
+          status: "fail",
+          detail: "git is not on PATH",
+          ...(mac ? { fix: "xcode-select --install" } : {}),
+          ask: "Den needs git. May I install it (on macOS: xcode-select --install)?",
+        },
+  );
+
+  const repos = d.dockerRepos();
+  if (repos.length === 0)
+    out.push({
+      id: "docker",
+      status: "ok",
+      detail: "no registered repo needs Docker",
+    });
+  else if (!d.which("docker"))
+    out.push({
+      id: "docker",
+      status: "fail",
+      detail: `${repos.join(", ")} need${repos.length === 1 ? "s" : ""} Docker, and docker is not on PATH`,
+      ask: "These repos run in containers. Can you install Docker Desktop (or another Docker engine)?",
+    });
+  else if (!d.dockerUp())
+    out.push({
+      id: "docker",
+      status: "fail",
+      detail: `${repos.join(", ")} need${repos.length === 1 ? "s" : ""} Docker, and the Docker daemon is not answering`,
+      ...(mac ? { fix: "open -a Docker" } : {}),
+      ask: "Docker is installed but not running. Can you start it?",
+    });
+  else
+    out.push({
+      id: "docker",
+      status: "ok",
+      detail: `Docker is running (needed by ${repos.join(", ")})`,
+    });
+
+  const probe = await d.probeWeb(d.webUrl);
+  const webPort = Number(new URL(d.webUrl).port) || 80;
+  const webFix = `${d.bin} web up --no-open --json`;
+  if (probe.kind === "up")
+    out.push({
+      id: "web",
+      status: "ok",
+      detail: `web server up${probe.version ? ` (Den ${probe.version})` : ""}`,
+      url: d.webUrl,
+      port: webPort,
+    });
+  else if (probe.kind === "foreign")
+    out.push({
+      id: "web",
+      status: "fail",
+      detail: `${probe.who} answers at ${d.webUrl}, not this distribution's web server`,
+      url: d.webUrl,
+      port: webPort,
+      ask: `Another Den distribution already uses ${d.webUrl}. Which port should ${product().title} use instead? (web.port in config/local/user.yml)`,
+    });
+  else
+    out.push({
+      id: "web",
+      status: "fail",
+      detail:
+        probe.kind === "timeout"
+          ? `web server at ${d.webUrl} is not answering in time`
+          : `web server not running at ${d.webUrl}`,
+      url: d.webUrl,
+      port: webPort,
+      fix:
+        probe.kind === "timeout"
+          ? `${d.bin} web restart --no-open --json`
+          : webFix,
+    });
+
+  if (probe.kind !== "up")
+    out.push({
+      id: "mcp",
+      status: "fail",
+      detail: "Den's MCP reads through the web server, which is not up",
+      fix: webFix,
+    });
+  else {
+    const m = d.mcpCall();
+    out.push(
+      m.ok
+        ? {
+            id: "mcp",
+            status: "ok",
+            detail: `${d.bin} mcp --call workspaces answered`,
+          }
+        : {
+            id: "mcp",
+            status: "fail",
+            detail: `${d.bin} mcp --call workspaces failed${m.detail ? `: ${m.detail}` : ""}`,
+            fix: `${d.bin} web restart --no-open --json`,
+          },
+    );
+  }
+  return out;
+}
+
+function onPath(bin: string): boolean {
+  for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
+    if (!dir) continue;
+    try {
+      fs.accessSync(path.join(dir, bin), fs.constants.X_OK);
+      return true;
+    } catch {
+      /* next */
+    }
+  }
+  return false;
+}
+
+/** The repos in every active workspace whose manifest or files need Docker. */
+export function registeredDockerRepos(): string[] {
+  const out: string[] = [];
+  let file;
+  try {
+    file = readWorkspacesFile();
+  } catch {
+    return out;
+  }
+  for (const ws of file.active) {
+    for (const [addr, entry] of Object.entries(
+      file.workspaces[ws]?.services ?? {},
+    )) {
+      const repo = addr.split("/")[0];
+      if (out.includes(repo)) continue;
+      const dir =
+        entry.mode === "dev-managed"
+          ? entry.path
+          : path.join(DEN_SERVICES_DIR, repo, entry.branch ?? "main");
+      if (!dir) continue;
+      if (needsDocker(readManifest(dir), fs.existsSync(dir) ? dir : undefined))
+        out.push(repo);
+    }
+  }
+  return out;
+}
+
+/** The command an agent runs from the distribution root. */
+export function runnableCli(): string {
+  const cli = product().cli;
+  return fs.existsSync(path.join(getDistRoot(), "bin", cli))
+    ? `./bin/${cli}`
+    : cli;
+}
+
+export function defaultOnboardDeps(
+  probeWeb: (url: string) => Promise<WebProbe>,
+): OnboardDeps {
+  let port: number;
+  try {
+    port = readWebPort();
+  } catch {
+    port = DEFAULT_PORT;
+  }
+  const cli = product().cli;
+  const shim = path.join(getDistRoot(), "bin", cli);
+  return {
+    nodeVersion: process.versions.node,
+    platform: process.platform,
+    which: onPath,
+    dockerRepos: registeredDockerRepos,
+    dockerUp: () =>
+      spawnSync("docker", ["info", "--format", "{{.ServerVersion}}"], {
+        stdio: "ignore",
+        timeout: 10_000,
+      }).status === 0,
+    webUrl: `http://localhost:${port}`,
+    probeWeb,
+    mcpCall: () => {
+      // The shim when there is one (a distribution), else this Den's bin.
+      const cmd = fs.existsSync(shim)
+        ? shim
+        : path.join(getDistRoot(), "bin", "den");
+      const r = spawnSync(cmd, ["mcp", "--call", "workspaces"], {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: 30_000,
+      });
+      return r.status === 0
+        ? { ok: true }
+        : {
+            ok: false,
+            detail:
+              (r.stderr ?? "").trim().split("\n").pop()?.slice(0, 200) ||
+              `exit ${r.status ?? "timeout"}`,
+          };
+    },
+    bin: runnableCli(),
+  };
+}

package/src/ui/cli/flag-parser.ts

@@ -88,6 +88,8 @@ const OWN_WORKSPACE_FLAG_COMMANDS = new Set([
   // CLI's workspace override here.
   "sessions",
   "agents",
+  // `repo add -w <ws>` names (or creates) the workspace to write.
+  "repo",
 ]);
 
 /** Whether `-w <name>` on this command requires `<name>` to be active. */
@@ -181,6 +183,7 @@ export const SUBCOMMAND_OWN_HELP: Readonly<Record<string, readonly string[]>> =
   {
     web: ["token", "login", "sessions", "logout", "owner", "approve"],
     mcp: ["connect", "disconnect", "clients", "config"],
+    repo: ["add"],
   };
 
 /** Whether `<command> <sub> --help` is the subcommand's own to answer. */
@@ -209,6 +212,7 @@ const COMMAND_FLAGS: Record<string, readonly string[]> = {
     "--pull",
     "-A",
     "--app",
+    "--json",
   ],
   down: [
     "--manifest",

package/src/ui/cli/index.ts

@@ -26,6 +26,7 @@ import { envSelector } from "../../shared/environment/env-selector.js";
 import {
   recordInvocation,
   recordFailure,
+  shipFromDetachedSender,
   startTimer,
 } from "../../shared/dev-metrics/emit.js";
 import type { Environment, Pillar } from "../../shared/types/index.js";
@@ -242,6 +243,8 @@ import {
 import { DEN_BANNER_LINES, DEN_DIVIDER } from "../../shared/banner.js";
 
 import { product } from "../../shared/product.js";
+import { AGENT_SETUP_LINE } from "../../shared/agent-setup.js";
+import { ExitRequested, printJson, quietStdout } from "./json-out.js";
 const DEN_HELP_DESCRIPTION = `  ${product().title} - local-first test, service, and workspace orchestration`;
 
 /**
@@ -360,6 +363,16 @@ const COMMAND_HELP: Record<string, { usage: string; lines: string[] }> = {
       "-w writes that workspace (active or not) and leaves focus alone.",
     ],
   },
+  repo: {
+    usage:
+      'repo add <path|git-url> [--sidecar] [-w <workspace>] [--name <repo>] [--run "<cmd>"] [--health <url>] [--json]',
+    lines: [
+      "Add a repo with no prompts, never writing into it. A repo with no",
+      "manifest (or --sidecar) gets a side-car manifest in manifests/, detected",
+      "from its Makefile, compose file or package.json scripts. Safe to re-run.",
+      "`{cli} repo add --help` says more.",
+    ],
+  },
   relocate: {
     usage: "relocate <repo> <path> [--dry-run] [--force] [-w <workspace>]",
     lines: [
@@ -465,8 +478,11 @@ const COMMAND_HELP: Record<string, { usage: string; lines: string[] }> = {
     ],
   },
   doctor: {
-    usage: "doctor [--probe]",
+    usage: "doctor [--probe] [--json]",
     lines: [
+      "--json: one object, { ok, checks: [{ id, status: ok|warn|fail, detail, fix?, ask? }] }:",
+      "Node 22.13+, git, Docker (only when a registered repo needs it), the web",
+      "server and Den's MCP through it, then each strategy below. Exit 1 on a fail.",
       "Each strategy kind (secrets, tls): the one selected, whether it was implicit,",
       "and whether it can work here (a PATH check; nothing is run or prompted).",
       "--probe: start a short probe session (through the session host) for a",
@@ -575,6 +591,7 @@ const TELEMETRY_COMMANDS = new Set<string>([
   "service",
   "theme",
   "plugin",
+  "repo",
 ]);
 
 /**
@@ -678,7 +695,18 @@ function printValidation(
   }
 }
 
+/** What `up --json` collects while up runs (runServicesCommand fills it). */
+interface UpReport {
+  started: string[];
+  failed: string[];
+  alreadyRunning: string[];
+  skipped: string[];
+}
+
 class DenCLI {
+  /** Set while `up --json` runs. */
+  private upReport: UpReport | null = null;
+
   private static readonly serviceCommands = new Set([
     "up",
     "down",
@@ -715,6 +743,8 @@ class DenCLI {
     // synchronously. `telCmd` is always a REGISTERED command name (never raw
     // argv — PII); it is refined once the args parse successfully.
     const stopTimer = startTimer();
+    // The exit hook can't await a send; hand it to a detached sender.
+    shipFromDetachedSender();
     let telCmd = telemetryCommandName(args.find((a) => !a.startsWith("-")));
     process.once("exit", (code) => {
       recordInvocation({
@@ -868,13 +898,31 @@ class DenCLI {
           process.exit(0);
           break;
 
-        case "web":
+        case "web": {
+          const sub = args[1];
+          if (
+            args.includes("--json") &&
+            (sub === undefined ||
+              sub.startsWith("-") ||
+              sub === "up" ||
+              sub === "restart")
+          ) {
+            process.exitCode = await this.cmdWebUpJson(
+              args.slice(1).filter((a) => a !== "--json"),
+            );
+            break;
+          }
           await cmdWeb(args.slice(1));
           break;
+        }
 
         // ── Environment manager commands ──────────────────────────────────
         case "up":
-          await this.cmdServiceUp(args.slice(1));
+          if (args.slice(1).includes("--json"))
+            process.exitCode = await this.cmdServiceUpJson(
+              args.slice(1).filter((a) => a !== "--json"),
+            );
+          else await this.cmdServiceUp(args.slice(1));
           break;
 
         case "down":
@@ -906,6 +954,12 @@ class DenCLI {
           await this.cmdRegister(args.slice(1));
           break;
 
+        case "repo": {
+          const { cmdRepo } = await import("./repo-command.js");
+          process.exitCode = await cmdRepo(args.slice(1), validateManifest);
+          break;
+        }
+
         case "relocate":
           await this.cmdRelocate(args.slice(1));
           break;
@@ -967,7 +1021,7 @@ class DenCLI {
         case "create": {
           // bin/den routes `create` to its own entry (it needs no den.yml);
           // this covers the CLI run directly from a checkout.
-          const code = runCreate(args.slice(1), getInvokeCwd());
+          const code = await runCreate(args.slice(1), getInvokeCwd());
           if (code !== 0) process.exit(code);
           break;
         }
@@ -1829,8 +1883,10 @@ class DenCLI {
         if (isNamedTarget(address, opts?.named ?? [])) {
           console.log(chalk.red(`  ✗ ${remote}`));
           process.exitCode = 1;
+          this.upReport?.failed.push(address);
         } else {
           console.log(chalk.gray(`  • ${remote}`));
+          this.upReport?.skipped.push(address);
         }
         continue;
       }
@@ -1854,6 +1910,7 @@ class DenCLI {
             );
             // A dependency only warns; the service you named failed.
             if (isNamedTarget(address, opts?.named ?? [])) process.exitCode = 1;
+            this.upReport?.failed.push(address);
             continue;
           }
           if (health.health === "ok" && claim !== "conflict") {
@@ -1870,6 +1927,7 @@ class DenCLI {
                 `  • ${chalk.bold(address)} already healthy — skipping dependency up${suffix}`,
               ),
             );
+            if (command === "up") this.upReport?.alreadyRunning.push(address);
             continue;
           }
         }
@@ -2103,6 +2161,8 @@ class DenCLI {
       // Any target that failed makes the whole command fail (scripts and
       // agents read the exit code).
       if (!started) process.exitCode = 1;
+      if (command === "up")
+        this.upReport?.[started ? "started" : "failed"].push(address);
       if (plan?.failFast && !started) {
         console.log(
           chalk.red(
@@ -2746,6 +2806,10 @@ class DenCLI {
       "act in that (active) workspace instead of the focused one; focus stays",
     );
     row("--skip-secrets", "skip the secrets-backend sign-in preflight");
+    row(
+      "--json",
+      "log on stderr; stdout: { ok, services: [{ address, result, health }], fix? }",
+    );
     row("-h, --help", "show this help");
     console.log();
   }
@@ -3099,6 +3163,177 @@ class DenCLI {
     );
   }
 
+  /**
+   * `up --json` (ON-2): up as it always runs, its log on stderr, then one
+   * JSON object on stdout: each service it touched, what happened to it
+   * (started, already-running, failed, skipped) and its health once started
+   * (a started service with a health check is waited on, up to 30s). Safe to
+   * re-run: a healthy service is already-running. Every failure names a fix.
+   */
+  private async cmdServiceUpJson(args: string[]): Promise<number> {
+    const report: UpReport = {
+      started: [],
+      failed: [],
+      alreadyRunning: [],
+      skipped: [],
+    };
+    const bin = fs.existsSync(
+      nodePath.join(getDistRoot(), "bin", product().cli),
+    )
+      ? `./bin/${product().cli}`
+      : product().cli;
+    const before = process.exitCode;
+    process.exitCode = undefined;
+    let error: string | undefined;
+    this.upReport = report;
+    try {
+      await quietStdout(() => this.cmdServiceUp(args));
+    } catch (e) {
+      if (!(e instanceof ExitRequested)) error = (e as Error).message;
+      else if (e.code !== 0) process.exitCode = e.code;
+    } finally {
+      this.upReport = null;
+    }
+    const failedExit = process.exitCode !== undefined && process.exitCode !== 0;
+    process.exitCode = before;
+    const workspace =
+      process.env.DEN_WORKSPACE_OVERRIDE ??
+      getFocusedWorkspaceName() ??
+      undefined;
+    const result = (address: string): string =>
+      report.failed.includes(address)
+        ? "failed"
+        : report.started.includes(address)
+          ? "started"
+          : report.alreadyRunning.includes(address)
+            ? "already-running"
+            : "skipped";
+    const touched = [
+      ...new Set([
+        ...report.started,
+        ...report.alreadyRunning,
+        ...report.failed,
+        ...report.skipped,
+      ]),
+    ];
+    const services = await Promise.all(
+      touched.map(async (address) => {
+        const resolved = resolveService(address, workspace);
+        let health = "unknown";
+        let detail: string | undefined;
+        if (resolved && result(address) !== "skipped") {
+          const ready =
+            result(address) === "started"
+              ? await waitForReady(resolved, "local", { timeoutMs: 30_000 })
+              : null;
+          const h = await checkServiceHealth(resolved, "local");
+          health = h.health;
+          detail = h.healthDetail ?? ready?.detail;
+        }
+        return {
+          address,
+          result: result(address),
+          health,
+          ...(detail ? { detail } : {}),
+        };
+      }),
+    );
+    const unhealthy = services.filter(
+      (s) => s.result !== "skipped" && s.health === "error",
+    );
+    const out: Record<string, unknown> = {
+      ok:
+        !error &&
+        !failedExit &&
+        report.failed.length === 0 &&
+        unhealthy.length === 0 &&
+        touched.length > 0,
+      workspace: workspace ?? null,
+      services,
+    };
+    if (error) {
+      out.error = error;
+      out.fix = `${bin} doctor --json`;
+    } else if (report.failed.length > 0 || unhealthy.length > 0) {
+      const names = [
+        ...new Set([...report.failed, ...unhealthy.map((s) => s.address)]),
+      ];
+      out.error = `${names.join(", ")} did not start healthy`;
+      out.fix = `${bin} logs ${names[0].split("/")[0]}`;
+    } else if (failedExit) {
+      out.error = "up failed (its log is on stderr)";
+      out.fix = `${bin} up ${args.join(" ")} --plan`.replace(/\s+/g, " ");
+    } else if (touched.length === 0) {
+      out.error =
+        "nothing was started: no repo named, and the folder up ran in is not a repo in the workspace";
+      out.fix = `${bin} up -a --json`;
+      out.ask = "Which repo should start? (its name, as `repo add` printed it)";
+    }
+    out.next = out.ok
+      ? [`${bin} web up --no-open --json`, `${bin} doctor --json`]
+      : [];
+    printJson(out);
+    return out.ok ? 0 : 1;
+  }
+
+  /**
+   * `web up|restart --json` (ON-2): the web server started as usual (its
+   * log on stderr), then `{ ok, url, port, version? }` once it answers
+   * (up to 30s), so an agent hands back the right URL.
+   */
+  private async cmdWebUpJson(args: string[]): Promise<number> {
+    const { parseWebCommandArgs } = await import("./web-command.js");
+    const { probeWebServer } = await import("./mcp-connect.js");
+    const bin = fs.existsSync(
+      nodePath.join(getDistRoot(), "bin", product().cli),
+    )
+      ? `./bin/${product().cli}`
+      : product().cli;
+    let port: number;
+    try {
+      port = parseWebCommandArgs(args).port;
+    } catch (e) {
+      printJson({
+        ok: false,
+        error: (e as Error).message,
+        fix: `${bin} web up --no-open --json`,
+      });
+      return 2;
+    }
+    const url = `http://localhost:${port}`;
+    let error: string | undefined;
+    try {
+      await quietStdout(() => cmdWeb(args));
+    } catch (e) {
+      if (!(e instanceof ExitRequested) || e.code !== 0)
+        error = (e as Error).message;
+    }
+    let probe = await probeWebServer(url);
+    const deadline = Date.now() + 30_000;
+    while (!error && probe.kind !== "up" && probe.kind !== "foreign") {
+      if (Date.now() > deadline) break;
+      await new Promise((r) => setTimeout(r, 500));
+      probe = await probeWebServer(url);
+    }
+    const out: Record<string, unknown> = {
+      ok: probe.kind === "up",
+      url,
+      port,
+      ...(probe.kind === "up" && probe.version
+        ? { version: probe.version }
+        : {}),
+    };
+    if (probe.kind === "foreign") {
+      out.error = `${probe.who} answers at ${url}, not this distribution's web server`;
+      out.ask = `Another Den distribution uses port ${port}. Which port should ${product().title} use? (web.port in config/local/user.yml)`;
+    } else if (probe.kind !== "up") {
+      out.error = error ?? `the web server is not answering at ${url}`;
+      out.fix = `${bin} web restart --no-open --json`;
+    }
+    printJson(out);
+    return out.ok ? 0 : 1;
+  }
+
   /** Legacy: start the given services via manifest depends_on. */
   private async cmdServiceUpManifest(
     addresses: string[],
@@ -4880,6 +5115,10 @@ class DenCLI {
    */
   private displayHelp(): void {
     this.displayHelpBanner();
+    // ON-5: the line a developer pastes into their agent.
+    console.log(`Set up by your agent: paste this into it:`);
+    console.log(`  ${AGENT_SETUP_LINE}`);
+    console.log();
     console.log("Usage:");
     console.log(`  ${product().cli} [command] [options]`);
     console.log("\nEnvironment commands:");
@@ -4917,6 +5156,9 @@ class DenCLI {
     console.log(
       "  register [path]      Register a repo in the service catalog",
     );
+    console.log(
+      "  repo add <path|url>  Add a repo with no prompts, never changing it (--sidecar, --json)",
+    );
     console.log(
       "  relocate <repo> <path>  Point a moved checkout's workspace entries at its new path",
     );