@monster-orange/den 0.2.4 → 0.2.6

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

@@ -3,6 +3,7 @@ import { execFileSync, spawn, spawnSync } from "child_process";
 import * as fs from "fs";
 import * as http from "http";
 import * as path from "path";
+import { pathToFileURL } from "url";
 import {
   CLI_SPAWN_TIMEOUT_MS,
   DEFAULT_PORT,
@@ -10,8 +11,14 @@ import {
 } from "../../shared/constants.js";
 import { getDistRoot, getEngineRoot, getStateDir } from "../../shared/paths.js";
 import { hasDenUiMarker } from "../../shared/ui-marker.js";
-import { engineBin } from "../../shared/engine.js";
+import { engineBin, engineModuleFile } from "../../shared/engine.js";
 import { readWebPort } from "../../shared/edge/config.js";
+import {
+  ownServer,
+  processCwd,
+  refuseForeignServer,
+  samePath,
+} from "./server-identity.js";
 
 import { product } from "../../shared/product.js";
 interface WebCommandOptions {
@@ -294,8 +301,19 @@ async function waitForDenWeb(port: number): Promise<boolean> {
   return false;
 }
 
-/** How to run the web server: Den's own files, from the engine root. */
-function resolveServerEntrypoint(engine: string = getEngineRoot()): {
+/**
+ * How to run the web server: Den's own files, from the engine root.
+ *
+ * The TypeScript source runs as `node --import <tsx loader> index.ts`, never
+ * through the `tsx` CLI. The CLI is a parent process that relays signals to
+ * the server and, if the server has not acknowledged a SIGTERM within about
+ * 60ms (two 30ms windows), SIGKILLs it and exits 143. Under load the server
+ * misses that window, so `<cli> web down` killed it without its shutdown.
+ * With the loader there is one process, and the signal reaches the
+ * server's own handler. (The launchd service, service/install.sh, already
+ * runs this way.)
+ */
+export function resolveServerEntrypoint(engine: string = getEngineRoot()): {
   cmd: string;
   args: string[];
 } {
@@ -313,17 +331,23 @@ function resolveServerEntrypoint(engine: string = getEngineRoot()): {
   // take effect. The server resolves PUBLIC_DIR relative to its own module, so
   // running from src/ serves src/ui/server/public directly. Fall back to the
   // compiled build only when devDependencies (tsx) aren't installed.
-  const tsxBin = engineBin(process.platform === "win32" ? "tsx.cmd" : "tsx");
+  const loader = engineModuleFile("tsx/dist/loader.mjs", engine);
   const srcServer = path.join(engine, "src/ui/server/index.ts");
-  if (fs.existsSync(tsxBin) && fs.existsSync(srcServer)) {
-    return { cmd: tsxBin, args: [srcServer] };
+  if (loader && fs.existsSync(srcServer)) {
+    return {
+      cmd: process.execPath,
+      args: ["--import", pathToFileURL(loader).href, srcServer],
+    };
   }
 
   if (fs.existsSync(builtServer)) {
     return { cmd: process.execPath, args: [builtServer] };
   }
 
-  return { cmd: tsxBin, args: [srcServer] };
+  return {
+    cmd: engineBin(process.platform === "win32" ? "tsx.cmd" : "tsx", engine),
+    args: [srcServer],
+  };
 }
 
 function startDenWebServer(options: WebCommandOptions): StartedServer {
@@ -551,21 +575,55 @@ async function waitForPidsExit(pids: number[]): Promise<boolean> {
   return false;
 }
 
-function findDenWebPids(port: number): number[] {
+/**
+ * Whether `pid` may be this distribution's server by where it runs: a web
+ * server runs from its distribution root, so one whose working directory
+ * is another root is never ours, even when its command line matches (two
+ * distributions on one linked engine run the same entry point). An
+ * unreadable directory does not decide.
+ */
+function runsFromRoot(pid: number, root: string): boolean {
+  const cwd = processCwd(pid);
+  if (!cwd) return true;
+  return samePath(cwd, root);
+}
+
+function isOurWebPid(pid: number, root: string): boolean {
+  const command = commandForPid(pid);
+  return (
+    !!command &&
+    isDenWebCommand(command, webRoots(root)) &&
+    runsFromRoot(pid, root)
+  );
+}
+
+/**
+ * Our server's pids on `port`. `vouched` is the pid of a server the
+ * identity check (server-info: our root, or an older server run from our
+ * root) found ours: it is stopped when it listens on the port even if its
+ * command line names no entry point we recognise. Before, an older Den
+ * installed elsewhere, or a hand-started server, matched no command line,
+ * so `web down` said "not running" and `web restart` "already running".
+ */
+function findDenWebPids(port: number, vouched?: number): number[] {
   const root = getDistRoot();
   const pids = new Set<number>();
   const state = readWebServerState();
-  if (state?.port === port && state.pid) {
-    const command = commandForPid(state.pid);
-    if (command && isDenWebCommand(command, webRoots(state.root || root))) {
-      pids.add(state.pid);
-    }
+  const listeners = listListeningPids(port);
+  // The state file may be shared by distributions of one product name: a
+  // record of another root's server is not ours to stop.
+  if (
+    state?.port === port &&
+    state.pid &&
+    samePath(state.root || root, root) &&
+    (isOurWebPid(state.pid, root) ||
+      (state.pid === vouched && listeners.includes(state.pid)))
+  ) {
+    pids.add(state.pid);
   }
 
-  for (const pid of listListeningPids(port)) {
-    if (isDenWebCommand(commandForPid(pid), webRoots(root))) {
-      pids.add(pid);
-    }
+  for (const pid of listeners) {
+    if (pid === vouched || isOurWebPid(pid, root)) pids.add(pid);
   }
 
   return Array.from(pids);
@@ -593,8 +651,11 @@ export function killWebProcess(pid: number, signal: NodeJS.Signals): void {
   }
 }
 
-async function stopDenWebServer(port: number): Promise<StopServerResult> {
-  const pids = findDenWebPids(port);
+async function stopDenWebServer(
+  port: number,
+  vouched?: number,
+): Promise<StopServerResult> {
+  const pids = findDenWebPids(port, vouched);
   if (pids.length === 0) {
     const state = readWebServerState();
     if (state?.port === port) removeWebServerState();
@@ -618,22 +679,25 @@ async function stopDenWebServer(port: number): Promise<StopServerResult> {
   return { stopped: forced, forced: true, pids };
 }
 
-async function stopBrokenDenWebServer(port: number): Promise<boolean> {
-  return (await stopDenWebServer(port)).stopped;
+async function stopBrokenDenWebServer(
+  port: number,
+  vouched?: number,
+): Promise<boolean> {
+  return (await stopDenWebServer(port, vouched)).stopped;
 }
 
 function recordRunningDenWebServer(port: number): void {
   const root = getDistRoot();
   const state = readWebServerState();
-  if (state?.port === port && state.pid) {
-    const command = commandForPid(state.pid);
-    if (command && isDenWebCommand(command, webRoots(state.root || root)))
-      return;
-  }
+  if (
+    state?.port === port &&
+    state.pid &&
+    samePath(state.root || root, root) &&
+    isOurWebPid(state.pid, root)
+  )
+    return;
 
-  const pids = listListeningPids(port).filter((pid) =>
-    isDenWebCommand(commandForPid(pid), webRoots(root)),
-  );
+  const pids = listListeningPids(port).filter((pid) => isOurWebPid(pid, root));
   const pid = pids[0];
   if (!pid) return;
 
@@ -947,8 +1011,13 @@ export async function cmdWeb(args: string[]): Promise<void> {
 
   const url = buildDenWebUrl(options.port);
 
+  // Never act on another distribution's server: not "already running", and
+  // never a signal to it (down, restart).
+  const identity = await refuseForeignServer(options.port, ownServer());
+  const vouched = identity.kind === "ours" ? identity.pid : undefined;
+
   if (options.action === "down") {
-    const stopped = await stopDenWebServer(options.port);
+    const stopped = await stopDenWebServer(options.port, vouched);
     if (stopped.stopped) {
       const mode = stopped.forced ? "force stopped" : "stopped";
       console.log(
@@ -970,7 +1039,7 @@ export async function cmdWeb(args: string[]): Promise<void> {
   }
 
   if (options.action === "restart") {
-    const stopped = await stopDenWebServer(options.port);
+    const stopped = await stopDenWebServer(options.port, vouched);
     if (stopped.pids.length > 0 && !stopped.stopped) {
       throw new Error(
         `Could not stop ${product().title} web on port ${options.port}.`,
@@ -997,7 +1066,7 @@ export async function cmdWeb(args: string[]): Promise<void> {
       ),
     );
     console.log(chalk.gray(`  Restarting ${product().title} web...`));
-    const stopped = await stopBrokenDenWebServer(options.port);
+    const stopped = await stopBrokenDenWebServer(options.port, vouched);
     if (!stopped) {
       throw new Error(
         `Could not stop the broken ${product().title} web server on port ${options.port}.`,

package/src/ui/mcp/api.ts

@@ -3,8 +3,19 @@
  * server holds no state of its own: agents and the web UI share the server's
  * state and its guards. This client can reach only the routes below, and it
  * sends the agent's audit headers (see shared/agent-actor.ts) on every call.
+ *
+ * With `identity`, it first makes sure the server on the port is this
+ * distribution's (server-identity.ts): another distribution's server (or an
+ * older Den from another root) on the configured port gets no request, and
+ * every tool says whose server it is instead of serving its data.
  */
 import { product } from "../../shared/product.js";
+import {
+  foreignServerMessage,
+  identifyServer,
+  type OwnServer,
+  type ServerIdentity,
+} from "../cli/server-identity.js";
 import { LIFECYCLE_CMDS, Refusal } from "./guards.js";
 
 export type Query = Record<string, string | string[] | undefined>;
@@ -20,6 +31,47 @@ export class DenWebDown extends Error {
   }
 }
 
+/** Another distribution's server answers on the port: no data from it. */
+export class ForeignWebServer extends Error {
+  constructor(
+    readonly port: number,
+    readonly who: string,
+  ) {
+    super(
+      `${foreignServerMessage(port, who)}; not this distribution's server. ` +
+        `Nothing was read from it. Point web.port (or --port) at this distribution's server.`,
+    );
+    this.name = "ForeignWebServer";
+  }
+}
+
+/** Something answers on the port but would not say whose server it is. */
+export class UnidentifiedWebServer extends Error {
+  constructor(readonly port: number) {
+    super(
+      `the server on port ${port} did not answer /api/server-info in time, ` +
+        `so it is not known to be this distribution's; nothing was read from it. Try again.`,
+    );
+    this.name = "UnidentifiedWebServer";
+  }
+}
+
+/** How long a positive identity check is trusted. */
+export const IDENTITY_TTL_MS = 30_000;
+/** The identity probe's budget: longer than the CLI's, a busy server is ours too. */
+export const IDENTITY_TIMEOUT_MS = 5_000;
+
+export interface IdentityCheck {
+  /** This distribution: its root and product. */
+  own: OwnServer;
+  /** Default identifyServer. */
+  identify?: (port: number, own: OwnServer) => Promise<ServerIdentity>;
+  /** Default IDENTITY_TTL_MS. */
+  ttlMs?: number;
+  /** Default Date.now. */
+  now?: () => number;
+}
+
 /** The web server answered with an error status. */
 export class DenHttpError extends Error {
   constructor(
@@ -157,8 +209,44 @@ export function createDenApi(opts: {
   baseUrl: string;
   cli: string;
   headers: () => Record<string, string>;
+  /** Check whose server it is before any request (the MCP server does). */
+  identity?: IdentityCheck;
 }): DenApi {
   const { baseUrl, cli } = opts;
+  const { hostname } = new URL(baseUrl);
+  const port = Number(new URL(baseUrl).port) || 80;
+  let vouchedAt: number | null = null;
+  let checking: Promise<void> | null = null;
+
+  /** Throws unless the server on the port is ours (cached briefly). */
+  async function ensureOurs(): Promise<void> {
+    const check = opts.identity;
+    if (!check) return;
+    const now = check.now ?? Date.now;
+    if (
+      vouchedAt !== null &&
+      now() - vouchedAt < (check.ttlMs ?? IDENTITY_TTL_MS)
+    )
+      return;
+    checking ??= (async () => {
+      const id = await (
+        check.identify ??
+        ((p: number, o: OwnServer) =>
+          identifyServer(p, o, IDENTITY_TIMEOUT_MS, hostname))
+      )(port, check.own);
+      if (id.kind === "ours") {
+        vouchedAt = now();
+        return;
+      }
+      vouchedAt = null;
+      if (id.kind === "foreign") throw new ForeignWebServer(port, id.who);
+      if (id.kind === "none") throw new DenWebDown(baseUrl, cli);
+      throw new UnidentifiedWebServer(port);
+    })().finally(() => {
+      checking = null;
+    });
+    return checking;
+  }
 
   async function request(
     method: string,
@@ -168,6 +256,7 @@ export function createDenApi(opts: {
     body?: unknown,
   ): Promise<Response> {
     assertAllowedRequest(method, path, query);
+    await ensureOurs();
     try {
       const res = await fetch(buildUrl(baseUrl, path, query), {
         method,
@@ -184,7 +273,11 @@ export function createDenApi(opts: {
       }
       return res;
     } catch (e) {
-      if (isConnectionError(e)) throw new DenWebDown(baseUrl, cli);
+      if (isConnectionError(e)) {
+        // Whatever answers next on the port is checked again.
+        vouchedAt = null;
+        throw new DenWebDown(baseUrl, cli);
+      }
       throw e;
     }
   }

package/src/ui/mcp/server.ts

@@ -18,7 +18,9 @@ import { engineVersion } from "../../shared/paths.js";
 import { product } from "../../shared/product.js";
 import { DEFAULT_PORT } from "../../shared/constants.js";
 import { createDenApi, type DenApi } from "./api.js";
+import { ownServer } from "../cli/server-identity.js";
 import { callTool, toolsFor, type ToolContext } from "./tools.js";
+import { plural } from "../../shared/plural.js";
 
 export interface DenMcpOptions {
   cfg: ResolvedMcpConfig;
@@ -56,6 +58,8 @@ export function createDenMcpServer(opts: DenMcpOptions): McpServer {
     createDenApi({
       baseUrl: opts.baseUrl,
       cli: opts.cli,
+      // Serve nothing from another distribution's server on the port.
+      identity: { own: ownServer() },
       headers: () =>
         agentAuditHeaders({
           client: client()?.name ?? "unknown",
@@ -210,6 +214,7 @@ export async function runMcp(argv: string[]): Promise<void> {
     const api = createDenApi({
       baseUrl,
       cli,
+      identity: { own: ownServer() },
       headers: () =>
         agentAuditHeaders({
           client: `${cli} mcp --call`,
@@ -224,7 +229,7 @@ export async function runMcp(argv: string[]): Promise<void> {
   const server = createDenMcpServer({ cfg, baseUrl, cli });
   await server.connect(new StdioServerTransport());
   process.stderr.write(
-    `${cli} mcp: ${toolsFor(cfg).length} tools ` +
+    `${cli} mcp: ${plural(toolsFor(cfg).length, "tool")} ` +
       `(${cfg.actions.length ? `actions: ${cfg.actions.join(", ")}` : "read only"}) → ${baseUrl}\n`,
   );
 }

package/src/ui/mcp/tools.ts

@@ -14,6 +14,8 @@ import { redactSecrets } from "../../shared/redact.js";
 import {
   DenHttpError,
   DenWebDown,
+  ForeignWebServer,
+  UnidentifiedWebServer,
   type DenApi,
   type Query,
   type StreamResult,
@@ -154,7 +156,7 @@ const READ_TOOLS: DenTool[] = [
   read(
     "status",
     "Service health",
-    "Health of every service in the workspace (what `status` shows): up/down, mode, and what was checked: `url` for an HTTP check, `check` for a shell command.",
+    "Health of every service in the workspace (what `status` shows): up/down, mode, and what was checked: `url` for an HTTP check, `check` for a shell command or a container check (`container <project>/<service>`).",
     { env: envArg, workspace: workspaceArg },
     (a, { api }) =>
       api.get("/api/health", { env: envOf(a), workspace: str(a.workspace) }),
@@ -636,7 +638,9 @@ export async function callTool(
     const msg =
       e instanceof Refusal
         ? `Refused: ${e.message}`
-        : e instanceof DenWebDown
+        : e instanceof DenWebDown ||
+            e instanceof ForeignWebServer ||
+            e instanceof UnidentifiedWebServer
           ? e.message
           : `Error: ${(e as Error).message}`;
     return { text: redactSecrets(msg), isError: true };

package/src/ui/server/health-row.ts

@@ -1,15 +1,18 @@
 /**
  * The fields of a /api/health row that say what was checked. `url` is only
  * ever a URL (or null): a shell check's command (a compose stack's
- * `<cli> stack health …`, or any declared shell check) goes in `check`.
+ * `<cli> stack health …`, or any declared shell check) goes in `check`, as
+ * does a container check's `container <project>/<service>` (or
+ * `container <name>`).
  */
-export type HealthCheckType = "shell" | "http" | "none";
+export type HealthCheckType = "shell" | "http" | "container" | "none";
 
 export function healthCheckFields(
   checkType: HealthCheckType,
   target: string,
 ): { url: string | null; check?: string } {
-  if (checkType === "shell") return { url: null, check: target };
+  if (checkType === "shell" || checkType === "container")
+    return { url: null, check: target };
   if (checkType === "http") return { url: target };
   return { url: null };
 }