@monster-orange/den 0.2.0 → 0.2.2

package/src/ui/cli/mcp-connect.ts

@@ -0,0 +1,350 @@
+/**
+ * `<cli> mcp connect | disconnect | clients | config`: register this
+ * distribution's MCP server with a developer's agents. Planning lives in
+ * ../mcp/connect.ts; this file does the I/O.
+ */
+import { spawnSync } from "child_process";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import chalk from "chalk";
+import {
+  MCP_CLIENTS,
+  findClient,
+  genericSnippet,
+  jsonHasEntry,
+  mergeJsonConfig,
+  serverSpec,
+  type ConnectAction,
+  type ConnectEnv,
+  type McpClient,
+  type Scope,
+  type ServerSpec,
+} from "../mcp/connect.js";
+import { product } from "../../shared/product.js";
+import { getDistRoot } from "../../shared/paths.js";
+import { readWebPort } from "../../shared/edge/config.js";
+import { DEFAULT_PORT } from "../../shared/constants.js";
+import { readMcpConfig } from "../../shared/den-config.js";
+
+export const MCP_CONNECT_SUBCOMMANDS = [
+  "connect",
+  "disconnect",
+  "clients",
+  "config",
+] as const;
+
+function onPath(bin: string): boolean {
+  const exts =
+    process.platform === "win32"
+      ? (process.env.PATHEXT ?? ".EXE;.CMD").split(";")
+      : [""];
+  for (const dir of (process.env.PATH ?? "").split(path.delimiter)) {
+    if (!dir) continue;
+    for (const ext of exts) {
+      try {
+        fs.accessSync(path.join(dir, bin + ext), fs.constants.X_OK);
+        return true;
+      } catch {
+        /* next */
+      }
+    }
+  }
+  return false;
+}
+
+function connectEnv(projectDir: string): ConnectEnv {
+  return {
+    home: os.homedir(),
+    platform: process.platform,
+    appData: process.env.APPDATA,
+    projectDir,
+    which: onPath,
+    exists: (p) => fs.existsSync(p),
+  };
+}
+
+interface Flags {
+  clients: string[];
+  all: boolean;
+  project: string | null;
+  port?: number;
+  dryRun: boolean;
+}
+
+function parseFlags(argv: string[]): Flags {
+  const f: Flags = { clients: [], all: false, project: null, dryRun: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--all" || a === "-a") f.all = true;
+    else if (a === "--dry-run" || a === "-n") f.dryRun = true;
+    else if (a === "--project" || a === "-p") {
+      const next = argv[i + 1];
+      if (next && !next.startsWith("-") && !findClient(next)) {
+        f.project = path.resolve(next);
+        i++;
+      } else f.project = process.env.DEN_INVOKE_CWD ?? process.cwd();
+    } else if (a === "--port") {
+      const n = Number(argv[++i]);
+      if (!Number.isInteger(n) || n < 1 || n > 65535)
+        throw new Error(`--port must be a port number`);
+      f.port = n;
+    } else if (a.startsWith("-")) throw new Error(`unknown flag ${a}`);
+    else f.clients.push(a);
+  }
+  return f;
+}
+
+function spec(port?: number): ServerSpec {
+  const cli = product().cli;
+  const s = serverSpec({
+    cli,
+    distRoot: getDistRoot(),
+    nodeBinDir: path.dirname(process.execPath),
+    platform: process.platform,
+    port,
+  });
+  if (!fs.existsSync(s.command))
+    throw new Error(
+      `${s.command} does not exist: run this from a distribution with a bin/${cli} shim`,
+    );
+  return s;
+}
+
+const show = (argv: string[]): string =>
+  argv.map((a) => (/^[\w./:=@-]+$/.test(a) ? a : `'${a}'`)).join(" ");
+
+function run(argv: string[]): { code: number; out: string } {
+  const r = spawnSync(argv[0], argv.slice(1), { encoding: "utf-8" });
+  return {
+    code: r.status ?? 1,
+    out: `${r.stdout ?? ""}${r.stderr ?? ""}`.trim(),
+  };
+}
+
+function readText(file: string): string | null {
+  try {
+    return fs.readFileSync(file, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+/** Write `text` to `file` atomically, keeping the previous copy as .bak. */
+function writeConfig(file: string, text: string): void {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  if (fs.existsSync(file)) fs.copyFileSync(file, `${file}.bak`);
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, text);
+  fs.renameSync(tmp, file);
+}
+
+function apply(
+  a: ConnectAction,
+  remove: boolean,
+  dryRun: boolean,
+): { ok: boolean; said: string } {
+  if (a.kind === "json") {
+    const before = readText(a.file);
+    const after = mergeJsonConfig(
+      before,
+      a.key,
+      a.name,
+      remove ? null : a.entry,
+    );
+    if (!dryRun) writeConfig(a.file, after);
+    return {
+      ok: true,
+      said: `${dryRun ? "would write" : remove ? "removed from" : "wrote"} ${a.file}`,
+    };
+  }
+  if (remove) {
+    if (!a.remove)
+      return {
+        ok: false,
+        said: "remove it from the client's own MCP settings",
+      };
+    if (dryRun) return { ok: true, said: `would run ${show(a.remove)}` };
+    const r = run(a.remove);
+    return { ok: r.code === 0, said: r.out || show(a.remove) };
+  }
+  if (dryRun) return { ok: true, said: `would run ${show(a.add)}` };
+  if (a.remove) run(a.remove);
+  const r = run(a.add);
+  return {
+    ok: r.code === 0,
+    said:
+      r.code === 0 ? `ran ${a.add[0]} ${a.add.slice(1, 3).join(" ")}` : r.out,
+  };
+}
+
+function status(
+  c: McpClient,
+  s: ServerSpec,
+  scope: Scope,
+  env: ConnectEnv,
+): string {
+  const a = c.plan(s, scope, env);
+  if (a.kind === "json") {
+    const st = jsonHasEntry(readText(a.file), a.key, a.name, a.entry);
+    return st === "connected"
+      ? chalk.green("connected")
+      : st === "different"
+        ? chalk.yellow("connected (different command: reconnect)")
+        : chalk.gray("not connected");
+  }
+  if (!a.check) return chalk.gray("unknown (check the client's MCP list)");
+  return run(a.check).code === 0
+    ? chalk.green("connected")
+    : chalk.gray("not connected");
+}
+
+async function webServerLine(port?: number): Promise<string> {
+  let p = port;
+  if (p === undefined) {
+    try {
+      p = readWebPort();
+    } catch {
+      p = DEFAULT_PORT;
+    }
+  }
+  const url = `http://localhost:${p}`;
+  try {
+    const r = await fetch(`${url}/api/server-info`, {
+      signal: AbortSignal.timeout(1500),
+    });
+    const info = (await r.json()) as { version?: string };
+    return (
+      chalk.green(`web server up at ${url}`) +
+      (info.version ? chalk.gray(` (Den ${info.version})`) : "")
+    );
+  } catch {
+    return chalk.yellow(
+      `web server not running at ${url}: agents get read errors until \`${product().cli} web up\``,
+    );
+  }
+}
+
+function usage(): string {
+  const cli = product().cli;
+  return [
+    `Usage:`,
+    `  ${cli} mcp clients                       which agents are installed and connected`,
+    `  ${cli} mcp connect [<client>...|--all]   register ${cli}'s MCP server (user scope)`,
+    `        [--project [dir]]                  in a project's config instead (default: here)`,
+    `        [--port <n>] [--dry-run]`,
+    `  ${cli} mcp disconnect <client>... [--project [dir]]`,
+    `  ${cli} mcp config [--port <n>]           JSON for any other MCP client`,
+    ``,
+    `Clients: ${MCP_CLIENTS.map((c) => c.id).join(", ")}`,
+  ].join("\n");
+}
+
+export async function runMcpConnect(argv: string[]): Promise<number> {
+  const [sub, ...rest] = argv;
+  if (rest.includes("-h") || rest.includes("--help")) {
+    console.log(usage());
+    return 0;
+  }
+  let flags: Flags;
+  try {
+    flags = parseFlags(rest);
+  } catch (e) {
+    console.error(chalk.red(`${(e as Error).message}\n`) + usage());
+    return 1;
+  }
+  const s = spec(flags.port);
+  const scope: Scope = flags.project ? "project" : "user";
+  const env = connectEnv(
+    flags.project ?? process.env.DEN_INVOKE_CWD ?? process.cwd(),
+  );
+
+  if (sub === "config") {
+    console.log(genericSnippet(s));
+    return 0;
+  }
+
+  if (sub === "clients") {
+    console.log(
+      chalk.bold(
+        `\n  ${product().title} MCP server: ${s.command} ${s.args.join(" ")}`,
+      ),
+    );
+    console.log(`  ${await webServerLine(flags.port)}`);
+    const actions = readMcpConfig().actions;
+    console.log(
+      chalk.gray(
+        `  tools: read${actions.length ? ` + actions ${actions.join(", ")}` : " only (mcp.actions is empty)"}\n`,
+      ),
+    );
+    for (const c of MCP_CLIENTS) {
+      const here = c.detect(env);
+      const st =
+        here && c.scopes.includes(scope)
+          ? status(c, s, scope, env)
+          : chalk.gray(here ? `no ${scope} scope` : "not installed");
+      console.log(
+        `  ${here ? "●" : "○"} ${c.id.padEnd(15)} ${c.title.padEnd(24)} ${st}`,
+      );
+    }
+    console.log(
+      chalk.gray(
+        `\n  Connect: ${product().cli} mcp connect <client>   (or --all for every installed one)\n`,
+      ),
+    );
+    return 0;
+  }
+
+  if (sub !== "connect" && sub !== "disconnect") {
+    console.log(usage());
+    return 1;
+  }
+  const remove = sub === "disconnect";
+  let targets: McpClient[];
+  if (flags.all)
+    targets = MCP_CLIENTS.filter(
+      (c) => c.detect(env) && c.scopes.includes(scope),
+    );
+  else {
+    const unknown = flags.clients.filter((id) => !findClient(id));
+    if (unknown.length) {
+      console.error(
+        chalk.red(`unknown client: ${unknown.join(", ")}\n`) + usage(),
+      );
+      return 1;
+    }
+    targets = flags.clients.map((id) => findClient(id)!);
+  }
+  if (targets.length === 0) {
+    console.log(usage());
+    return 1;
+  }
+
+  let failed = 0;
+  for (const c of targets) {
+    if (!c.scopes.includes(scope)) {
+      console.log(`  ${chalk.yellow("•")} ${c.title}: no ${scope} scope`);
+      failed++;
+      continue;
+    }
+    try {
+      const r = apply(c.plan(s, scope, env), remove, flags.dryRun);
+      console.log(
+        `  ${r.ok ? chalk.green("✓") : chalk.red("✗")} ${c.title}: ${r.said}`,
+      );
+      if (!r.ok) failed++;
+    } catch (e) {
+      console.log(`  ${chalk.red("✗")} ${c.title}: ${(e as Error).message}`);
+      failed++;
+    }
+  }
+  if (!remove && !flags.dryRun && failed < targets.length) {
+    console.log(
+      chalk.gray(
+        `\n  Restart the agent (or start a new session) to load "${s.name}".`,
+      ),
+    );
+    console.log(`  ${await webServerLine(flags.port)}\n`);
+  }
+  return failed ? 1 : 0;
+}

package/src/ui/cli/named-target.ts

@@ -0,0 +1,11 @@
+/**
+ * Whether `address` ("repo" or "repo/service") is something the user named on
+ * the command line: the address itself, or the repo it belongs to.
+ */
+export function isNamedTarget(
+  address: string,
+  named: readonly string[],
+): boolean {
+  const repo = address.split("/")[0];
+  return named.some((n) => n === address || n === repo);
+}

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

@@ -0,0 +1,131 @@
+/**
+ * `service install | status | print | uninstall`
+ *
+ * The web UI as a macOS launchd service, over Den's service/install.sh. The
+ * label and log directory come from the org config's `web.service`
+ * (readWebServiceConfig), with the script's own defaults, so a distribution
+ * no longer wraps the script in its Makefile.
+ *
+ * `install` (which also restarts a running service) says the service is
+ * running only once the web server answers /api/server-info with JSON: a
+ * fresh server takes a few seconds to start, and answers empty until then.
+ */
+import { spawnSync } from "child_process";
+import * as os from "os";
+import * as path from "path";
+import {
+  readDenConfig,
+  readWebServiceConfig,
+  type DenConfig,
+} from "../../shared/den-config.js";
+import { readWebPort } from "../../shared/edge/config.js";
+import { getDistRoot, getEngineRoot } from "../../shared/paths.js";
+
+/** Runs a command with extra env vars; returns its exit code. */
+export type ServiceRunner = (
+  cmd: string,
+  args: string[],
+  env: Record<string, string>,
+) => number;
+
+const SUBCOMMANDS = ["install", "status", "print", "uninstall"] as const;
+
+const defaultRunner: ServiceRunner = (cmd, args, env) =>
+  spawnSync(cmd, args, { stdio: "inherit", env: { ...process.env, ...env } })
+    .status ?? 1;
+
+/** How long `install` waits for the web server to answer. */
+export const READY_TIMEOUT_MS = 30_000;
+
+/**
+ * Poll `url` until it answers 2xx with a JSON object, or `timeoutMs` passes.
+ * Each attempt is bounded too, so a hung connection cannot outlast it.
+ */
+export async function waitForServerInfo(
+  url: string,
+  timeoutMs: number = READY_TIMEOUT_MS,
+  intervalMs = 500,
+): Promise<boolean> {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    const left = deadline - Date.now();
+    if (left <= 0) return false;
+    try {
+      const res = await fetch(url, {
+        signal: AbortSignal.timeout(Math.min(2_000, left)),
+      });
+      if (res.ok) {
+        const body: unknown = JSON.parse(await res.text());
+        if (body !== null && typeof body === "object") return true;
+      }
+    } catch {
+      /* not up yet: refused, empty or partial body */
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+}
+
+export interface ServiceDeps {
+  run?: ServiceRunner;
+  config?: DenConfig;
+  distRoot?: string;
+  engineRoot?: string;
+  home?: string;
+  platform?: NodeJS.Platform;
+  /** The web UI port (default: config web.port). */
+  webPort?: number;
+  /** Readiness poller (default: waitForServerInfo). */
+  waitReady?: (url: string, timeoutMs: number) => Promise<boolean>;
+  log?: (line: string) => void;
+}
+
+/** Run `service <sub>`; returns the exit code. */
+export async function cmdService(
+  args: string[],
+  deps: ServiceDeps = {},
+): Promise<number> {
+  const sub = args[0];
+  if (!(SUBCOMMANDS as readonly string[]).includes(sub ?? ""))
+    throw new Error(
+      `${sub ? `Unknown service command "${sub}". ` : ""}Use: ${SUBCOMMANDS.join(" | ")}`,
+    );
+  // print only writes the plist; the rest talk to launchd.
+  if (sub !== "print" && (deps.platform ?? process.platform) !== "darwin")
+    throw new Error(
+      "the web UI service is a launchd LaunchAgent: macOS only (print works anywhere)",
+    );
+  const distRoot = deps.distRoot ?? getDistRoot();
+  const { label, logs } = readWebServiceConfig(
+    deps.config ?? readDenConfig(),
+    distRoot,
+    deps.home ?? os.homedir(),
+  );
+  const script = path.join(
+    deps.engineRoot ?? getEngineRoot(),
+    "service",
+    "install.sh",
+  );
+  const code = (deps.run ?? defaultRunner)("bash", [script, sub!], {
+    DEN_ROOT: distRoot,
+    DEN_SERVICE_LABEL: label,
+    DEN_SERVICE_LOGS: logs,
+    // The script then leaves saying "running" to us (after the poll below).
+    ...(sub === "install" ? { DEN_SERVICE_READY_CHECK: "external" } : {}),
+  });
+  if (sub !== "install" || code !== 0) return code;
+
+  const log = deps.log ?? ((l: string) => console.log(l));
+  const port = deps.webPort ?? readWebPort(distRoot);
+  const url = `http://localhost:${port}/api/server-info`;
+  if (await (deps.waitReady ?? waitForServerInfo)(url, READY_TIMEOUT_MS)) {
+    log(
+      `✓ ${label} running at http://localhost:${port} (logs: ${path.join(logs, "web.log")})`,
+    );
+    return 0;
+  }
+  log(
+    `✗ ${label} installed but not answering yet: check ${logs} ` +
+      `(${url} gave no JSON within ${READY_TIMEOUT_MS / 1000}s)`,
+  );
+  return 1;
+}

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

@@ -14,6 +14,7 @@ import {
   stackHealth,
   stackLogs,
   stackPs,
+  stackRestartService,
   stackUp,
 } from "../../shared/stacks/runtime.js";
 import { loadStackContext, stackStatuses } from "../../shared/stacks/status.js";
@@ -71,6 +72,14 @@ export async function cmdStack(argv: string[]): Promise<void> {
       return;
     }
     case "restart":
+      if (service) {
+        // One compose service, in place: no edge re-render, no recreate.
+        for (const n of pick()) {
+          console.log(chalk.cyan(`↻ ${n} ${service}`));
+          stackRestartService(ctx, stacks[n], service);
+        }
+        return;
+      }
       await edgeUp(edge);
       for (const n of pick()) {
         console.log(chalk.cyan(`↻ ${n}`));

package/src/ui/mcp/api.ts

@@ -58,6 +58,8 @@ const READ_ROUTES = new Set([
 
 /** Action routes and their method. Anything else is never reached. */
 const ACTION_ROUTES: Record<string, string> = {
+  // A refusal report: appends one entry to the activity trail, nothing more.
+  "/api/activity": "POST",
   "/api/service/exec": "GET",
   "/api/run": "GET",
   "/api/workspace/sync": "POST",