@monster-orange/den 0.2.4 → 0.2.5

package/src/shared/stacks/compose-health.ts

@@ -0,0 +1,150 @@
+/**
+ * Compose-stack health answered in-process, from one `docker ps` listing
+ * shared by every check that runs at the same time.
+ *
+ * Den gives a compose repo with no declared check a `<cli> stack health`
+ * shell check (composeHealthCmd), one per manifest service. Spawned, each
+ * was a full CLI start: 17-19 tsx processes per health cycle for three
+ * stacks, which on a loaded machine (load 35-55) ran past their budget and
+ * read as down. The checks Den generates itself are now judged here, with
+ * the verdict `stack health` gives; a distribution's own shell checks still
+ * run as shell commands.
+ */
+import { execFile } from "child_process";
+import type { RawManifest } from "../types/index.js";
+import { manifestStackName } from "./config.js";
+import { composeHealthCmd } from "./manifest-commands.js";
+import { projectName } from "./render.js";
+import { judgeStackRows, type ComposeRow } from "./runtime.js";
+import { resolveStackWorkspaces } from "./status.js";
+
+export { judgeStackRows, type ComposeRow };
+
+/** A Den-generated compose health check: what to look for in the listing. */
+export interface ComposeHealthTarget {
+  /** The Compose project (`<stack>-<stack workspace>`). */
+  project: string;
+  /** A compose service to check on its own; unset: the whole stack. */
+  service?: string;
+  /** The equivalent `<cli> stack health` command (shown as the check). */
+  cmd: string;
+}
+
+/** A health verdict; `ok: null` when docker could not be asked. */
+export interface ComposeVerdict {
+  ok: boolean | null;
+  detail: string;
+  /** With ok null: docker gave no answer within the budget. */
+  pending?: boolean;
+}
+
+/** The compose health check Den generates for this service, or null. */
+export function composeHealthTarget(
+  manifest: RawManifest,
+  subsystem: string,
+  repoName: string,
+  workspace: string,
+): ComposeHealthTarget | null {
+  const cmd = composeHealthCmd(manifest, subsystem, repoName, workspace);
+  if (!cmd) return null;
+  const project = projectName(
+    manifestStackName(manifest, repoName),
+    resolveStackWorkspaces(workspace).stackWorkspace,
+  );
+  const service = cmd.includes(" --service ") ? subsystem : undefined;
+  return { project, ...(service ? { service } : {}), cmd };
+}
+
+/** Budget for the shared listing; past it the checks are pending. */
+export const COMPOSE_LISTING_TIMEOUT_MS = 5_000;
+
+type Listing = { rows: ComposeRow[] } | { error: string; pending?: boolean };
+
+let inFlight: Promise<Listing> | null = null;
+
+/**
+ * Every compose container, from one `docker ps -a`. Concurrent callers share
+ * the call in flight, so a health cycle lists once however many checks it has.
+ */
+export function composeListing(): Promise<Listing> {
+  return (inFlight ??= listOnce().finally(() => {
+    inFlight = null;
+  }));
+}
+
+function listOnce(): Promise<Listing> {
+  return new Promise((done) => {
+    // Backstop: execFile reports only once the pipes close, which a killed
+    // process's children can hold open; the checks must not wait on that.
+    const guard = setTimeout(
+      () =>
+        resolve({
+          error: `docker gave no answer within ${COMPOSE_LISTING_TIMEOUT_MS / 1000}s`,
+          pending: true,
+        }),
+      COMPOSE_LISTING_TIMEOUT_MS + 500,
+    );
+    let settled = false;
+    const resolve = (l: Listing): void => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(guard);
+      done(l);
+    };
+    execFile(
+      "docker",
+      [
+        "ps",
+        "-a",
+        "--filter",
+        "label=com.docker.compose.project",
+        "--format",
+        '{{.Label "com.docker.compose.project"}}\t{{.Label "com.docker.compose.service"}}\t{{.State}}\t{{.Status}}',
+      ],
+      {
+        encoding: "utf-8",
+        timeout: COMPOSE_LISTING_TIMEOUT_MS,
+        maxBuffer: 16 * 1024 * 1024,
+      },
+      (err, stdout, stderr) => {
+        if (err) {
+          const killed = (err as { killed?: boolean }).killed === true;
+          return resolve(
+            killed
+              ? {
+                  error: `docker gave no answer within ${COMPOSE_LISTING_TIMEOUT_MS / 1000}s`,
+                  pending: true,
+                }
+              : {
+                  error:
+                    String(stderr || err.message).trim() || "docker ps failed",
+                },
+          );
+        }
+        const rows = stdout
+          .split("\n")
+          .filter(Boolean)
+          .map((line) => {
+            const [project = "", service = "", state = "", status = ""] =
+              line.split("\t");
+            return { project, service, state, status };
+          });
+        resolve({ rows });
+      },
+    );
+  });
+}
+
+/** The health of one Den-generated compose check, from the shared listing. */
+export async function composeHealth(
+  target: ComposeHealthTarget,
+): Promise<ComposeVerdict> {
+  const listing = await composeListing();
+  if ("error" in listing)
+    return {
+      ok: null,
+      detail: `container state unknown: ${listing.error}`,
+      ...(listing.pending ? { pending: true } : {}),
+    };
+  return judgeStackRows(listing.rows, target.project, target.service);
+}

package/src/shared/stacks/runtime.ts

@@ -364,39 +364,86 @@ export function stackLogs(
 
 /**
  * Health of a running stack: ok when it has containers, all are running, and
- * none reports a failing or pending Docker healthcheck.
+ * none reports a failing or pending Docker healthcheck. `ok: null` when
+ * docker could not be asked: container state unknown is not "not running".
  */
 export function stackHealth(
   ctx: StackContext,
   s: StackConfig,
   service?: string,
-): { ok: boolean; detail: string } {
+): { ok: boolean | null; detail: string } {
   const project = projectName(s.name, ctx.workspace);
-  const r = run("docker", [
-    "ps",
-    "-a",
-    "--filter",
-    `label=com.docker.compose.project=${project}`,
-    ...(service
-      ? ["--filter", `label=com.docker.compose.service=${service}`]
-      : []),
-    "--format",
-    '{{.Label "com.docker.compose.service"}}\t{{.State}}\t{{.Status}}',
-  ]);
-  if (r.code !== 0) return { ok: false, detail: r.err || "docker ps failed" };
-  const rows = r.out.split("\n").filter(Boolean);
-  if (!rows.length)
+  let r: ReturnType<typeof run>;
+  try {
+    r = run("docker", [
+      "ps",
+      "-a",
+      "--filter",
+      `label=com.docker.compose.project=${project}`,
+      ...(service
+        ? ["--filter", `label=com.docker.compose.service=${service}`]
+        : []),
+      "--format",
+      '{{.Label "com.docker.compose.service"}}\t{{.State}}\t{{.Status}}',
+    ]);
+  } catch (e) {
+    return {
+      ok: null,
+      detail: `container state unknown: ${(e as Error).message}`,
+    };
+  }
+  if (r.code !== 0)
+    return {
+      ok: null,
+      detail: `container state unknown: ${r.err.trim() || "docker ps failed"}`,
+    };
+  const rows = r.out
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      const [svc = "", state = "", status = ""] = line.split("\t");
+      return { project, service: svc, state, status };
+    });
+  return judgeStackRows(rows, project, service);
+}
+
+/** One compose container, as a `docker ps` listing reports it. */
+export interface ComposeRow {
+  project: string;
+  service: string;
+  state: string;
+  status: string;
+}
+
+/**
+ * The verdict `stack health` gives for `project` (and `service`): ok when it
+ * has containers, all running, none with a failing or starting Docker
+ * healthcheck. Shared by the CLI and the in-process check (compose-health).
+ */
+export function judgeStackRows(
+  rows: ComposeRow[],
+  project: string,
+  service?: string,
+): { ok: boolean; detail: string } {
+  const mine = rows.filter(
+    (r) => r.project === project && (!service || r.service === service),
+  );
+  if (!mine.length)
     return {
       ok: false,
       detail: `${project}${service ? `/${service}` : ""}: not running`,
     };
-  const bad = rows.filter((row) => {
-    const [, state, status] = row.split("\t");
-    return (
-      state !== "running" || /\((unhealthy|health: starting)\)/.test(status)
-    );
-  });
+  const bad = mine.filter(
+    (r) =>
+      r.state !== "running" ||
+      /\((unhealthy|health: starting)\)/.test(r.status),
+  );
   return bad.length
-    ? { ok: false, detail: bad.join("; ") }
-    : { ok: true, detail: `${rows.length} container(s) running` };
+    ? {
+        ok: false,
+        detail: bad
+          .map((r) => `${r.service}\t${r.state}\t${r.status}`)
+          .join("; "),
+      }
+    : { ok: true, detail: `${mine.length} container(s) running` };
 }

package/src/shared/stacks/status.ts

@@ -34,7 +34,8 @@ export interface StackStatus {
   routes: StackRoute[];
   uses: string[];
   /** Container health (only when asked for: it runs `docker ps`). */
-  health?: { ok: boolean; detail: string };
+  /** `ok: null`: docker could not be asked, so the state is unknown. */
+  health?: { ok: boolean | null; detail: string };
 }
 
 const WS_RE = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
@@ -96,7 +97,7 @@ export function stackStatuses(
       try {
         status.health = healthOf(ctx, s);
       } catch (e) {
-        status.health = { ok: false, detail: (e as Error).message };
+        status.health = { ok: null, detail: (e as Error).message };
       }
     }
     return status;

package/src/ui/cli/health-display.ts

@@ -13,6 +13,7 @@ export function healthLabelText(health: HealthState): string {
 export function formatHealthLabel(health: HealthState): string {
   if (health === "ok") return chalk.green("● ok");
   if (health === "error") return chalk.red("● down");
+  if (health === "pending") return chalk.gray("● pending");
   return chalk.gray("● unknown");
 }
 

package/src/ui/cli/index.ts

@@ -85,9 +85,11 @@ import {
   resolveServiceRuntime,
 } from "../../shared/environment-manager/service-runner.js";
 import {
-  defaultWorkspaceRepos,
+  blueprintWorkspaces,
   defaultWorkspaceNeedsSeeding,
   defaultWorkspaceHasServices,
+  isMultiBlueprint,
+  seedBlueprintWorkspaces,
   seedDefaultWorkspace,
   topUpDefaultWorkspace,
   markDefaultWorkspaceDeclined,
@@ -252,6 +254,14 @@ const WORKSPACE_SUBCOMMANDS: {
     usage: "code [n]",
     lines: ["open it in your editor (VS Code: a .code-workspace)"],
   },
+  {
+    name: "seed",
+    usage: "seed",
+    lines: [
+      "fill workspaces from the distribution's blueprint",
+      "(defaults.workspace / defaults.workspaces), all managed",
+    ],
+  },
 ];
 
 const COMMAND_HELP: Record<string, { usage: string; lines: string[] }> = {
@@ -2483,36 +2493,42 @@ class DenCLI {
   }
 
   /**
-   * Seed (or reset) the default workspace from the committed blueprint
-   * (config/den.yml `defaults.workspace`), all repos managed. Prints
-   * clear guidance and, on a TTY, asks first. `reason: "auto"` is the one-time
-   * offer on a fresh clone; `reason: "init"` is the explicit `den init`.
-   * Returns true if the workspace was seeded.
+   * Seed (or reset) the blueprint's workspaces from the committed config:
+   * `defaults.workspace` fills `default`; `defaults.workspaces` creates each
+   * named workspace, activates them all and focuses the marked one. All
+   * repos managed. Prints clear guidance and, on a TTY, asks first.
+   * `reason: "auto"` is the one-time offer on a genuine fresh setup (TTY
+   * only: see ensureWorkspaceSeeded); `reason: "init"` is the explicit
+   * `<cli> workspace seed` / `<cli> init` in the root. Returns true if seeded.
    */
   private async seedDefaultWorkspaceFlow(
     reason: "auto" | "init",
   ): Promise<boolean> {
-    const repos = defaultWorkspaceRepos();
-    if (repos.length === 0) {
+    const bps = blueprintWorkspaces();
+    if (bps.length === 0) {
       if (reason === "init") {
         console.log(
           chalk.yellow(
-            `\n  No defaults.workspace.repos in ${product().configFile} — nothing to seed.\n`,
+            `\n  No defaults.workspace.repos or defaults.workspaces in ${product().configFile} — nothing to seed.\n`,
           ),
         );
       }
       return false;
     }
+    const multi = isMultiBlueprint();
     const willReset = defaultWorkspaceHasServices();
     const interactive = !!(process.stdin.isTTY && process.stdout.isTTY);
 
-    console.log(
-      chalk.cyan(`\n  Default workspace — ${repos.length} repos, all managed:`),
-    );
-    console.log(chalk.gray(`    ${repos.join(", ")}`));
+    for (const bp of bps) {
+      const label = multi ? `Workspace ${bp.name}` : "Default workspace";
+      console.log(
+        chalk.cyan(`\n  ${label} — ${bp.repos.length} repos, all managed:`),
+      );
+      console.log(chalk.gray(`    ${bp.repos.join(", ")}`));
+    }
     console.log(
       chalk.gray(
-        `  ${product().title} clones + tracks them on main under ${product().servicesDir}/. Switch any`,
+        `  ${product().title} clones + tracks them on their branch under ${product().servicesDir}/. Switch any`,
       ),
     );
     console.log(
@@ -2522,16 +2538,17 @@ class DenCLI {
     );
 
     if (interactive) {
+      const what = multi ? "these workspaces" : "the default workspace";
       const question = willReset
-        ? "  Reset the default workspace to this shipped set?"
-        : "  Seed the default workspace now?";
+        ? `  Reset ${what} to this shipped set?`
+        : `  Seed ${what} now?`;
       const ok = await cliPrompts.confirm(question, !willReset);
       if (!ok) {
         if (reason === "auto") {
           markDefaultWorkspaceDeclined(); // don't ask again
           console.log(
             chalk.gray(
-              `  Skipped — run \`${product().cli} init\` to set it up later.\n`,
+              `  Skipped — run \`${product().cli} workspace seed\` to set it up later.\n`,
             ),
           );
         } else {
@@ -2541,6 +2558,17 @@ class DenCLI {
       }
     }
 
+    if (multi) {
+      const seeded = seedBlueprintWorkspaces();
+      const focus = readWorkspacesFile().focus;
+      console.log(
+        chalk.green(
+          `  ✓ ${seeded.length} workspaces ready (${seeded.map((w) => w.name).join(", ")}), all active; focus: ${focus}. ` +
+            `Run \`${product().cli} up <repo>\` to bring up its closure.\n`,
+        ),
+      );
+      return true;
+    }
     const seeded = seedDefaultWorkspace();
     console.log(
       chalk.green(
@@ -2552,13 +2580,22 @@ class DenCLI {
   }
 
   /**
-   * One-time offer to seed the default workspace on a fresh clone; afterwards
-   * keep it converged on the blueprint (repos added to defaults later — e.g.
-   * tasks-api — join the existing workspace managed).
+   * On a genuine fresh setup (nothing but an empty, never-seeded `default`),
+   * offer to seed from the blueprint: on a TTY, ask; otherwise print a
+   * one-line hint and change nothing. Afterwards keep a lone `default`
+   * converged on the blueprint (repos added to defaults later join it
+   * managed); never once the user has other workspaces.
    */
   private async ensureWorkspaceSeeded(): Promise<void> {
     if (defaultWorkspaceNeedsSeeding()) {
-      await this.seedDefaultWorkspaceFlow("auto");
+      if (process.stdin.isTTY && process.stdout.isTTY) {
+        await this.seedDefaultWorkspaceFlow("auto");
+      } else {
+        const hint = isMultiBlueprint()
+          ? "no workspaces yet: run `{cli} workspace seed` to create them from the blueprint"
+          : "default workspace is empty: run `{cli} workspace seed` to fill it from the blueprint";
+        console.error(chalk.gray(`  ${hint.replace("{cli}", product().cli)}`));
+      }
       return;
     }
     const added = topUpDefaultWorkspace();
@@ -3627,6 +3664,10 @@ class DenCLI {
         );
         break;
       }
+      case "seed": {
+        await this.seedDefaultWorkspaceFlow("init");
+        break;
+      }
       case "create": {
         const name =
           args[1] ??
@@ -3718,7 +3759,7 @@ class DenCLI {
       default:
         console.log(
           chalk.gray(
-            `Usage: ${product().cli} workspace <list|activate|deactivate|focus|use|create|delete|code> [name]`,
+            `Usage: ${product().cli} workspace <${WORKSPACE_SUBCOMMANDS.map((c) => c.name).join("|")}> [name]`,
           ),
         );
     }

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

@@ -22,6 +22,7 @@ import {
 } from "../../shared/stacks/runtime.js";
 import { loadStackContext, stackStatuses } from "../../shared/stacks/status.js";
 import type { StackConfig } from "../../shared/stacks/types.js";
+import { STACK_HEALTH_UNKNOWN_EXIT } from "../../shared/constants.js";
 
 function serviceFlag(args: string[]): { service?: string; rest: string[] } {
   const rest: string[] = [];
@@ -56,9 +57,48 @@ export async function resolveStacksSecretEnv(
   return out;
 }
 
+/**
+ * `stack health <name…>`: exit 0 when every stack is healthy, 1 when one is
+ * not, and STACK_HEALTH_UNKNOWN_EXIT when none failed but one could not be
+ * told (docker did not answer, the config could not be read). The web
+ * server's health row reads that as unknown, never as down.
+ */
+function stackHealthCommand(args: string[], service?: string): void {
+  let failed = false;
+  let unknown = false;
+  try {
+    const ctx = loadStackContext();
+    const names = args.filter((a) => !a.startsWith("-"));
+    if (!names.length)
+      throw new Error(
+        `Usage: stack health <name…>  (known: ${Object.keys(ctx.stacks).join(", ")})`,
+      );
+    for (const n of names) {
+      const s = ctx.stacks[n];
+      const h = s
+        ? stackHealth(ctx, s, service)
+        : { ok: false, detail: `unknown stack "${n}"` };
+      if (h.ok === false) failed = true;
+      if (h.ok === null) unknown = true;
+      const mark =
+        h.ok === true
+          ? chalk.green("✓")
+          : h.ok === false
+            ? chalk.red("✗")
+            : chalk.gray("?");
+      console.log(`${mark} ${n}  ${h.detail}`);
+    }
+  } catch (e) {
+    console.error(chalk.gray(`? ${(e as Error).message}`));
+    unknown = true;
+  }
+  process.exitCode = failed ? 1 : unknown ? STACK_HEALTH_UNKNOWN_EXIT : 0;
+}
+
 export async function cmdStack(argv: string[]): Promise<void> {
   const { service, rest } = serviceFlag(argv);
   const [sub = "ls", ...args] = rest;
+  if (sub === "health") return stackHealthCommand(args, service);
   // The global -w/--workspace is parsed (and checked) before we run and
   // arrives as DEN_WORKSPACE_OVERRIDE; loadStackContext reads it.
   const ctx = loadStackContext();
@@ -129,18 +169,6 @@ export async function cmdStack(argv: string[]): Promise<void> {
       }
       return;
     }
-    case "health": {
-      let ok = true;
-      for (const n of pick()) {
-        const h = stackHealth(ctx, stacks[n], service);
-        ok &&= h.ok;
-        console.log(
-          `${h.ok ? chalk.green("✓") : chalk.red("✗")} ${n}  ${h.detail}`,
-        );
-      }
-      process.exitCode = ok ? 0 : 1;
-      return;
-    }
     case "down":
       for (const n of startOrder(pick(), stacks)
         .reverse()

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,7 +11,7 @@ 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 { product } from "../../shared/product.js";
@@ -294,8 +295,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 +325,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 {