@monster-orange/den 0.4.14 → 0.4.15

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

@@ -28,6 +28,8 @@ import {
 import { readWebPort } from "../../shared/edge/config.js";
 import { DEFAULT_PORT } from "../../shared/constants.js";
 import { needsDocker } from "./repo-detect.js";
+import { readMcpConfig } from "../../shared/den-config.js";
+import { approvalsState } from "../mcp/tools.js";
 import type { WebProbe } from "./mcp-connect.js";
 
 export type CheckStatus = "ok" | "warn" | "fail";
@@ -59,6 +61,8 @@ export interface OnboardDeps {
   probeWeb: (url: string) => Promise<WebProbe>;
   /** The MCP one-shot against the web server: exit 0, or why not. */
   mcpCall: () => { ok: boolean; detail?: string };
+  /** `mcp.approvals` (throws on a bad value): whether the held writes are on. */
+  approvals: () => boolean;
   /** The command an agent runs, e.g. `./bin/acme`. */
   bin: string;
 }
@@ -193,9 +197,30 @@ export async function onboardingChecks(
           },
     );
   }
+  out.push(approvalsCheck(d));
   return out;
 }
 
+/** `mcp:approvals`: which state the held writes are in. Never needs the server. */
+function approvalsCheck(d: OnboardDeps): OnboardCheck {
+  let on: boolean;
+  try {
+    on = d.approvals();
+  } catch (err) {
+    return {
+      id: "mcp:approvals",
+      status: "fail",
+      detail: (err as Error).message,
+      ask: "Set mcp.approvals in the distribution config to true or false.",
+    };
+  }
+  return {
+    id: "mcp:approvals",
+    status: "ok",
+    detail: approvalsState({ approvals: on }),
+  };
+}
+
 function onPath(bin: string): boolean {
   for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
     if (!dir) continue;
@@ -286,6 +311,7 @@ export function defaultOnboardDeps(
               `exit ${r.status ?? "timeout"}`,
           };
     },
+    approvals: () => readMcpConfig().approvals,
     bin: runnableCli(),
   };
 }

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

@@ -181,7 +181,15 @@ function validateFlagScopes(parsed: ParsedCliArgs): void {
  */
 export const SUBCOMMAND_OWN_HELP: Readonly<Record<string, readonly string[]>> =
   {
-    web: ["token", "login", "sessions", "logout", "owner", "approve"],
+    web: [
+      "token",
+      "login",
+      "sessions",
+      "logout",
+      "owner",
+      "approve",
+      "claim-link",
+    ],
     mcp: ["connect", "disconnect", "clients", "config"],
     repo: ["add"],
   };

package/src/ui/cli/index.ts

@@ -366,12 +366,22 @@ const COMMAND_HELP: Record<string, { usage: string; lines: string[] }> = {
   },
   repo: {
     usage:
-      'repo add <path|git-url> [--sidecar] [-w <workspace>] [--name <repo>] [--run "<cmd>"] [--health <url>] [--json]',
+      'repo add <path|git-url> [--sidecar] [-w <workspace>] [--name <repo>] [--run "<cmd>"] [--health <url>] [--dry-run] [--json] | repo detect <folder> [--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.",
+      "--dry-run prints the side-car it would write, validated, and writes nothing.",
+      "detect: the git repos in a folder in your home, how each runs, and",
+      "suggested workspaces. `{cli} repo add --help` says more.",
+    ],
+  },
+  onboard: {
+    usage: "onboard status [--json]",
+    lines: [
+      "What's set up (a distribution, the web server, workspaces, repos, a",
+      "running service, Den's MCP) and the one next step, with its command.",
+      "Reads only; it never runs an agent's CLI.",
     ],
   },
   relocate: {
@@ -595,6 +605,7 @@ const TELEMETRY_COMMANDS = new Set<string>([
   "theme",
   "plugin",
   "repo",
+  "onboard",
 ]);
 
 /**
@@ -975,6 +986,15 @@ class DenCLI {
           break;
         }
 
+        case "onboard": {
+          const { cmdOnboard } = await import("./onboard-command.js");
+          const { probeWebServer } = await import("./mcp-connect.js");
+          process.exitCode = await cmdOnboard(args.slice(1), (u) =>
+            probeWebServer(u),
+          );
+          break;
+        }
+
         case "relocate":
           await this.cmdRelocate(args.slice(1));
           break;
@@ -5271,7 +5291,13 @@ class DenCLI {
       "  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)",
+      "  repo add <path|url>  Add a repo with no prompts, never changing it (--sidecar, --dry-run, --json)",
+    );
+    console.log(
+      "  repo detect <folder> Find the repos in a folder and suggest workspaces (--json)",
+    );
+    console.log(
+      "  onboard status       What's set up, and the next step (--json)",
     );
     console.log(
       "  relocate <repo> <path>  Point a moved checkout's workspace entries at its new path",

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

@@ -0,0 +1,180 @@
+/**
+ * `<cli> onboard status [--json]` (ON-3): what's set up and the one next
+ * step, the CLI twin of the MCP tool `onboard_status` and of
+ * GET /api/onboard/status. `doctor --json` has the machine checks (Node,
+ * git, Docker, the web server, Den's MCP); this adds what onboarding needs
+ * on top (a distribution, workspaces, repos, a running service) and picks
+ * the next step. Reads only. It never runs an agent's CLI: Den's MCP is
+ * checked in the agents' config files (onboard-reads.ts mcpRegistration).
+ * Exit 0 whenever it answers, whatever is left to do.
+ */
+import { execFile } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { product } from "../../shared/product.js";
+import { getDistRoot } from "../../shared/paths.js";
+import {
+  DEN_SERVICES_DIR,
+  readWorkspacesFile,
+} from "../../shared/environment-manager/workspaces.js";
+import { listDaemons } from "../../shared/environment-manager/service-runner.js";
+import { defaultOnboardDeps, runnableCli } from "./doctor-onboard.js";
+import type { WebProbe } from "./mcp-connect.js";
+import {
+  mcpRegistration,
+  onboardStatus,
+  type OnboardStatus,
+  type OnboardStatusDeps,
+  type RegisteredRepo,
+} from "./onboard-reads.js";
+import { printJson } from "./json-out.js";
+
+/** Every repo in a workspace, at the folder Den runs it from. */
+export function registeredRepos(): RegisteredRepo[] {
+  let file;
+  try {
+    file = readWorkspacesFile();
+  } catch {
+    return [];
+  }
+  const out: RegisteredRepo[] = [];
+  for (const [workspace, ws] of Object.entries(file.workspaces))
+    for (const [addr, entry] of Object.entries(ws?.services ?? {})) {
+      const repo = addr.split("/")[0];
+      const dir =
+        entry.mode === "dev-managed"
+          ? entry.path
+          : path.join(DEN_SERVICES_DIR, repo, entry.branch ?? "main");
+      if (dir) out.push({ path: dir, workspace, repo });
+    }
+  return out;
+}
+
+function readText(file: string): string | null {
+  try {
+    return fs.readFileSync(file, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+/** Whether the Docker daemon answers, without blocking the event loop. */
+function dockerUpAsync(): Promise<boolean> {
+  return new Promise((resolve) => {
+    execFile(
+      "docker",
+      ["info", "--format", "{{.ServerVersion}}"],
+      { timeout: 10_000 },
+      (err) => resolve(!err),
+    );
+  });
+}
+
+/** This machine's deps for onboardStatus. */
+export async function defaultStatusDeps(o: {
+  probeWeb: (url: string) => Promise<WebProbe>;
+  webUrl?: string;
+  viaMcp?: boolean;
+}): Promise<OnboardStatusDeps> {
+  const doctor = defaultOnboardDeps(o.probeWeb);
+  if (o.webUrl) doctor.webUrl = o.webUrl;
+  // Docker is asked only when a registered repo needs it, and asynchronously:
+  // the web server answers this route too.
+  const dockerRepos = doctor.dockerRepos();
+  const dockerUp =
+    dockerRepos.length && doctor.which("docker")
+      ? await dockerUpAsync()
+      : false;
+  const bin = runnableCli();
+  return {
+    bin,
+    distribution: fs.existsSync(path.join(getDistRoot(), "bin", product().cli)),
+    doctor: {
+      ...doctor,
+      dockerRepos: () => dockerRepos,
+      dockerUp: () => dockerUp,
+    },
+    workspaces: () => {
+      let file;
+      try {
+        file = readWorkspacesFile();
+      } catch {
+        return { names: [], active: [], repos: [] };
+      }
+      const repos = new Set<string>();
+      for (const ws of Object.values(file.workspaces))
+        for (const addr of Object.keys(ws?.services ?? {}))
+          repos.add(addr.split("/")[0]);
+      return {
+        names: Object.keys(file.workspaces),
+        active: file.active.filter((n) => n in file.workspaces),
+        repos: [...repos],
+      };
+    },
+    running: () => {
+      try {
+        return listDaemons().map((d) => d.address);
+      } catch {
+        return [];
+      }
+    },
+    mcp: () =>
+      mcpRegistration({
+        cli: bin,
+        home: os.homedir(),
+        platform: process.platform,
+        appData: process.env.APPDATA,
+        projectDir: getDistRoot(),
+        which: doctor.which,
+        read: readText,
+        viaMcp: o.viaMcp,
+      }),
+  };
+}
+
+const MARK: Record<string, string> = { ok: "✓", warn: "!", todo: "·" };
+
+function printHuman(r: OnboardStatus): void {
+  for (const c of r.checks)
+    console.log(`  ${MARK[c.status] ?? " "} ${c.id.padEnd(12)} ${c.detail}`);
+  console.log(`\n  Next: ${r.next.step}`);
+  if (r.next.command) console.log(`  Run:  ${r.next.command}`);
+}
+
+export const ONBOARD_USAGE = () => `${product().cli} onboard status [--json]`;
+
+/** `onboard <sub> …`; returns the exit code. */
+export async function cmdOnboard(
+  argv: string[],
+  probeWeb: (url: string) => Promise<WebProbe>,
+): Promise<number> {
+  const [sub, ...rest] = argv;
+  const json = rest.includes("--json");
+  const unknown = rest.filter((a) => a !== "--json");
+  if (sub !== "status" || unknown.length) {
+    const error =
+      sub === undefined || sub === "--help" || sub === "-h"
+        ? null
+        : sub !== "status"
+          ? `unknown onboard subcommand "${sub}"`
+          : `unknown flag ${unknown[0]}`;
+    if (json && error)
+      printJson({
+        ok: false,
+        error,
+        fix: `${runnableCli()} onboard status --json`,
+      });
+    else {
+      if (error) console.error(`✗ ${error}`);
+      console.log(
+        `\n  ${ONBOARD_USAGE()}\n\n  What's set up (a distribution, the web server, workspaces, repos,\n  a running service, Den's MCP) and the one next step, with its command.\n`,
+      );
+    }
+    return error ? 2 : sub === undefined ? 1 : 0;
+  }
+  const r = await onboardStatus(await defaultStatusDeps({ probeWeb }));
+  if (json) printJson(r);
+  else printHuman(r);
+  return 0;
+}