@monster-orange/den 0.2.5 → 0.2.7

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

@@ -25,6 +25,13 @@ 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 {
+  classifyServerInfo,
+  foreignServerMessage,
+  ownServer,
+  pickAnotherPortHint,
+  type OwnServer,
+} from "./server-identity.js";
 import { readDenConfig, readMcpConfig } from "../../shared/den-config.js";
 
 export const MCP_CONNECT_SUBCOMMANDS = [
@@ -205,6 +212,8 @@ export const WEB_PROBE_TIMEOUT_MS = 1500;
 /** What a probe of the web server's /api/server-info found. */
 export type WebProbe =
   | { kind: "up"; version?: string }
+  /** Another distribution's server (see server-identity.ts). */
+  | { kind: "foreign"; who: string }
   /** Something accepted the connection but sent no answer in time. */
   | { kind: "timeout" }
   /** Nothing answered: connection refused, or not the web server. */
@@ -214,13 +223,15 @@ export async function probeWebServer(
   url: string,
   timeoutMs: number = WEB_PROBE_TIMEOUT_MS,
   fetchImpl: typeof fetch = fetch,
+  own: OwnServer = ownServer(),
 ): Promise<WebProbe> {
   try {
     const r = await fetchImpl(`${url}/api/server-info`, {
       signal: AbortSignal.timeout(timeoutMs),
     });
-    const info = (await r.json()) as { version?: string };
-    return { kind: "up", version: info.version };
+    const id = classifyServerInfo(await r.json(), own);
+    if (id.kind === "foreign") return { kind: "foreign", who: id.who };
+    return { kind: "up", version: id.kind === "ours" ? id.version : undefined };
   } catch (e) {
     return (e as Error).name === "TimeoutError"
       ? { kind: "timeout" }
@@ -252,6 +263,11 @@ export function webServerMessage(
       chalk.green(`web server up at ${url}`) +
       (probe.version ? chalk.gray(` (Den ${probe.version})`) : "")
     );
+  if (probe.kind === "foreign")
+    return chalk.yellow(
+      `${foreignServerMessage(Number(new URL(url).port), probe.who)}: ` +
+        `agents would read another distribution; ${pickAnotherPortHint(opts.cli)}`,
+    );
   const svc = `\`${opts.cli} service status\``;
   if (probe.kind === "timeout") {
     const secs = (opts.timeoutMs ?? WEB_PROBE_TIMEOUT_MS) / 1000;
@@ -271,7 +287,7 @@ export function webServerMessage(
   );
 }
 
-async function webServerLine(port?: number): Promise<string> {
+function webUrl(port?: number): string {
   let p = port;
   if (p === undefined) {
     try {
@@ -280,8 +296,12 @@ async function webServerLine(port?: number): Promise<string> {
       p = DEFAULT_PORT;
     }
   }
-  const url = `http://localhost:${p}`;
-  return webServerMessage(await probeWebServer(url), url, {
+  return `http://localhost:${p}`;
+}
+
+async function webServerLine(port?: number, probe?: WebProbe): Promise<string> {
+  const url = webUrl(port);
+  return webServerMessage(probe ?? (await probeWebServer(url)), url, {
     cli: product().cli,
     asService: webRunsAsService(),
   });
@@ -382,6 +402,17 @@ export async function runMcpConnect(argv: string[]): Promise<number> {
     return 1;
   }
 
+  // Never point agents at another distribution's server.
+  if (!remove) {
+    const probe = await probeWebServer(webUrl(flags.port));
+    if (probe.kind === "foreign") {
+      console.error(
+        `  ${chalk.red("✗")} ${await webServerLine(flags.port, probe)}`,
+      );
+      return 1;
+    }
+  }
+
   let failed = 0;
   for (const c of targets) {
     if (!c.scopes.includes(scope)) {

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

@@ -0,0 +1,162 @@
+/**
+ * `<cli> org list` (ORG-1a): every org with its label, its workspaces on
+ * this machine, whether it is the default (`github_org`), and the org
+ * warnings (C1). The orgs are `/api/orgs`'s (catalog owners plus `orgs:`),
+ * then the default org and any workspace's org that list does not name.
+ *
+ * `--org <id>` (on `org list` and `workspace list`) keeps one org's rows.
+ */
+import chalk from "chalk";
+import { product } from "../../shared/product.js";
+import { listOrgs } from "../../shared/manifest/service-links.js";
+import {
+  defaultOrg,
+  githubOrgFor,
+  readOrgContext,
+  resolveAllWorkspaceOrgs,
+  withOrgMembership,
+  type OrgContext,
+  type WorkspaceOrg,
+} from "../../shared/environment-manager/workspace-org.js";
+import { newTable } from "./table.js";
+
+/** `--org <id>`'s value from `args` (also `--org=<id>`), or undefined. */
+export function orgFlag(args: readonly string[]): string | undefined {
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--org") return args[i + 1];
+    if (a.startsWith("--org=")) return a.slice("--org=".length);
+  }
+  return undefined;
+}
+
+/** `args` without `--org <id>` / `--org=<id>`. */
+export function withoutOrgFlag(args: readonly string[]): string[] {
+  const out: string[] = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--org") {
+      i++;
+      continue;
+    }
+    if (args[i].startsWith("--org=")) continue;
+    out.push(args[i]);
+  }
+  return out;
+}
+
+export const sameOrg = (a: string | null, b: string): boolean =>
+  a !== null && a.toLowerCase() === b.toLowerCase();
+
+export interface OrgListRow {
+  id: string;
+  label: string;
+  default: boolean;
+  workspaces: string[];
+}
+
+/** The rows `org list` prints, and every workspace's warnings. */
+export function orgListRows(ctx: OrgContext = readOrgContext()): {
+  rows: OrgListRow[];
+  warnings: string[];
+  resolved: WorkspaceOrg[];
+} {
+  const resolved = resolveAllWorkspaceOrgs(ctx);
+  const listed = withOrgMembership(
+    listOrgs(ctx.catalog, ctx.config.orgs ?? {}),
+    resolved,
+    ctx.file,
+    ctx.config,
+  ).map((o) => ({
+    id: o.id,
+    label: o.label,
+    default: o.default,
+    workspaces: o.workspaces,
+  }));
+  const local = new Set(Object.keys(ctx.file.workspaces));
+  const extra = new Map<string, OrgListRow>();
+  const add = (id: string, isDefault: boolean): void => {
+    if (listed.some((r) => sameOrg(r.id, id))) return;
+    const key = id.toLowerCase();
+    if (!extra.has(key))
+      extra.set(key, { id, label: id, default: isDefault, workspaces: [] });
+  };
+  const d = defaultOrg(ctx.config);
+  if (d) add(d, true);
+  for (const w of resolved)
+    if (w.org && local.has(w.workspace)) {
+      add(w.org, sameOrg(d, w.org));
+      extra.get(w.org.toLowerCase())?.workspaces.push(w.workspace);
+    }
+  return {
+    rows: [...listed, ...extra.values()],
+    warnings: resolved
+      .filter((w) => local.has(w.workspace))
+      .flatMap((w) => w.warnings),
+    resolved,
+  };
+}
+
+/**
+ * The GitHub org `register` lists repos from: `--org <id>`, else the
+ * workspace's resolved org. Never Den's own checkout or remote (SEC-0).
+ * Undefined when there is none, or it is not a GitHub owner name.
+ */
+export function registerOrg(
+  workspace: string,
+  orgArg?: string,
+  ctx?: OrgContext,
+): string | undefined {
+  let org = orgArg?.trim();
+  if (!org) {
+    try {
+      org = githubOrgFor(workspace, ctx);
+    } catch {
+      return undefined;
+    }
+  }
+  return /^[A-Za-z0-9][A-Za-z0-9-]*$/.test(org) ? org : undefined;
+}
+
+/** Print the org warnings under a listing. */
+export function printOrgWarnings(warnings: readonly string[]): void {
+  for (const w of warnings) console.log(chalk.yellow(`  ⚠ ${w}`));
+  if (warnings.length) console.log();
+}
+
+export function cmdOrg(args: string[]): void {
+  const sub = args[0] ?? "list";
+  if (sub !== "list") {
+    console.log(chalk.red(`Usage: ${product().cli} org list [--org <id>]`));
+    process.exitCode = 1;
+    return;
+  }
+  const only = orgFlag(args.slice(1));
+  const { rows, warnings, resolved } = orgListRows();
+  const shown = only ? rows.filter((r) => sameOrg(r.id, only)) : rows;
+  const table = newTable({
+    head: ["Org", "Label", "Default", "Workspaces"],
+    style: { head: ["cyan"] },
+  });
+  for (const r of shown)
+    table.push([
+      chalk.bold(r.id),
+      r.label,
+      r.default ? chalk.green("✓") : "",
+      r.workspaces.join(", ") || chalk.gray("none"),
+    ]);
+  console.log(table.toString());
+  if (only && shown.length === 0)
+    console.log(chalk.yellow(`  No org ${only}.`));
+  const inScope = only
+    ? new Set(
+        resolved.filter((w) => sameOrg(w.org, only)).map((w) => w.workspace),
+      )
+    : null;
+  printOrgWarnings(
+    inScope
+      ? warnings.filter((w) =>
+          [...inScope].some((n) => w.startsWith(`workspace ${n}:`)),
+        )
+      : warnings,
+  );
+}

package/src/ui/cli/results-viewer.ts

@@ -3,7 +3,7 @@
  * Display test results in CLI
  */
 
-import Table from "cli-table3";
+import { newTable } from "./table.js";
 import chalk from "chalk";
 import { resultReader } from "../../shared/results/result-reader.js";
 import type {
@@ -40,7 +40,7 @@ export class ResultsViewer {
     for (const pillar of pillars) {
       console.log(chalk.bold(`\n${this.formatPillarName(pillar)}:`));
 
-      const table = new Table({
+      const table = newTable({
         head: [
           chalk.cyan("Environment"),
           chalk.cyan("Total"),
@@ -115,7 +115,7 @@ export class ResultsViewer {
       return;
     }
 
-    const table = new Table({
+    const table = newTable({
       head: [
         chalk.cyan("Test"),
         chalk.cyan("Status"),
@@ -191,7 +191,7 @@ export class ResultsViewer {
       return;
     }
 
-    const table = new Table({
+    const table = newTable({
       head: [
         chalk.cyan("Journey"),
         chalk.cyan("Verdict"),
@@ -281,7 +281,7 @@ export class ResultsViewer {
       return;
     }
 
-    const table = new Table({
+    const table = newTable({
       head: [
         chalk.cyan("Test"),
         chalk.cyan("Runs"),

package/src/ui/cli/server-identity.ts

@@ -0,0 +1,233 @@
+/**
+ * Whether the web server answering on a port is THIS distribution's.
+ *
+ * Several distributions can run a Den web server on one machine (each with
+ * its own root), so something answering on the configured port is not
+ * proof it is ours: `<cli> web up` once printed "already running" for
+ * another distribution's server, and `web down` could have signalled it.
+ * /api/server-info names the distribution root it serves and the product
+ * (since 0.2.6); every command that acts on "our" server asks this module
+ * first and refuses to act on a foreign one.
+ *
+ * A server from before 0.2.6 has no `root`. It does report its pid, and it
+ * runs with its distribution root as its working directory (`web up` and
+ * the launchd service both start it there), so that decides instead.
+ */
+import { spawnSync } from "child_process";
+import * as fs from "fs";
+import * as http from "http";
+import * as path from "path";
+import { CLI_SPAWN_TIMEOUT_MS } from "../../shared/constants.js";
+import { getDistRoot } from "../../shared/paths.js";
+import { product } from "../../shared/product.js";
+
+/** The distribution a command acts for. */
+export interface OwnServer {
+  root: string;
+  product: string;
+}
+
+/** What answers on a port, from this distribution's point of view. */
+export type ServerIdentity =
+  /** Nothing listens there. */
+  | { kind: "none" }
+  /** Something accepted the connection but sent no answer in time. */
+  | { kind: "unresponsive" }
+  /**
+   * `pid`: the server's own pid (server-info reports it). Identity is what
+   * makes it ours, so a stop signals this pid even when its command line
+   * names no entry point we recognise (an older Den installed elsewhere, a
+   * hand-started server).
+   */
+  | { kind: "ours"; version?: string; pid?: number }
+  /** Someone else's server. `who` reads "acme-ops at /srv/acme-ops". */
+  | { kind: "foreign"; who: string };
+
+/** How long one probe of /api/server-info may take. */
+export const SERVER_INFO_TIMEOUT_MS = 1_500;
+
+/** This distribution: its root and product name. */
+export function ownServer(): OwnServer {
+  return { root: getDistRoot(), product: product().name };
+}
+
+function canonical(p: string): string {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return path.resolve(p);
+  }
+}
+
+export function samePath(a: string, b: string): boolean {
+  return canonical(a) === canonical(b);
+}
+
+/** A process's working directory (lsof), or null when it can't be read. */
+export function processCwd(pid: number): string | null {
+  const r = spawnSync("lsof", ["-a", "-p", String(pid), "-d", "cwd", "-Fn"], {
+    encoding: "utf-8",
+    timeout: CLI_SPAWN_TIMEOUT_MS,
+  });
+  if (r.status !== 0 || typeof r.stdout !== "string") return null;
+  const line = r.stdout.split(/\r?\n/).find((l) => l.startsWith("n"));
+  return line ? line.slice(1) : null;
+}
+
+/**
+ * Classify a parsed /api/server-info body. `cwdOf` reads a pid's working
+ * directory, for servers from before `root` was reported.
+ */
+export function classifyServerInfo(
+  body: unknown,
+  own: OwnServer,
+  cwdOf: (pid: number) => string | null = processCwd,
+): ServerIdentity {
+  if (body === null || typeof body !== "object" || Array.isArray(body))
+    return { kind: "foreign", who: "a non-Den server" };
+  const info = body as Record<string, unknown>;
+  const version = typeof info.version === "string" ? info.version : undefined;
+  const prod = typeof info.product === "string" ? info.product : undefined;
+  const pid =
+    typeof info.pid === "number" && Number.isInteger(info.pid) && info.pid > 0
+      ? info.pid
+      : undefined;
+  const ours = (): ServerIdentity => ({
+    kind: "ours",
+    ...(version !== undefined ? { version } : {}),
+    ...(pid !== undefined ? { pid } : {}),
+  });
+
+  if (typeof info.root === "string" && info.root) {
+    if (
+      samePath(info.root, own.root) &&
+      (prod === undefined || prod === own.product)
+    )
+      return ours();
+    return {
+      kind: "foreign",
+      who: `${prod ?? "another server"} at ${info.root}`,
+    };
+  }
+
+  if (pid !== undefined) {
+    const cwd = cwdOf(pid);
+    if (cwd && samePath(cwd, own.root)) return ours();
+  }
+  if (version === undefined && info.pid === undefined)
+    return { kind: "foreign", who: "a non-Den server" };
+  return {
+    kind: "foreign",
+    who: `another server${version ? ` (Den ${version})` : ""}`,
+  };
+}
+
+/** Classify a raw /api/server-info answer (status and body text). */
+export function classifyServerInfoResponse(
+  statusCode: number,
+  text: string,
+  own: OwnServer,
+  cwdOf?: (pid: number) => string | null,
+): ServerIdentity {
+  // A server still starting answers 200 with an empty body: not up yet.
+  if (statusCode >= 200 && statusCode < 300 && text.trim() === "")
+    return { kind: "unresponsive" };
+  if (statusCode < 200 || statusCode >= 300)
+    return { kind: "foreign", who: "a non-Den server" };
+  let body: unknown;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    return { kind: "foreign", who: "a non-Den server" };
+  }
+  return classifyServerInfo(body, own, cwdOf);
+}
+
+/**
+ * GET /api/server-info on `port` and say whose server answered. `host`: the
+ * name the caller itself connects to (the MCP server's `localhost`).
+ */
+export function identifyServer(
+  port: number,
+  own: OwnServer = ownServer(),
+  timeoutMs: number = SERVER_INFO_TIMEOUT_MS,
+  host: string = "127.0.0.1",
+): Promise<ServerIdentity> {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (v: ServerIdentity): void => {
+      if (settled) return;
+      settled = true;
+      resolve(v);
+    };
+    const req = http.get(
+      {
+        host,
+        port,
+        path: "/api/server-info",
+        timeout: timeoutMs,
+        agent: false,
+      },
+      (res) => {
+        let text = "";
+        res.setEncoding("utf-8");
+        res.on("data", (chunk: string) => {
+          text += chunk;
+          if (text.length > 1024 * 1024) {
+            req.destroy();
+            finish({ kind: "foreign", who: "a non-Den server" });
+          }
+        });
+        res.on("end", () =>
+          finish(classifyServerInfoResponse(res.statusCode ?? 0, text, own)),
+        );
+        res.on("error", () => finish({ kind: "unresponsive" }));
+      },
+    );
+    req.on("timeout", () => {
+      req.destroy();
+      finish({ kind: "unresponsive" });
+    });
+    req.on("error", (e: NodeJS.ErrnoException) =>
+      finish(
+        e.code === "ECONNREFUSED" ? { kind: "none" } : { kind: "unresponsive" },
+      ),
+    );
+  });
+}
+
+/** "port 7001 is in use by acme-ops at /srv/acme-ops". */
+export function foreignServerMessage(port: number, who: string): string {
+  return `port ${port} is in use by ${who}`;
+}
+
+/** How to get out of the way: another port, for once or for good. */
+export function pickAnotherPortHint(cli: string = product().cli): string {
+  return (
+    `pick another port: \`${cli} web up --port <n>\` for once, or set ` +
+    `web.port in config/local/user.yml (yours) or ${product().configFile} (the team's)`
+  );
+}
+
+/** The error a command raises instead of acting on a foreign server. */
+export class ForeignServerError extends Error {
+  constructor(
+    readonly port: number,
+    readonly who: string,
+  ) {
+    super(
+      `${foreignServerMessage(port, who)}\n  Hint: ${pickAnotherPortHint()}`,
+    );
+    this.name = "ForeignServerError";
+  }
+}
+
+/** Throw ForeignServerError when `port` is served by another distribution. */
+export async function refuseForeignServer(
+  port: number,
+  own: OwnServer = ownServer(),
+): Promise<ServerIdentity> {
+  const id = await identifyServer(port, own);
+  if (id.kind === "foreign") throw new ForeignServerError(port, id.who);
+  return id;
+}