@monster-orange/den 0.2.0 → 0.2.2

package/src/ui/cli/index.ts

@@ -5,6 +5,7 @@
  * Main entry point for the interactive CLI
  */
 
+import { isNamedTarget } from "./named-target.js";
 import chalk from "chalk";
 import oraSpinner from "ora";
 
@@ -95,7 +96,12 @@ import {
   getWaitDeps,
 } from "../../shared/environment-manager/dag.js";
 import { waitForReady } from "../../shared/environment-manager/readiness.js";
-import { resolveService } from "../../shared/environment-manager/service-runner.js";
+import {
+  canonicalServiceAddress,
+  previewServiceCommand,
+  resolveService,
+  type ServiceCommandPreview,
+} from "../../shared/environment-manager/service-runner.js";
 import { getGitHubCoords } from "../../shared/smoke/git-remote.js";
 import {
   getReposRoot,
@@ -156,6 +162,7 @@ import {
 import { cleanupStaleTabs } from "../../shared/cli-tabs.js";
 import { cmdConfig } from "./config-command.js";
 import { cmdEdge } from "./edge-command.js";
+import { cmdService } from "./service-command.js";
 import { cmdStack } from "./stack-command.js";
 import { cmdWeb, displayWebHelp } from "./web-command.js";
 import { cmdGraph } from "./graph-command.js";
@@ -190,14 +197,15 @@ const COMMAND_HELP: Record<string, { usage: string; lines: string[] }> = {
   down: {
     usage: "down [repo] [flags]",
     lines: [
-      "Stop the cwd (or named) repo's derived dependency closure, in reverse order.",
+      "Stop the cwd (or named) repo; --with-deps also stops what it sits on (its",
+      "derived closure, in reverse order), naming anything else that uses it.",
       "-a/--all stops EVERY workspace system (reverse derived order, cwd-agnostic;",
       "every down script runs — no already-stopped skip).",
-      "Flags: -a/--all · -A/--app <app> · -n/--dry-run (print order, stop nothing) · --manifest (legacy depends_on)",
+      "Flags: -a/--all · -A/--app <app> · --with-deps · -n/--dry-run (print order, stop nothing) · --manifest (legacy depends_on)",
     ],
   },
   restart: {
-    usage: "restart [service...] [-A <app>]",
+    usage: "restart [service...] [-A <app>] [-n|--dry-run]",
     lines: [
       `Restart the given services, or every repo in an application (\`${product().cli} apps\`).`,
     ],
@@ -300,10 +308,18 @@ const COMMAND_HELP: Record<string, { usage: string; lines: string[] }> = {
     ],
   },
   mcp: {
-    usage: "mcp [--port <web port>]",
+    usage: "mcp [--port <web port>] [--list | --call <tool> ['<json args>']]",
     lines: [
       "An MCP server over stdio for agents: a client of the running web server",
       `(\`${product().cli} web up\`). Read tools always; actions only as named in mcp.actions.`,
+      "--list prints the tool names; --call runs one tool and prints its result.",
+    ],
+  },
+  service: {
+    usage: "service [install|status|print|uninstall]",
+    lines: [
+      "The web UI as a macOS launchd service, started at login. Label and logs:",
+      "config web.service { label, logs }.",
     ],
   },
   "local-dev": {
@@ -362,6 +378,7 @@ const TELEMETRY_COMMANDS = new Set<string>([
   "apps",
   "applications",
   "mcp",
+  "service",
 ]);
 
 /** Map a raw command token to a PII-safe, registered telemetry command name. */
@@ -379,6 +396,20 @@ function telemetryReason(error: unknown): string {
   return name && name !== "Object" ? name : "Error";
 }
 
+/**
+ * What was typed, with each service alias (a manifest service key or a
+ * compose stack name) mapped to its service's address, so the derived graph,
+ * ownership and the daemon registry all see one name. Flags pass through; an
+ * ambiguous alias throws, naming the candidates. `limit` maps only the first
+ * n positional args.
+ */
+function canonicalTargets(args: string[], limit = Infinity): string[] {
+  let seen = 0;
+  return args.map((a) =>
+    a.startsWith("-") || seen++ >= limit ? a : canonicalServiceAddress(a),
+  );
+}
+
 /** Print one manifest's validation: a status line, then each issue. */
 function printValidation(
   label: string,
@@ -684,6 +715,10 @@ class DenCLI {
           await cmdEdge(args.slice(1));
           break;
 
+        case "service":
+          process.exitCode = await cmdService(args.slice(1));
+          break;
+
         case "stack":
           await cmdStack(args.slice(1));
           break;
@@ -695,6 +730,17 @@ class DenCLI {
           break;
 
         case "mcp": {
+          // Setup subcommands: register the server with agents.
+          const { MCP_CONNECT_SUBCOMMANDS, runMcpConnect } =
+            await import("./mcp-connect.js");
+          if (
+            (MCP_CONNECT_SUBCOMMANDS as readonly string[]).includes(
+              args[1] ?? "",
+            )
+          ) {
+            process.exitCode = await runMcpConnect(args.slice(1));
+            break;
+          }
           // bin/den routes `mcp` to its own entry (stdout is the protocol);
           // this covers the CLI run directly from a checkout.
           await import("./mcp-stdout-guard.js");
@@ -1298,7 +1344,20 @@ class DenCLI {
       /** Skip ANY already-healthy node (derived `up` starts only what's down). */
       skipHealthyAll?: boolean;
     },
-    opts?: { force?: boolean },
+    opts?: {
+      force?: boolean;
+      /**
+       * What the user named on the command line (repo or address). A remote
+       * service among them is refused with a non-zero exit; one reached only
+       * as part of a workspace or app run is said and skipped.
+       */
+      named?: readonly string[];
+      /**
+       * `-n`/`--dry-run` (and `--plan` on this path): print what would run,
+       * in order, and run nothing. Read-only on every path.
+       */
+      dryRun?: boolean;
+    },
   ): Promise<void> {
     // How long to show startup output before handing control back to the menu
     // for detachable (long-running) commands like `up`.
@@ -1308,6 +1367,22 @@ class DenCLI {
       getFocusedWorkspaceName() ??
       undefined;
     const force = opts?.force ?? false;
+    // R13: why a remote service is not run here, or null.
+    const remoteRefusal = (address: string): string | null => {
+      const placed = resolveService(address, workspace);
+      return placed
+        ? placementRefusal(
+            address,
+            servicePlacement(
+              readManifest(placed.repoPath),
+              placed.subsystem,
+              "local",
+            ),
+            (e) => isProductionEnv(e),
+            command,
+          )
+        : null;
+    };
 
     // Resolve dependency order. Derived mode supplies the order directly;
     // otherwise topo-sort manifest depends_on (`down` → reverse).
@@ -1321,8 +1396,17 @@ class DenCLI {
         const startupOrder = ws
           ? resolveStartupOrder(addresses, catalog, ws.config, ws.name)
           : addresses;
+        // Only up pulls in dependencies (a service needs them to start).
+        // Down and restart act on what was named: its dependencies may be
+        // serving other running services.
+        const namedOnly = (): string[] => {
+          const kept = startupOrder.filter((a) => addresses.includes(a));
+          return [...kept, ...addresses.filter((a) => !kept.includes(a))];
+        };
         if (command === "down") {
-          ordered = [...startupOrder].reverse();
+          ordered = namedOnly().reverse();
+        } else if (command !== "up") {
+          ordered = namedOnly();
         } else {
           ordered = startupOrder;
           if (ordered.length > addresses.length) {
@@ -1338,6 +1422,42 @@ class DenCLI {
       }
     }
 
+    if (opts?.dryRun) {
+      // The same lookup a real run makes, so the dry run says what it does.
+      const previews = ordered.map((a): ServiceCommandPreview => {
+        const remote = remoteRefusal(a);
+        if (!remote) return previewServiceCommand(a, command, workspace);
+        // As the loop below: a named remote target fails, any other is
+        // said and skipped.
+        return isNamedTarget(a, opts?.named ?? [])
+          ? { kind: "error", address: a, note: remote }
+          : {
+              kind: "nothing",
+              address: a,
+              note: `${a} (remote, skipped): ${remote}`,
+            };
+      });
+      const doing =
+        { up: "starting", down: "stopping", restart: "restarting" }[command] ??
+        `running "${command}" on`;
+      const runs = previews
+        .filter((p) => p.kind === "run" || p.kind === "via-repo")
+        .map((p) => p.address);
+      console.log(
+        chalk.cyan(
+          `\n  Would ${command}: ${[...new Set(runs)].join(" → ") || "(nothing)"}`,
+        ),
+      );
+      for (const p of previews) {
+        if (p.kind === "via-repo" || p.kind === "nothing")
+          console.log(chalk.gray(`  ${p.note}`));
+        if (p.kind === "error") console.log(chalk.red(`  ✗ ${p.note}`));
+      }
+      if (previews.some((p) => p.kind === "error")) process.exitCode = 1;
+      console.log(chalk.gray(`  (--dry-run: not ${doing} anything)\n`));
+      return;
+    }
+
     // Build a catalog + workspace reference once per run for readiness lookups.
     const catalog = readCatalog();
     const ws = getActiveWorkspace();
@@ -1378,21 +1498,14 @@ class DenCLI {
       }
       // R13: a remote service is never started or stopped from here. Said,
       // not failed, so a workspace or app up/down carries on past it.
-      const placed = resolveService(address, workspace);
-      const remote = placed
-        ? placementRefusal(
-            address,
-            servicePlacement(
-              readManifest(placed.repoPath),
-              placed.subsystem,
-              "local",
-            ),
-            (e) => isProductionEnv(e),
-            command === "down" ? "stop" : "start",
-          )
-        : null;
+      const remote = remoteRefusal(address);
       if (remote) {
-        console.log(chalk.gray(`  • ${remote}`));
+        if (isNamedTarget(address, opts?.named ?? [])) {
+          console.log(chalk.red(`  ✗ ${remote}`));
+          process.exitCode = 1;
+        } else {
+          console.log(chalk.gray(`  • ${remote}`));
+        }
         continue;
       }
       if (command === "up" && !seedAddresses.has(address)) {
@@ -1604,6 +1717,9 @@ class DenCLI {
         }
       });
 
+      // Any target that failed makes the whole command fail (scripts and
+      // agents read the exit code).
+      if (!started) process.exitCode = 1;
       if (plan?.failFast && !started) {
         console.log(
           chalk.red(
@@ -1732,6 +1848,7 @@ class DenCLI {
     plan = false,
     pull = false,
   ): Promise<void> {
+    const named = [seed];
     const full = deriveGraph({ scope: "all" });
     // Same positional closure the web "up with deps" uses: everything the seed
     // sits ON TOP OF, never anything above it. Keeps the two entry points from
@@ -1791,7 +1908,12 @@ class DenCLI {
       return;
     }
     if (dryRun) {
-      console.log(chalk.gray("  (--dry-run: not starting anything)\n"));
+      await this.runServicesCommand(
+        order,
+        "up",
+        { order },
+        { named, dryRun: true },
+      );
       return;
     }
     // Check the secrets backend first so any first-clone `make setup` (and the up
@@ -1813,12 +1935,17 @@ class DenCLI {
       );
       return;
     }
-    await this.runServicesCommand(order, "up", {
+    await this.runServicesCommand(
       order,
-      waitDepsFor: (address) => hardDepsOf(graph, address),
-      failFast: true,
-      skipHealthyAll: true,
-    });
+      "up",
+      {
+        order,
+        waitDepsFor: (address) => hardDepsOf(graph, address),
+        failFast: true,
+        skipHealthyAll: true,
+      },
+      { named },
+    );
   }
 
   /**
@@ -1831,10 +1958,13 @@ class DenCLI {
     seed: string,
     dryRun: boolean,
     force = false,
+    withDeps = false,
   ): Promise<void> {
     const full = deriveGraph({ scope: "all" });
+    // Only the named repo, unless --with-deps: what it sits on may be
+    // serving other running systems (the same rule as a named service).
     const upOrder = this.runtimeOnly(
-      deriveStartTargets(full, seed).order,
+      withDeps ? deriveStartTargets(full, seed).order : [seed],
       "stopped",
     );
     if (upOrder.length === 0) return;
@@ -1845,6 +1975,9 @@ class DenCLI {
     // still running on them. Name them rather than letting them fall over
     // silently.
     const inClosure = new Set(order);
+    // Only what really stops here puts dependents at risk: a remote service
+    // is refused (R13), so it stops nothing.
+    const stopsHere = new Set(order.filter((a) => !this.isRemote(a, "down")));
     const atRisk = [
       ...new Set(
         full.edges
@@ -1852,14 +1985,16 @@ class DenCLI {
             (e) =>
               e.kind !== "jwks" &&
               e.ordering !== false &&
-              inClosure.has(e.to) &&
+              stopsHere.has(e.to) &&
               !inClosure.has(e.from),
           )
           .map((e) => e.from),
       ),
     ].sort();
     console.log(
-      chalk.cyan(`\n  Derived down for ${chalk.bold(seed)} (+ dependencies)`),
+      chalk.cyan(
+        `\n  Derived down for ${chalk.bold(seed)}${withDeps ? " (+ dependencies)" : ""}`,
+      ),
     );
     console.log(chalk.gray(`  Order: ${order.join(" → ")}\n`));
     if (atRisk.length > 0) {
@@ -1871,10 +2006,38 @@ class DenCLI {
       );
     }
     if (dryRun) {
-      console.log(chalk.gray("  (--dry-run: not stopping anything)\n"));
+      await this.runServicesCommand(
+        order,
+        "down",
+        { order },
+        { force, named: [seed], dryRun: true },
+      );
       return;
     }
-    await this.runServicesCommand(order, "down", { order }, { force });
+    await this.runServicesCommand(
+      order,
+      "down",
+      { order },
+      { force, named: [seed] },
+    );
+  }
+
+  /** Whether `address` runs remotely, so `command` is refused here (R13). */
+  private isRemote(address: string, command: string): boolean {
+    const placed = resolveService(address);
+    return (
+      !!placed &&
+      placementRefusal(
+        address,
+        servicePlacement(
+          readManifest(placed.repoPath),
+          placed.subsystem,
+          "local",
+        ),
+        (e) => isProductionEnv(e),
+        command,
+      ) !== null
+    );
   }
 
   /** Workspace repos with no runtime (modules, libraries) → their kind. */
@@ -2301,9 +2464,10 @@ class DenCLI {
     // Tokens after a `--` terminator belong to a child command — they must
     // never be read as up's own flags (`den up -- -a` is NOT `up -a`).
     const terminator = args.indexOf("--");
-    const { app, rest: ownArgs } = takeAppFlag(
+    const { app, rest } = takeAppFlag(
       terminator === -1 ? args : args.slice(0, terminator),
     );
+    const ownArgs = canonicalTargets(rest);
     const dryRun = ownArgs.includes("--dry-run") || ownArgs.includes("-n");
     const plan = ownArgs.includes("--plan");
     const pull = ownArgs.includes("--pull");
@@ -2360,11 +2524,17 @@ class DenCLI {
       await this.runDerivedUp(seed, include, dryRun, plan, pull);
       return;
     }
-    await this.cmdServiceUpManifest(ownArgs.filter((a) => !a.startsWith("-")));
+    await this.cmdServiceUpManifest(
+      ownArgs.filter((a) => !a.startsWith("-")),
+      dryRun || plan,
+    );
   }
 
   /** Legacy: start the given services via manifest depends_on. */
-  private async cmdServiceUpManifest(addresses: string[]): Promise<void> {
+  private async cmdServiceUpManifest(
+    addresses: string[],
+    dryRun = false,
+  ): Promise<void> {
     // Resolve targets BEFORE the secrets preflight — otherwise running
     // `den up` from a non-service dir (e.g. the den repo root) triggers
     // an interactive sign-in just to print "nothing to do".
@@ -2391,8 +2561,11 @@ class DenCLI {
       }
       return;
     }
-    preflightSecrets();
-    await this.runServicesCommand(targets, "up");
+    if (!dryRun) preflightSecrets();
+    await this.runServicesCommand(targets, "up", undefined, {
+      named: addresses,
+      dryRun,
+    });
   }
 
   private async cmdServiceDown(args: string[]): Promise<void> {
@@ -2400,9 +2573,10 @@ class DenCLI {
     // never be read as down's own flags (`den down -- -a` must NOT tear
     // down the whole workspace).
     const terminator = args.indexOf("--");
-    const { app, rest: ownArgs } = takeAppFlag(
+    const { app, rest } = takeAppFlag(
       terminator === -1 ? args : args.slice(0, terminator),
     );
+    const ownArgs = canonicalTargets(rest);
     const dryRun = ownArgs.includes("--dry-run") || ownArgs.includes("-n");
     const force = ownArgs.includes("--force") || ownArgs.includes("-f");
     if (app) {
@@ -2444,7 +2618,12 @@ class DenCLI {
     const seed = forceManifest ? undefined : this.derivedSeed(seedArg);
 
     if (seed) {
-      await this.runDerivedDown(seed, dryRun, force);
+      await this.runDerivedDown(
+        seed,
+        dryRun,
+        force,
+        ownArgs.includes("--with-deps"),
+      );
       return;
     }
     const addresses = ownArgs.filter((a) => !a.startsWith("-"));
@@ -2452,26 +2631,34 @@ class DenCLI {
       addresses.length > 0
         ? addresses
         : this.resolveNoArgServiceTargets("down");
-    await this.runServicesCommand(targets, "down", undefined, { force });
+    await this.runServicesCommand(targets, "down", undefined, {
+      force,
+      named: addresses,
+      dryRun,
+    });
   }
 
   private async cmdServiceRestart(argv: string[]): Promise<void> {
     const { app, rest: args } = takeAppFlag(argv);
-    preflightSecrets();
+    const dryRun = args.includes("--dry-run") || args.includes("-n");
+    if (!dryRun) preflightSecrets();
     if (app) {
       const order =
         this.allWorkspaceOrder(focusedAppRepos(app))?.rawOrder ?? [];
-      await this.runServicesCommand(order, "restart");
+      await this.runServicesCommand(order, "restart", undefined, { dryRun });
       return;
     }
     // Drop flag tokens so a bare `den restart --foo` doesn't treat the flag
     // as a service address (matches cmdServiceUp/cmdServiceDown).
-    const filtered = args.filter((a) => !a.startsWith("-"));
+    const filtered = canonicalTargets(args.filter((a) => !a.startsWith("-")));
     const addresses =
       filtered.length > 0
         ? filtered
         : this.resolveNoArgServiceTargets("restart");
-    await this.runServicesCommand(addresses, "restart");
+    await this.runServicesCommand(addresses, "restart", undefined, {
+      named: filtered,
+      dryRun,
+    });
   }
 
   /** Service address with a ⏸ marker when the repo is auto-start off. */
@@ -2579,7 +2766,7 @@ class DenCLI {
   private async cmdLogs(args: string[]): Promise<void> {
     await this.ensureWorkspaceSeeded();
     const alias = loadAliasResolver();
-    const target = resolveLogsTarget(args, alias);
+    const target = resolveLogsTarget(canonicalTargets(args, 1), alias);
     if (target.kind === "unknown-repo") {
       console.log(chalk.red(`\n  Unknown repo: ${target.arg}\n`));
       process.exit(1);
@@ -3645,6 +3832,12 @@ class DenCLI {
     console.log(
       "  mcp [--port <n>]     MCP server (stdio) for agents, over the running web server",
     );
+    console.log(
+      "  mcp --call <tool>    Call one MCP tool and print its result (--list: tool names)",
+    );
+    console.log(
+      "  service install      Run the web UI as a launchd service (status, print, uninstall)",
+    );
     console.log();
     console.log("  workspace list       List workspaces");
     console.log(