@monster-orange/den 0.2.8 → 0.4.0

package/src/shared/stacks/status.ts

@@ -10,13 +10,23 @@ import { readCatalog } from "../environment-manager/catalog.js";
 import { readEdgeConfig } from "../edge/config.js";
 import { routeUrl } from "../edge/render.js";
 import {
+  getActiveWorkspaces,
   getFocusedWorkspaceName,
   getWorkspaceByName,
   listWorkspaceServices,
 } from "../environment-manager/workspaces.js";
 import { readManifestStacks, readStacks } from "./config.js";
-import { projectName, stackWorkspace } from "./render.js";
-import { stackHealth, type StackContext } from "./runtime.js";
+import { STACK_NAMESPACE_RE } from "../den-config.js";
+import {
+  resolveStackNamespace,
+  type StackNamespaceSource,
+} from "./namespace.js";
+import { projectName } from "./render.js";
+import {
+  rejoinEdgeNetworks,
+  stackHealth,
+  type StackContext,
+} from "./runtime.js";
 
 export interface StackRoute {
   name: string;
@@ -38,40 +48,81 @@ export interface StackStatus {
   health?: { ok: boolean | null; detail: string };
 }
 
-const WS_RE = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
-
 /**
  * The den workspace stacks read their manifests from, and the Compose
  * project suffix they run under. `denWorkspace` defaults to the CLI's
- * -w override, then the focused workspace, then `default`.
+ * -w override, then the focused workspace, then `default`. The suffix is
+ * the workspace's stack namespace (namespace.ts); DEN_STACK_WORKSPACE, a
+ * per-command override, wins over it for this one process (source `env`).
+ *
+ * The one place a den workspace becomes a Compose project suffix: every
+ * stack path (status, runtime, health, container lookup) comes through here.
  */
 export function resolveStackWorkspaces(
   denWorkspace?: string | null,
   env: NodeJS.ProcessEnv = process.env,
-): { denWorkspace: string; stackWorkspace: string } {
+): {
+  denWorkspace: string;
+  stackWorkspace: string;
+  source: StackNamespaceSource | "env";
+} {
   const fkWs =
     denWorkspace ||
     env.DEN_WORKSPACE_OVERRIDE ||
     getFocusedWorkspaceName() ||
     "default";
-  const ws = env.DEN_STACK_WORKSPACE || stackWorkspace(fkWs);
-  if (!WS_RE.test(ws))
+  const override = env.DEN_STACK_WORKSPACE;
+  const resolved = override ? null : resolveStackNamespace(fkWs);
+  const ws = override || resolved!.namespace;
+  if (!STACK_NAMESPACE_RE.test(ws))
     throw new Error(
       `workspace "${ws}" must be lowercase letters, digits and dashes`,
     );
-  return { denWorkspace: fkWs, stackWorkspace: ws };
+  return {
+    denWorkspace: fkWs,
+    stackWorkspace: ws,
+    source: resolved ? resolved.source : "env",
+  };
 }
 
 /** The edge, the known stacks and the project suffix for one workspace. */
 export function loadStackContext(denWorkspace?: string | null): StackContext {
-  const { denWorkspace: fkWs, stackWorkspace: ws } =
-    resolveStackWorkspaces(denWorkspace);
+  const {
+    denWorkspace: fkWs,
+    stackWorkspace: ws,
+    source,
+  } = resolveStackWorkspaces(denWorkspace);
   const edge = readEdgeConfig();
   // Repo manifests come from that den workspace's checkouts.
   const stacks = readStacks(undefined, {
     workspace: getWorkspaceByName(fkWs) ? fkWs : undefined,
   });
-  return { edge, stacks, workspace: ws };
+  return {
+    edge,
+    stacks,
+    workspace: ws,
+    denWorkspace: fkWs,
+    namespaceSource: source,
+  };
+}
+
+/**
+ * After edge up: the edge back on the routed networks of every running
+ * stack it routes (rejoinEdgeNetworks), across the focused and active
+ * workspaces' stack namespaces. A workspace whose stacks cannot be read is
+ * skipped.
+ */
+export function rejoinRunningStacks(
+  onLine: (line: string) => void = console.log,
+): string[] {
+  const contexts: StackContext[] = [];
+  for (const ws of new Set([null, ...getActiveWorkspaces()]))
+    try {
+      contexts.push(loadStackContext(ws));
+    } catch {
+      /* unreadable: nothing of it to rejoin */
+    }
+  return rejoinEdgeNetworks(contexts, onLine);
 }
 
 /** Each stack's name, project, routes and (optionally) container health. */

package/src/shared/strategies/registry.ts

@@ -0,0 +1,89 @@
+/**
+ * Strategy registry: every concern that varies by distribution (secrets
+ * backend today; TLS and others next) is a strategy, and Den's built-ins
+ * register here exactly as a plugin would. An entry is
+ * `{ id, kind, detect(), capabilities }`:
+ *
+ *  - `kind` names the concern ("secrets"); ids are unique per kind;
+ *  - `detect()` is cheap and side-effect free: it never prompts, never
+ *    spawns a CLI that could prompt, and never prints a secret. It says
+ *    whether the strategy can work on this machine, and why not;
+ *  - `capabilities` is the kind's own interface (a factory, optional setup,
+ *    optional env injection, ...).
+ *
+ * No plugin loading happens here: a future plugin kind calls
+ * registerStrategy() with its entry.
+ */
+import * as fs from "fs";
+import * as path from "path";
+
+export interface DetectResult {
+  available: boolean;
+  /** Why the strategy is unavailable, or a note (e.g. "not configured"). */
+  reason?: string;
+}
+
+export interface StrategyEntry<K extends string = string, C = unknown> {
+  id: string;
+  kind: K;
+  detect(env?: NodeJS.ProcessEnv): DetectResult;
+  capabilities: C;
+}
+
+const registries = new Map<string, Map<string, StrategyEntry>>();
+
+/** Register (or replace) a strategy under its kind. */
+export function registerStrategy<K extends string, C>(
+  entry: StrategyEntry<K, C>,
+): void {
+  let byId = registries.get(entry.kind);
+  if (!byId) {
+    byId = new Map();
+    registries.set(entry.kind, byId);
+  }
+  byId.set(entry.id, entry as StrategyEntry);
+}
+
+/** The strategy `id` of `kind`, or undefined. */
+export function getStrategy<K extends string, C>(
+  kind: K,
+  id: string,
+): StrategyEntry<K, C> | undefined {
+  return registries.get(kind)?.get(id) as StrategyEntry<K, C> | undefined;
+}
+
+/** Every kind with a registered strategy, in registration order. */
+export function strategyKinds(): string[] {
+  return [...registries.keys()];
+}
+
+/** Every registered id of `kind`, in registration order. */
+export function strategyIds(kind: string): string[] {
+  return [...(registries.get(kind)?.keys() ?? [])];
+}
+
+/**
+ * True when an executable named `bin` is on `env.PATH`. A file check only:
+ * nothing is run, so it can never prompt (Touch ID, a login) or print.
+ */
+export function onPath(
+  bin: string,
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  const exts =
+    process.platform === "win32"
+      ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";")
+      : [""];
+  for (const dir of (env.PATH ?? "").split(path.delimiter)) {
+    if (!dir) continue;
+    for (const ext of exts) {
+      try {
+        fs.accessSync(path.join(dir, bin + ext), fs.constants.X_OK);
+        if (fs.statSync(path.join(dir, bin + ext)).isFile()) return true;
+      } catch {
+        /* not here */
+      }
+    }
+  }
+  return false;
+}