@monster-orange/den 0.2.5 → 0.2.7

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

@@ -5,6 +5,7 @@
  *
  * stdout carries the protocol only: diagnostics go to stderr.
  */
+import { z } from "zod";
 import { randomUUID } from "crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -18,7 +19,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 +59,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",
@@ -181,7 +186,29 @@ export async function runOneShot(
     return 0;
   }
   const ctx: ToolContext = { api: opts.api, cfg: opts.cfg, cli: opts.cli };
-  const r = await callTool(shot.tool, shot.args, ctx);
+  // The stdio server validates arguments against each tool's schema (the
+  // SDK does it); a one-shot must too, and strictly: it is typed by hand, so
+  // an unknown or misspelt key is an error, not silently dropped.
+  let args = shot.args;
+  const tool = toolsFor(opts.cfg).find((t) => t.name === shot.tool);
+  if (tool) {
+    const parsed = z.object(tool.shape).strict().safeParse(args);
+    if (!parsed.success) {
+      const err = opts.err ?? ((t: string) => process.stderr.write(t));
+      const lines = parsed.error.issues.map((i) => {
+        const at = i.path.length ? i.path.join(".") : "(arguments)";
+        return `  ${at}: ${i.message}`;
+      });
+      const keys = Object.keys(tool.shape);
+      err(
+        `--call ${shot.tool}: invalid arguments\n${lines.join("\n")}\n` +
+          `  takes: ${keys.length ? keys.join(", ") : "no arguments"}\n`,
+      );
+      return 2;
+    }
+    args = parsed.data as Record<string, unknown>;
+  }
+  const r = await callTool(shot.tool, args, ctx);
   out(r.text.endsWith("\n") ? r.text : `${r.text}\n`);
   return r.isError ? 1 : 0;
 }
@@ -210,6 +237,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 +252,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/daemon-reaper.ts

@@ -11,9 +11,11 @@
  * so an "error" health result is only acted on after a SECOND
  * consecutive "error" check separated by a retry delay. "unknown"
  * results and thrown checks always keep the entry (err on the side of
- * keeping). A daemon whose address no longer resolves to any
- * workspace/catalog service is process-death-equivalent evidence and is
- * removed directly.
+ * keeping). A daemon this root registered whose address no longer resolves
+ * to any workspace/catalog service is process-death-equivalent evidence and
+ * is removed directly. Records another root registered (all roots of a
+ * product share the file) are never touched, and an unstamped legacy record
+ * is not removed for being unresolvable.
  */
 
 import type { ServiceHealthResult } from "../../shared/environment-manager/health.js";
@@ -41,6 +43,12 @@ export interface DaemonReaperDeps {
   delay: (ms: number) => Promise<void>;
   /** Gap between the first "error" result and the confirming re-check. */
   retryDelayMs: number;
+  /**
+   * Which root wrote the record (`daemonRootOf`). Every root of a product
+   * shares one daemons file: another root's records are never swept here,
+   * and an unstamped (pre-0.2.7) one is not dropped for being unresolvable.
+   */
+  rootOf: (daemon: DaemonRecord) => "here" | "other" | "unstamped";
 }
 
 export interface DaemonReapResult {
@@ -92,9 +100,19 @@ export async function reapDeadDaemons(
   await Promise.allSettled(
     deps.listDaemons().map(async (daemon) => {
       try {
+        const root = deps.rootOf(daemon);
+        if (root === "other") {
+          kept.push(daemon.address);
+          return;
+        }
         const service = resolveForDaemon(deps, daemon);
         if (!service) {
-          // No longer in any owning workspace/catalog — nothing could restart it.
+          // No longer in any owning workspace/catalog — nothing could restart
+          // it. An unstamped record may be another root's, so it stays.
+          if (root === "unstamped") {
+            kept.push(daemon.address);
+            return;
+          }
           deps.unregisterDaemon(daemon.address);
           removed.push(daemon.address);
           return;

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 };
 }

package/src/ui/server/index.ts

@@ -12,9 +12,11 @@
 
 import {
   composeHealthTarget,
+  containerCheckLabel,
   type ComposeHealthTarget,
+  type ContainerHealthTarget,
 } from "../../shared/stacks/compose-health.js";
-import { healthCheckFields } from "./health-row.js";
+import { healthCheckFields, type HealthCheckType } from "./health-row.js";
 import { hasRuntime, repoKind } from "../../shared/repo-kind.js";
 import * as http from "http";
 import * as fs from "fs";
@@ -62,6 +64,8 @@ import {
   isSafeServiceName,
 } from "./log-history.js";
 import {
+  containerTarget,
+  pingContainerCheck,
   pingHttp,
   pingShellCheck,
   TimeoutStreaks,
@@ -76,6 +80,7 @@ import {
   checkServiceHealth,
   loadDaemonsFromFile,
   pruneDeadDaemonsAsync,
+  daemonRootOf,
   isInteractiveServiceCommand,
   rewriteLegacyOpctlKillCommandForContainer,
   shouldDetachServiceCommand,
@@ -432,6 +437,11 @@ import {
   send404,
 } from "./http-helpers.js";
 import { orgOf, listOrgs } from "../../shared/manifest/service-links.js";
+import {
+  readOrgContext,
+  resolveAllWorkspaceOrgs,
+  withOrgMembership,
+} from "../../shared/environment-manager/workspace-org.js";
 import {
   readLatestSummary,
   securityReportsDir,
@@ -680,9 +690,18 @@ async function handleRequest(
 
   // ── API: environments ──────────────────────────────────────────────────────
   // Orgs the catalog's repos belong to, with config/den.yml display names.
+  // Each entry also says whether it is the default org (`github_org`) and
+  // which workspaces on this machine belong to it (ORG-1a). Nothing else
+  // changes: same entries, order and fields (ORG-SPEC C3).
   if (pathname === "/api/orgs") {
-    const catalog = readCatalog();
-    const orgs = listOrgs(catalog, readDenConfig().orgs ?? {});
+    const ctx = readOrgContext();
+    const catalog = ctx.catalog;
+    const orgs = withOrgMembership(
+      listOrgs(catalog, ctx.config.orgs ?? {}),
+      resolveAllWorkspaceOrgs(),
+      ctx.file,
+      ctx.config,
+    );
     if (url.searchParams.get("repos") !== "1") return sendJson(res, orgs);
     const repos = Object.fromEntries(
       Object.keys(catalog).map((r) => [r, orgOf(r, catalog)]),
@@ -926,7 +945,7 @@ async function handleRequest(
       repo: string;
       service: string;
       label: string;
-      checkType: "http" | "shell" | "none";
+      checkType: HealthCheckType;
       target: string;
       repoPath: string;
       mode: "dev-managed" | "managed";
@@ -941,6 +960,8 @@ async function handleRequest(
       expect?: Expect;
       /** pingShell options (Den's own `stack health` can report unknown). */
       compose: ComposeHealthTarget | null;
+      /** A `type: container` check: answered from the shared listing. */
+      container: ContainerHealthTarget | null;
       meta: Pick<HealthResult, "runs" | "target">;
     }> = [];
     let edgeDomain: string | null = null;
@@ -974,6 +995,7 @@ async function handleRequest(
           links: [],
           org: orgOf(resolved.repoName, catalog),
           compose: null,
+          container: null,
           meta: { runs: "none", target: null },
         });
         continue;
@@ -1020,14 +1042,16 @@ async function handleRequest(
         service: resolved.subsystem,
         label: plan.label ?? healthCfg?.label ?? resolved.subsystem,
         checkType: healthCfg
-          ? healthCfg.type === "shell"
-            ? "shell"
+          ? healthCfg.type === "shell" || healthCfg.type === "container"
+            ? healthCfg.type
             : "http"
           : "none",
         target: healthCfg
           ? healthCfg.type === "shell"
             ? healthCfg.cmd
-            : healthCfg.url
+            : healthCfg.type === "container"
+              ? containerCheckLabel(containerTarget(healthCfg))
+              : healthCfg.url
           : "",
         repoPath: resolved.repoPath,
         mode: resolved.mode,
@@ -1048,14 +1072,15 @@ async function handleRequest(
           subsystem: resolved.subsystem,
           repoName: resolved.repoName,
           env,
-          healthUrl:
-            healthCfg && healthCfg.type !== "shell" ? healthCfg.url : null,
+          healthUrl: healthCfg && "url" in healthCfg ? healthCfg.url : null,
           edgeDomain,
         }),
         links: linksFor(manifest, resolved.subsystem, env),
         org: orgOf(resolved.repoName, catalog),
         ...(plan.expect ? { expect: plan.expect } : {}),
         compose,
+        container:
+          healthCfg?.type === "container" ? containerTarget(healthCfg) : null,
         meta: { runs: plan.placement.runs, target: plan.placement.target },
       });
     }
@@ -1086,6 +1111,7 @@ async function handleRequest(
       meta,
       expect,
       compose,
+      container,
     }) => {
       if (checkType !== "none") {
         const started = Date.now();
@@ -1097,13 +1123,15 @@ async function handleRequest(
                 repoPath,
                 compose,
               )
-            : await pingHttp(
-                target,
-                env === "local" && meta.runs !== "remote"
-                  ? HEALTH_CHECK_TIMEOUT_MS
-                  : HOSTED_HEALTH_CHECK_TIMEOUT_MS,
-                expect,
-              );
+            : checkType === "container" && container
+              ? await pingContainerCheck(container)
+              : await pingHttp(
+                  target,
+                  env === "local" && meta.runs !== "remote"
+                    ? HEALTH_CHECK_TIMEOUT_MS
+                    : HOSTED_HEALTH_CHECK_TIMEOUT_MS,
+                  expect,
+                );
         return {
           repo,
           service,
@@ -2362,7 +2390,14 @@ async function handleRequest(
   // ── API: den config ────────────────────────────────────────────────────
   if (pathname === `/api/${product().cli}/config` && req.method === "GET") {
     // `org` resolved (id defaults to edge.org) for the header's org label.
-    return sendJson(res, { ...readDenConfig(), org: readOrg() });
+    const config = readDenConfig();
+    // `default_org` (ORG-1a) is the default work org, `github_org`; `org`
+    // stays the instance org (readOrg).
+    return sendJson(res, {
+      ...config,
+      org: readOrg(),
+      default_org: config.github_org?.trim() || null,
+    });
   }
 
   // ── API: server info + staleness (drives the header "stale server" pill) ────
@@ -2373,6 +2408,11 @@ async function handleRequest(
       port: PORT,
       // Den's version: the MCP server compares it with the routes it needs.
       version: engineVersion() ?? null,
+      // Whose server this is: `<cli> web up|down`, `mcp connect` and
+      // `service install` compare both with their own and never act on
+      // another distribution's server (see cli/server-identity.ts).
+      root: ROOT,
+      product: product().name,
       startedAt: new Date(SERVER_STARTED_AT).toISOString(),
       uptimeMs: Date.now() - SERVER_STARTED_AT,
       stale,
@@ -3166,7 +3206,7 @@ void (async () => {
   await new Promise<void>((resolve) =>
     setTimeout(resolve, DAEMON_SHUTDOWN_GRACE_MS),
   );
-  await reapDeadDaemons({
+  const reaped = await reapDeadDaemons({
     listDaemons,
     resolveService,
     getActiveWorkspaces,
@@ -3174,7 +3214,12 @@ void (async () => {
     unregisterDaemon,
     delay: (ms) => new Promise<void>((resolve) => setTimeout(resolve, ms)),
     retryDelayMs: DAEMON_RETRY_DELAY_MS,
+    rootOf: daemonRootOf,
   });
+  if (reaped.removed.length > 0)
+    console.error(
+      `Reaped ${reaped.removed.length} stopped daemon(s): ${reaped.removed.join(", ")}`,
+    );
 })();
 
 const prunedSnapshots = pruneDeadSnapshots();

package/src/ui/server/release-service.ts

@@ -19,13 +19,16 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 import { GH_API_TIMEOUT_MS } from "../../shared/constants.js";
 import {
+  readExplicitReleaseOrg,
   readReleaseConfig,
+  releaseOwnerFor,
   type ReleaseConfig,
   type ReleaseRepo,
   type ResolvedReleaseTarget,
   resolveReleaseTarget,
 } from "../../shared/den-config.js";
 import { readCatalog } from "../../shared/environment-manager/catalog.js";
+import { orgOf } from "../../shared/manifest/service-links.js";
 import { listReposWithManifests } from "../../shared/manifest/workspace-manifests.js";
 
 import { product } from "../../shared/product.js";
@@ -262,13 +265,23 @@ export class ReleaseService {
     };
   }
 
-  private org(cfg = this.config()): string {
-    return cfg.org ?? "";
+  /**
+   * The owner a repo is released from (REL-1): an explicit `release.org`
+   * (den.yml or user.yml) wins; otherwise the repo's own non-empty catalog
+   * owner, so a client org's repo releases from its own org; `github_org`
+   * (readReleaseConfig's fallback for `cfg.org`) last.
+   */
+  private ownerFor(repo: string, cfg: ReleaseConfig): string {
+    return releaseOwnerFor({
+      explicitOrg: readExplicitReleaseOrg(),
+      catalogOwner: orgOf(repo, readCatalog()),
+      githubOrg: cfg.org,
+    });
   }
 
   slug(repo: string, cfg = this.config()): string {
     const gh = cfg.repos.find((r) => r.name === repo)?.gh;
-    return gh && gh.includes("/") ? gh : `${this.org(cfg)}/${repo}`;
+    return gh && gh.includes("/") ? gh : `${this.ownerFor(repo, cfg)}/${repo}`;
   }
 
   /**

package/src/ui/server/workspace-routes.ts

@@ -65,6 +65,7 @@ import {
   getWaitDeps,
 } from "../../shared/environment-manager/dag.js";
 import { deriveGraph } from "../../shared/environment-manager/derivation/derive-graph.js";
+import { githubOrgFor } from "../../shared/environment-manager/workspace-org.js";
 import {
   deriveStartTargets,
   filterClosureForStart,
@@ -2158,7 +2159,9 @@ export async function handleWorkspaceRoutes(
         // flow writes one), which used to read as "not in the catalog" and
         // skip the clone entirely. Derive the conventional slug instead, and
         // persist it so every other flow (CLI up/setup) stops hitting this.
-        const ghSlug = resolveRepoGhSlug(svc.repoName);
+        const ghSlug = resolveRepoGhSlug(svc.repoName, readCatalog(), () =>
+          githubOrgFor(ws.name),
+        );
         if (!readCatalog()[svc.repoName]?.gh) {
           upsertCatalogEntry(svc.repoName, { gh: ghSlug });
         }