@monster-orange/den 0.4.2 → 0.4.4

package/src/ui/server/edge-exposure.ts

@@ -0,0 +1,143 @@
+/**
+ * The edge counts as local (0.4.3): with no sign-in through the edge, who
+ * can reach the edge can use terminals. When Den can tell the edge is
+ * reachable beyond this machine it says so, once in web.log and in a
+ * banner on every page (the shell, dismissible per browser).
+ *
+ * How it tells (read-only, once at start):
+ *  - an edge hostname that routes to Den resolves to an address that isn't
+ *    loopback (a LAN or a VPN address, such as Tailscale's 100.x); or
+ *  - the edge's container publishes a port on every interface (a
+ *    PortBindings HostIp of "", 0.0.0.0 or ::), from `docker inspect`.
+ * Neither (an edge on `*.localhost`, published on 127.0.0.1, or not
+ * running): no warning.
+ */
+import { execFile } from "child_process";
+import { promises as dns } from "dns";
+import { isLoopbackAddress } from "./request-guard.js";
+
+export const EDGE_EXPOSED_MESSAGE =
+  "Your edge is reachable from other machines; anyone who can reach it can use terminals. Auth is coming.";
+
+export interface ExposureDeps {
+  /** Every address a hostname resolves to (none when it doesn't). */
+  lookup?: (host: string) => Promise<string[]>;
+  /** The edge container's `docker inspect` PortBindings, or null. */
+  portBindings?: (container: string) => Promise<unknown>;
+}
+
+async function lookupAll(host: string): Promise<string[]> {
+  try {
+    return (await dns.lookup(host, { all: true })).map((a) => a.address);
+  } catch {
+    return [];
+  }
+}
+
+function inspectPortBindings(container: string): Promise<unknown> {
+  return new Promise((resolve) => {
+    execFile(
+      "docker",
+      ["inspect", "--format", "{{json .HostConfig.PortBindings}}", container],
+      { timeout: 5000 },
+      (err, stdout) => {
+        if (err) return resolve(null);
+        try {
+          resolve(JSON.parse(String(stdout)));
+        } catch {
+          resolve(null);
+        }
+      },
+    );
+  });
+}
+
+/** A published port bound on every interface, from PortBindings. */
+export function publishedOnAllInterfaces(bindings: unknown): string | null {
+  if (!bindings || typeof bindings !== "object") return null;
+  for (const [port, list] of Object.entries(bindings as object)) {
+    if (!Array.isArray(list)) continue;
+    for (const b of list as { HostIp?: string; HostPort?: string }[]) {
+      const ip = String(b?.HostIp ?? "");
+      if (ip === "" || ip === "0.0.0.0" || ip === "::")
+        return `the edge publishes ${b?.HostPort || port} on every interface`;
+    }
+  }
+  return null;
+}
+
+/**
+ * Why the edge is reachable beyond this machine, or null when Den can't
+ * tell that it is.
+ */
+export async function edgeExposure(
+  hosts: readonly string[],
+  container: string | null,
+  deps: ExposureDeps = {},
+): Promise<string | null> {
+  const lookup = deps.lookup ?? lookupAll;
+  for (const h of hosts) {
+    const away = (await lookup(h)).find((a) => !isLoopbackAddress(a));
+    if (away) return `${h} resolves to ${away}`;
+  }
+  if (!container || hosts.length === 0) return null;
+  const bindings = await (deps.portBindings ?? inspectPortBindings)(container);
+  return publishedOnAllInterfaces(bindings);
+}
+
+/**
+ * The IPv4 subnets of the edge's Docker networks (`<org>-edge` and the
+ * external networks it joins), from `docker network inspect`, read-only,
+ * once at start. On OrbStack and Docker Desktop a user-defined network is
+ * no host interface, so localNet can't see it: a proxy container on it, or
+ * its gateway, is this machine's container network ("can't tell", so
+ * local), not another machine. None when Docker or the network isn't
+ * there.
+ */
+export async function edgeNetworkSubnets(
+  names: readonly string[],
+  inspect: (name: string) => Promise<unknown> = inspectNetworkIpam,
+): Promise<{ address: string; netmask: string }[]> {
+  const out: { address: string; netmask: string }[] = [];
+  for (const n of [...new Set(names)]) {
+    const ipam = await inspect(n);
+    if (!Array.isArray(ipam)) continue;
+    for (const c of ipam as { Subnet?: unknown }[]) {
+      const s = cidrToSubnet(String(c?.Subnet ?? ""));
+      if (s) out.push(s);
+    }
+  }
+  return out;
+}
+
+/** "192.168.214.0/24" → { address, netmask }; null for IPv6 or junk. */
+export function cidrToSubnet(
+  cidr: string,
+): { address: string; netmask: string } | null {
+  const m = /^(\d{1,3}(?:\.\d{1,3}){3})\/(\d{1,2})$/.exec(cidr.trim());
+  if (!m) return null;
+  const bits = Number(m[2]);
+  if (bits < 8 || bits > 32) return null;
+  if (m[1].split(".").some((o) => Number(o) > 255)) return null;
+  const mask = (0xffffffff << (32 - bits)) >>> 0;
+  const netmask = [24, 16, 8, 0].map((s) => (mask >>> s) & 255).join(".");
+  return { address: m[1], netmask };
+}
+
+function inspectNetworkIpam(name: string): Promise<unknown> {
+  return new Promise((resolve) => {
+    execFile(
+      "docker",
+      ["network", "inspect", "--format", "{{json .IPAM.Config}}", name],
+      { timeout: 5000 },
+      (err, stdout) => {
+        if (err) return resolve(null);
+        try {
+          resolve(JSON.parse(String(stdout)));
+        } catch {
+          resolve(null);
+        }
+      },
+    );
+  });
+}

package/src/ui/server/index.ts

@@ -17,6 +17,7 @@ import {
   type ContainerHealthTarget,
 } from "../../shared/stacks/compose-health.js";
 import { healthCheckFields, type HealthCheckType } from "./health-row.js";
+import { notCheckedReason } from "../../shared/health/not-checked.js";
 import { hasRuntime, repoKind } from "../../shared/repo-kind.js";
 import * as http from "http";
 import * as net from "net";
@@ -162,6 +163,7 @@ import {
   saveSudoToVault,
   sudoRef,
   sudoVaultStatus,
+  sudoVaultWhere,
   SUDO_REF_NAME,
 } from "../../shared/auth/sudo-vault.js";
 import {
@@ -184,8 +186,10 @@ import {
   bindRefusal,
   checkRequest,
   isEdgePeer,
+  isDockerBridgeAddress,
   isLoopbackAddress,
   isLoopbackBind,
+  localNet,
   newCsrfToken,
   principalOf,
   requestIsHttps,
@@ -273,6 +277,10 @@ interface HealthResult {
   pending?: boolean;
   status?: number;
   error?: string;
+  /** A 3xx answer's target (MCP-2.4): ok null, not down. */
+  redirect?: string;
+  /** With ok null and nothing checked: why not (MCP-2.4). */
+  why?: string;
   /** Where the app opens for this env (open-in-new-tab), or null. */
   openUrl?: string | null;
   /** Extra named links for this env. */
@@ -549,6 +557,13 @@ setHtmlFill((html) => {
         () => '<div id="den-shell" data-config-invalid="1"',
       );
   }
+  // 0.4.3: every page says when the edge is reachable from other machines.
+  if (EDGE_EXPOSED)
+    out = out.replace(
+      '<div id="den-shell"',
+      () =>
+        `<div id="den-shell" data-edge-exposed="${escAttr(EDGE_EXPOSED_MESSAGE)}"`,
+    );
   // MD-2: every page says when the engine on disk is not the one running.
   const engine = engineCheck();
   if (engine.stale)
@@ -707,12 +722,14 @@ const CONFIG_FREE_PAGES = new Set(["/settings", "/settings.html", "/logs"]);
 import {
   setSudoPassword,
   clearSudoPassword,
+  clearSudoShims,
   closeLockForThisRequest,
   inRequestLockScope,
   getSudoEnv,
   prewarmSudo,
   hasSudoPassword,
   hasPasswordlessSudo,
+  watchSudo,
 } from "./sudo-store.js";
 import {
   guardStdio,
@@ -721,6 +738,9 @@ import {
   requestShutdown,
 } from "./shutdown-guard.js";
 
+/** This server saved the admin password to the vault or loaded it from there. */
+let sudoInVault = false;
+
 // ── HTTP helpers ─────────────────────────────────────────────────────────────
 import { sweepLogs } from "../../shared/process/log-rotation.js";
 import {
@@ -773,7 +793,17 @@ import {
 import { refuseUpgrade } from "./websocket.js";
 import { isLifecycleExecCmd, streamLifecycleExec } from "./lifecycle-exec.js";
 import { readEdgeConfig, readWebPort } from "../../shared/edge/config.js";
-import { edgeDomains, edgeHttps, routeHost } from "../../shared/edge/render.js";
+import {
+  edgeHttps,
+  edgeNames,
+  webRouteHosts,
+} from "../../shared/edge/render.js";
+import {
+  EDGE_EXPOSED_MESSAGE,
+  edgeExposure,
+  edgeNetworkSubnets,
+} from "./edge-exposure.js";
+import { initLoginPath } from "../../shared/agents/runtime-search.js";
 import {
   linksFor,
   openUrlFor,
@@ -904,24 +934,8 @@ function denEdgeHosts(): string[] {
   } catch {
     return [];
   }
-  const ports = new Set([PORT, readWebPortSafe()]);
-  const names = Object.entries(cfg.routes)
-    .filter(([, upstream]) => {
-      try {
-        const u = new URL(upstream);
-        return (
-          ports.has(Number(u.port || (u.protocol === "https:" ? 443 : 80))) &&
-          ["host.docker.internal", "localhost", "127.0.0.1"].includes(
-            u.hostname,
-          )
-        );
-      } catch {
-        return false;
-      }
-    })
-    .map(([name]) => name);
-  return names.flatMap((n) =>
-    edgeDomains(cfg).map((d) => routeHost(n, d).toLowerCase()),
+  return webRouteHosts(cfg, new Set([PORT, readWebPortSafe()])).map(
+    (r) => r.host,
   );
 }
 
@@ -1016,6 +1030,36 @@ function sessionCookie(req: http.IncomingMessage): string | undefined {
 }
 
 const LAN_HOSTS = lanHosts();
+/** This machine's addresses (localNet), re-read at most every 10 s. */
+let LOCAL_NET = { at: 0, net: localNet() };
+/** The edge's Docker networks' subnets (edgeNetworkSubnets), once at start. */
+let EDGE_NETS: { address: string; netmask: string }[] = [];
+function currentLocalNet(): ReturnType<typeof localNet> {
+  if (Date.now() - LOCAL_NET.at > 10_000) {
+    const here = localNet();
+    LOCAL_NET = {
+      at: Date.now(),
+      net: { own: here.own, bridges: [...here.bridges, ...EDGE_NETS] },
+    };
+  }
+  return LOCAL_NET.net;
+}
+/** Read the edge's Docker networks' subnets in the background (no edge: none). */
+function readEdgeNetworks(): void {
+  let names: string[];
+  try {
+    const cfg = readEdgeConfig();
+    names = [edgeNames(cfg.org).network, ...cfg.networks];
+  } catch {
+    return;
+  }
+  void edgeNetworkSubnets(names)
+    .then((nets) => {
+      EDGE_NETS = nets;
+      LOCAL_NET = { at: 0, net: LOCAL_NET.net }; // re-read on the next request
+    })
+    .catch(() => undefined);
+}
 const GUARD: GuardContext = {
   port: PORT,
   loopbackNames: loopbackNames(),
@@ -1044,8 +1088,43 @@ const GUARD: GuardContext = {
   peerIsLoopback: (req) => isLoopbackAddress(req.socket?.remoteAddress),
   // The edge hostname only from the edge's own peers (loopback, Docker).
   peerIsEdge: (req) => isEdgePeer(req.socket?.remoteAddress),
+  // 0.4.3: the edge from this machine counts as local (edgeClientIsLocal).
+  localNet: currentLocalNet,
+  // A deliberate exposure (DEN_BIND_HOST beyond loopback, other than the
+  // Linux edge's Docker bridge): the edge needs a sign-in too.
+  exposed: !isLoopbackBind(BIND_HOST) && !isDockerBridgeAddress(BIND_HOST),
 };
 
+/**
+ * 0.4.3: why the edge is reachable beyond this machine (edge-exposure.ts),
+ * once at start; null until known, or when Den can't tell.
+ */
+let EDGE_EXPOSED: string | null = null;
+function checkEdgeExposure(): void {
+  // `docker inspect` only when the edge publishes host ports itself
+  // (edge.publish); behind another proxy, only the hostnames tell.
+  let container: string | null = null;
+  try {
+    const cfg = readEdgeConfig();
+    container = cfg.ports ? edgeNames(cfg.org).container : null;
+  } catch {
+    return; // no edge
+  }
+  const hosts = denEdgeHosts();
+  if (hosts.length === 0) return;
+  void edgeExposure(hosts, container)
+    .then((why) => {
+      if (!why) return;
+      EDGE_EXPOSED = why;
+      // The in-app log, and stderr, which is web.log even when `web up`
+      // starts this --silent (stdout is not written then).
+      const line = `  ⚠ ${EDGE_EXPOSED_MESSAGE} (${why})`;
+      pushLog("warn", line);
+      if (!outputLost()) process.stderr.write(line + "\n");
+    })
+    .catch(() => undefined);
+}
+
 /**
  * The Set-Cookie for a session: HttpOnly, SameSite=Strict, Path=/, Secure
  * when the request came over HTTPS (requestIsHttps: the edge's own header
@@ -1775,6 +1854,8 @@ async function handleRequest(
       compose: ComposeHealthTarget | null;
       /** A `type: container` check: answered from the shared listing. */
       container: ContainerHealthTarget | null;
+      /** The repo has no manifest (the row is kept, unchecked). */
+      noManifest?: boolean;
       meta: Pick<HealthResult, "runs" | "target" | "focused" | "workspaces">;
     }> = [];
     const focusName = getFocusedWorkspaceName();
@@ -1817,6 +1898,7 @@ async function handleRequest(
           org: orgOf(resolved.repoName, catalog),
           compose: null,
           container: null,
+          noManifest: true,
           meta: {
             runs: "none",
             target: null,
@@ -1944,6 +2026,7 @@ async function handleRequest(
       expect,
       compose,
       container,
+      noManifest,
     }) => {
       if (checkType !== "none") {
         const started = Date.now();
@@ -2010,6 +2093,13 @@ async function handleRequest(
         isEntrypoint,
         ...meta,
         ok: null,
+        why: notCheckedReason({
+          env,
+          runs: meta.runs,
+          target: meta.target,
+          manifest: !noManifest,
+          conventional,
+        }),
       };
     };
     // Stream each result the moment it lands. The checks run concurrently but
@@ -2176,9 +2266,10 @@ async function handleRequest(
       Connection: "keep-alive",
       "X-Accel-Buffering": "no",
     });
-    const emit = (obj: unknown): void => {
+    // LK-0: the command's sudo without the password is a needs-sudo event.
+    const emit = watchSudo((obj: unknown): void => {
       res.write(`data: ${JSON.stringify(obj)}\n\n`);
-    };
+    }, `${repoName}/${svcName} ${cmdName}`);
     // Every fail here is before anything ran: a refusal or a lookup miss.
     // Recorded, so failed attempts show in the activity trail (F2).
     const fail = (msg: string): void => {
@@ -3796,8 +3887,13 @@ async function handleRequest(
   }
 
   // ── API: sudo password ────────────────────────────────────────────────────
+  // LK-0: the admin password is for sudo, and nothing else: no route asks
+  // for it as an access check. A run that is about to run sudo without it
+  // streams a needs-sudo event (watchSudo); the page asks, then runs again.
   // POST /api/sudo-password  body: { password: string, saveToVault?: boolean }
-  // GET  /api/sudo-password/status         → { set: boolean }
+  // POST /api/sudo-password/forget         → { ok, vaultCleared, vaultError? }
+  // GET  /api/sudo-password/status         → { set, passwordless,
+  //        saved: "vault" | "session" | null, vault: { configured, label } }
   // GET  /api/sudo-password/vault-status   → { backend, label, configured,
   //        backendAvailable, reason?, hasStored, opAvailable (deprecated) }
   // POST /api/sudo-password/load-from-vault → { ok, reason?, message? }
@@ -3833,6 +3929,7 @@ async function handleRequest(
         try {
           await saveSudoToVault(password);
           savedToVault = true;
+          sudoInVault = true;
         } catch (err) {
           vaultError = (err as Error).message;
         }
@@ -3844,10 +3941,51 @@ async function handleRequest(
   }
 
   if (pathname === "/api/sudo-password/status") {
-    // passwordless: NOPASSWD sudoer (or warm cache) — no admin login needed.
+    // passwordless: NOPASSWD sudoer (or warm cache) — sudo needs none.
+    // saved (Settings, LK-0): "vault" once this server saved it there or
+    // loaded it from there, "session" when it is held in memory only.
+    const set = hasSudoPassword();
     return sendJson(res, {
-      set: hasSudoPassword(),
+      set,
       passwordless: hasPasswordlessSudo(),
+      saved: sudoInVault ? "vault" : set ? "session" : null,
+      vault: sudoVaultWhere(),
+    });
+  }
+
+  // Forget (Settings, LK-0): the password this server holds goes, and the
+  // vault's copy when this server knows there is one (written empty, which
+  // every read takes as none). sudo's own cache is dropped too.
+  if (pathname === "/api/sudo-password/forget") {
+    if (req.method !== "POST") {
+      res.writeHead(405);
+      res.end();
+      return;
+    }
+    clearSudoPassword();
+    try {
+      execSync("sudo -k", {
+        stdio: ["ignore", "ignore", "ignore"],
+        timeout: CLI_SPAWN_TIMEOUT_MS,
+      });
+    } catch {
+      /* best-effort */
+    }
+    let vaultCleared = false;
+    let vaultError: string | undefined;
+    if (sudoInVault) {
+      try {
+        await saveSudoToVault("");
+        vaultCleared = true;
+        sudoInVault = false;
+      } catch (err) {
+        vaultError = (err as Error).message;
+      }
+    }
+    return sendJson(res, {
+      ok: true,
+      vaultCleared,
+      ...(vaultError ? { vaultError } : {}),
     });
   }
 
@@ -3892,6 +4030,7 @@ async function handleRequest(
       return sendJson(res, { ok: false, reason: "stale" });
     }
     setSudoPassword(password);
+    sudoInVault = true;
     return sendJson(res, { ok: true });
   }
 
@@ -4572,6 +4711,11 @@ try {
 } catch (e) {
   serverLog(`  ⚠ web.secret could not be created: ${(e as Error).message}`);
 }
+// AG-0.1: the login shell's PATH, once, in the background (3 s at most),
+// so agents find their CLI as the person's terminal would: a launchd
+// service's PATH leaves out ~/.local/bin. Until (or unless) it answers, the
+// search is this PATH and the runtimes' install directories.
+void initLoginPath();
 server.listen(PORT, BIND_HOST, () => {
   const hosts = fs.existsSync("/etc/hosts")
     ? fs.readFileSync("/etc/hosts", "utf-8")
@@ -4594,6 +4738,8 @@ server.listen(PORT, BIND_HOST, () => {
   console.log();
   // Once per start: a secrets config that leaves Den's own features off.
   for (const w of secretsConfigWarnings()) serverLog(`  ⚠ ${w}`);
+  checkEdgeExposure();
+  readEdgeNetworks();
 });
 
 // ── Graceful shutdown ─────────────────────────────────────────────────────────
@@ -4672,7 +4818,7 @@ async function stopDaemons(): Promise<void> {
 }
 
 async function handleShutdown(signal: string): Promise<void> {
-  clearSudoPassword();
+  clearSudoShims();
   // The registry lives in the state dir, which is resolved from the
   // distribution root on every call: if that can no longer be found (den.yml
   // moved or removed while the server ran), still exit. Never product() here: