@monster-orange/den 0.2.8 → 0.3.0

package/src/shared/environment-manager/up-targets.ts

@@ -0,0 +1,132 @@
+/**
+ * What starting a repo runs (0.3.0-dev.35; backported to 0.2.8): the one
+ * decision `up <repo>` (its dependency closure) and `up -a` / `-A` share.
+ *
+ *   - the repo's own `up`                → the repo
+ *   - none, but its services have one    → those services: all of them, or,
+ *                                          for a repo started only as a
+ *                                          dependency, the ones its
+ *                                          dependents name (`depends_on:
+ *                                          [acme/api]`); every one when any
+ *                                          dependent needs the repo as a
+ *                                          whole
+ *   - no up at all                       → skipped ("no local up command")
+ *
+ * A repo that can't be resolved in the workspace is passed through
+ * unchanged, so the runner reports it as before. Reads manifests from disk:
+ * call it once the start set's clones exist.
+ */
+import { readManifest } from "../manifest/read-manifest.js";
+import { depService } from "../manifest/deps.js";
+import type { DerivedGraph } from "./derivation/types.js";
+import {
+  getWorkspaceServices,
+  previewServiceCommand,
+  resolveService,
+} from "./service-runner.js";
+
+export interface UpTargets {
+  /** The start order, a repo replaced by its services where it has no up. */
+  order: string[];
+  /** Repos with no up at all (said and skipped, never fatal). */
+  skippedNoUp: string[];
+  /** repo → the service addresses that start in its place. */
+  expanded: Map<string, string[]>;
+  /**
+   * A list of dependency repos as the start set has them: an expanded repo
+   * becomes its services, a skipped one is dropped (nothing to wait on).
+   */
+  depsAs(deps: string[]): string[];
+}
+
+/** The repo part of an address ("acme/api" → "acme"). */
+export const repoOfAddress = (address: string): string => address.split("/")[0];
+
+/**
+ * @param order   repos in start order
+ * @param opts.targets   repos started for their own sake (the seed, or every
+ *                       `-a` candidate): all their services start
+ * @param opts.graph     the derived graph: who depends on whom
+ */
+export function resolveUpTargets(
+  order: string[],
+  workspace: string,
+  opts: { targets: ReadonlySet<string>; graph?: DerivedGraph },
+): UpTargets {
+  const services = getWorkspaceServices(workspace);
+  const expanded = new Map<string, string[]>();
+  const skippedNoUp: string[] = [];
+  const out: string[] = [];
+  const runs = (address: string): boolean =>
+    previewServiceCommand(address, "up", workspace).kind === "run";
+  for (const repo of order) {
+    const own = previewServiceCommand(repo, "up", workspace).kind;
+    if (
+      own === "run" ||
+      own === "via-repo" ||
+      !resolveService(repo, workspace)
+    ) {
+      out.push(repo);
+      continue;
+    }
+    const withUp = services
+      .filter((s) => s.repoName === repo && s.address !== repo)
+      .map((s) => s.address)
+      .filter(runs);
+    if (withUp.length === 0) {
+      skippedNoUp.push(repo);
+      continue;
+    }
+    const wanted = opts.targets.has(repo)
+      ? null
+      : namedByDependents(repo, order, workspace, opts.graph);
+    const start = wanted ? withUp.filter((a) => wanted.has(a)) : withUp;
+    const pick = start.length ? start : withUp;
+    expanded.set(repo, pick);
+    out.push(...pick);
+  }
+  const skipped = new Set(skippedNoUp);
+  return {
+    order: out,
+    skippedNoUp,
+    expanded,
+    depsAs: (deps) =>
+      deps.flatMap((d) => (skipped.has(d) ? [] : (expanded.get(d) ?? [d]))),
+  };
+}
+
+/**
+ * The services of `repo` its dependents in `order` name, or null when one
+ * of them needs the repo as a whole (names it bare, or depends on it by a
+ * derived edge with no `depends_on` naming a service of it).
+ */
+function namedByDependents(
+  repo: string,
+  order: string[],
+  workspace: string,
+  graph?: DerivedGraph,
+): Set<string> | null {
+  const named = new Set<string>();
+  const dependents = new Set(
+    (graph?.edges ?? [])
+      .filter((e) => e.to === repo && e.from !== repo)
+      .map((e) => e.from),
+  );
+  for (const dependent of order) {
+    if (dependent === repo) continue;
+    const resolved = resolveService(dependent, workspace);
+    const manifest = resolved ? readManifest(resolved.repoPath) : null;
+    let mine = 0;
+    for (const s of Object.values(manifest?.services ?? {}))
+      for (const dep of s?.depends_on ?? []) {
+        const d = depService(dep);
+        if (d === repo) return null;
+        if (repoOfAddress(d) === repo) {
+          named.add(d);
+          mine++;
+        }
+      }
+    if (dependents.has(dependent) && mine === 0) return null;
+  }
+  return named.size ? named : null;
+}

package/src/shared/health/rollup.ts

@@ -0,0 +1,48 @@
+/**
+ * The repo health rollup, typed for TypeScript callers (`<cli> status`).
+ *
+ * The rule itself is one plain ES module, src/ui/server/public/health-rollup.js,
+ * because the browser runs it too (the header row and the graph): one
+ * function everywhere, so the row, its chip, the graph and `status` never
+ * disagree. See that file for the rule.
+ */
+import * as rollup from "../../ui/server/public/health-rollup.js";
+
+export type RepoState = "down" | "degraded" | "ok" | "unknown";
+
+export interface HealthSignal {
+  service: string;
+  /** true up, false down or failing, null not checked (or not yet). */
+  ok: boolean | null | undefined;
+  isEntrypoint?: boolean;
+  /** Not answered yet this cycle: the repo stays unknown until it has. */
+  awaiting?: boolean;
+}
+
+export interface RepoRollup {
+  state: RepoState;
+  /** The entry service's name, or null when none can be told. */
+  entry: string | null;
+  /** Checked services that are down, by name. */
+  down: string[];
+  checked: number;
+  unchecked: number;
+  /** Checks that haven't answered yet; any holds the state at unknown. */
+  awaiting: number;
+}
+
+export const STATE_RANK: Record<RepoState, number> = rollup.STATE_RANK;
+
+export const rollupRepo = rollup.rollupRepo as (
+  repo: string,
+  signals: HealthSignal[],
+) => RepoRollup;
+
+export const describeRollup = rollup.describeRollup as (
+  r: RepoRollup,
+) => string;
+
+export const compareRepos = rollup.compareRepos as (
+  a: { state: RepoState; repo: string; focused?: boolean },
+  b: { state: RepoState; repo: string; focused?: boolean },
+) => number;

package/src/shared/open-url.ts

@@ -6,7 +6,8 @@
  * Order, first answer wins:
  *   1. manifest `services.<svc>.urls.<env>`
  *   2. local only: the edge route for the service's compose container,
- *      `https://<route>.<stack>.<edge domain>`; the stack-wide service (the
+ *      `https://<route>.<stack>.<edge domain>` (`http://` and the edge's http
+ *      port for `tls: none`, 0.3.0-dev.40); the stack-wide service (the
  *      entrypoint, or one named after the stack) takes the `app` route, else
  *      the first route
  *   3. the origin of the env's HTTP health URL
@@ -32,11 +33,22 @@ export function httpUrl(raw: unknown): string | null {
   }
 }
 
+/**
+ * How the edge serves its routes: https on 443 (every edge.tls strategy but
+ * `none`), or http on its http port for `tls: none`. A non-default port is
+ * part of the URL.
+ */
+export interface EdgeOrigin {
+  https: boolean;
+  port?: number | null;
+}
+
 function edgeRouteUrl(
   manifest: DenManifest,
   subsystem: string,
   repoName: string,
   edgeDomain: string,
+  origin: EdgeOrigin,
 ): string | null {
   const routes = manifest.compose?.routes;
   if (!routes || !Object.keys(routes).length) return null;
@@ -51,7 +63,11 @@ function edgeRouteUrl(
   });
   if (!route && (manifest.entrypoint === subsystem || subsystem === stack))
     route = routes.app ? "app" : names[0];
-  return route ? `https://${route}.${stack}.${edgeDomain}/` : null;
+  if (!route) return null;
+  const scheme = origin.https ? "https" : "http";
+  const dflt = origin.https ? 443 : 80;
+  const port = origin.port && origin.port !== dflt ? `:${origin.port}` : "";
+  return `${scheme}://${route}.${stack}.${edgeDomain}${port}/`;
 }
 
 export function openUrlFor(opts: {
@@ -63,6 +79,8 @@ export function openUrlFor(opts: {
   healthUrl?: string | null;
   /** Primary edge domain; local edge routes are skipped without it. */
   edgeDomain?: string | null;
+  /** The edge's scheme and port (default: https on 443). */
+  edgeOrigin?: EdgeOrigin;
 }): string | null {
   const svc = opts.manifest.services?.[opts.subsystem];
   const declared = httpUrl(
@@ -75,6 +93,7 @@ export function openUrlFor(opts: {
       opts.subsystem,
       opts.repoName,
       opts.edgeDomain,
+      opts.edgeOrigin ?? { https: true },
     );
     if (routed) return routed;
   }

package/src/shared/org-sources.ts

@@ -17,7 +17,7 @@
  * GitHub sources clone through the user's gh, a repo with no source clones
  * from its catalog `remote:` through plain git (SEC-0).
  */
-import { ConfigError } from "./config-error.js";
+import { ConfigError, type ConfigIssue } from "./config-error.js";
 import type { ServiceCatalog, ServiceCatalogEntry } from "./types/index.js";
 
 /** `orgs.<id>.sources[i]`: a git host and the owner (or group) it claims. */
@@ -65,13 +65,23 @@ const sourceOwner = (s: OrgSourceConfig): string =>
   (s.owner ?? s.group ?? "").trim();
 
 /**
- * Check the ORG-1d keys of `orgs:` and throw on the first problem, naming the
- * key. Entries without them are not looked at (C1). A repo listed by two
- * orgs, or an owner claimed by two orgs' sources (or by a source and a
- * legacy org of that name), names both.
+ * Check the ORG-1d keys of `orgs:` and throw a ConfigError listing every
+ * problem (0.3.0-dev.40; it threw on the first), each naming its key. A
+ * problem with a source skips the rest of that source; one with `sources`
+ * or `repos` as a whole skips that key. Entries without them are not
+ * looked at (C1). A repo listed by two orgs, or an owner claimed by two
+ * orgs' sources (or by a source and a legacy org of that name), names both.
  */
 export function validateOrgSources(orgs: unknown, file: string): void {
   if (!orgs || typeof orgs !== "object" || Array.isArray(orgs)) return;
+  const issues: ConfigIssue[] = [];
+  // `text` is the message as it reads after "<file>: ".
+  const bad = (key: string, text: string): void => {
+    const message = text.startsWith(key)
+      ? text.slice(key.length).replace(/^:?\s*/, "")
+      : text;
+    issues.push({ file, key, message, text });
+  };
   const entries = Object.entries(orgs as Record<string, unknown>);
   const repoAt = new Map<string, string>();
   const ownerAt = new Map<string, string>();
@@ -81,67 +91,74 @@ export function validateOrgSources(orgs: unknown, file: string): void {
     const at = `orgs.${id}`;
     if ("sources" in e) {
       if (!Array.isArray(e.sources))
-        throw new ConfigError(
-          `${file}: ${at}.sources must be a list of { host, owner } or { host, group }`,
+        bad(
+          `${at}.sources`,
+          `${at}.sources must be a list of { host, owner } or { host, group }`,
         );
-      e.sources.forEach((s: unknown, i: number) => {
-        const k = `${at}.sources[${i}]`;
-        if (!s || typeof s !== "object" || Array.isArray(s))
-          throw new ConfigError(
-            `${file}: ${k} must be a map: { host: github, owner: <owner> }`,
-          );
-        const src = s as Record<string, unknown>;
-        for (const key of Object.keys(src))
-          if (!["host", "owner", "group"].includes(key))
-            throw new ConfigError(
-              `${file}: ${k}: unknown key "${key}" (known: host, owner, group)`,
+      else
+        e.sources.forEach((s: unknown, i: number) => {
+          const k = `${at}.sources[${i}]`;
+          if (!s || typeof s !== "object" || Array.isArray(s))
+            return bad(
+              k,
+              `${k} must be a map: { host: github, owner: <owner> }`,
             );
-        if (typeof src.host !== "string" || !HOST_RE.test(src.host))
-          throw new ConfigError(
-            `${file}: ${k}.host must be a git host id such as github or gitlab`,
-          );
-        const hasOwner = src.owner !== undefined;
-        const hasGroup = src.group !== undefined;
-        if (hasOwner === hasGroup)
-          throw new ConfigError(
-            `${file}: ${k} needs exactly one of owner or group`,
+          const src = s as Record<string, unknown>;
+          const unknown = Object.keys(src).find(
+            (key) => !["host", "owner", "group"].includes(key),
           );
-        const key = hasOwner ? "owner" : "group";
-        const v = src[key];
-        const ok =
-          typeof v === "string" &&
-          (src.host === "github" ? GH_OWNER_RE : GROUP_RE).test(v.trim());
-        if (!ok)
-          throw new ConfigError(
-            src.host === "github"
-              ? `${file}: ${k}.${key} must be a GitHub owner name (letters, digits and hyphens)`
-              : `${file}: ${k}.${key} must be an owner or group path`,
-          );
-        const claim = `${src.host}:${lower((v as string).trim())}`;
-        const prior = ownerAt.get(claim);
-        if (prior && !prior.startsWith(`${at}.`))
-          throw new ConfigError(
-            `${file}: ${src.host} owner ${(v as string).trim()} is claimed by both ${prior} and ${k}`,
-          );
-        if (!prior) ownerAt.set(claim, k);
-      });
+          if (unknown !== undefined)
+            return bad(
+              k,
+              `${k}: unknown key "${unknown}" (known: host, owner, group)`,
+            );
+          if (typeof src.host !== "string" || !HOST_RE.test(src.host))
+            return bad(
+              `${k}.host`,
+              `${k}.host must be a git host id such as github or gitlab`,
+            );
+          const hasOwner = src.owner !== undefined;
+          const hasGroup = src.group !== undefined;
+          if (hasOwner === hasGroup)
+            return bad(k, `${k} needs exactly one of owner or group`);
+          const key = hasOwner ? "owner" : "group";
+          const v = src[key];
+          const ok =
+            typeof v === "string" &&
+            (src.host === "github" ? GH_OWNER_RE : GROUP_RE).test(v.trim());
+          if (!ok)
+            return bad(
+              `${k}.${key}`,
+              src.host === "github"
+                ? `${k}.${key} must be a GitHub owner name (letters, digits and hyphens)`
+                : `${k}.${key} must be an owner or group path`,
+            );
+          const claim = `${src.host}:${lower((v as string).trim())}`;
+          const prior = ownerAt.get(claim);
+          if (prior && !prior.startsWith(`${at}.`))
+            return bad(
+              k,
+              `${src.host} owner ${(v as string).trim()} is claimed by both ${prior} and ${k}`,
+            );
+          if (!prior) ownerAt.set(claim, k);
+        });
     }
     if ("repos" in e) {
       if (
         !Array.isArray(e.repos) ||
         e.repos.some((r) => typeof r !== "string" || !r.trim())
       )
-        throw new ConfigError(
-          `${file}: ${at}.repos must be a list of repo names`,
-        );
-      for (const r of e.repos as string[]) {
-        const prior = repoAt.get(r.trim());
-        if (prior && prior !== `${at}.repos`)
-          throw new ConfigError(
-            `${file}: repo ${r.trim()} is claimed by both ${prior} and ${at}.repos`,
-          );
-        repoAt.set(r.trim(), `${at}.repos`);
-      }
+        bad(`${at}.repos`, `${at}.repos must be a list of repo names`);
+      else
+        for (const r of e.repos as string[]) {
+          const prior = repoAt.get(r.trim());
+          if (prior && prior !== `${at}.repos`)
+            bad(
+              `${at}.repos`,
+              `repo ${r.trim()} is claimed by both ${prior} and ${at}.repos`,
+            );
+          else repoAt.set(r.trim(), `${at}.repos`);
+        }
     }
   }
   // A legacy org is the GitHub owner of its own name: a source elsewhere that
@@ -150,11 +167,13 @@ export function validateOrgSources(orgs: unknown, file: string): void {
     if (isSourcedOrg(raw as WorkOrgConfig)) continue;
     const prior = ownerAt.get(`github:${lower(id)}`);
     if (prior)
-      throw new ConfigError(
-        `${file}: github owner ${id} is claimed by both ${prior} and orgs.${id} ` +
+      bad(
+        `orgs.${id}`,
+        `github owner ${id} is claimed by both ${prior} and orgs.${id} ` +
           `(an org with no sources: is the GitHub owner of its own name)`,
       );
   }
+  if (issues.length) throw new ConfigError(issues);
 }
 
 /** `gh: owner/repo`'s owner, as spelled, or "" (the legacy orgOf). */

package/src/shared/org.ts

@@ -4,7 +4,7 @@
  *
  *   org:
  *     id: globex      # defaults to edge.org
- *     title: Globex   # defaults to the id
+ *     title: Globex   # defaults to the github_org's `orgs:` label, then the id
  */
 import * as fs from "fs";
 import * as path from "path";
@@ -31,12 +31,60 @@ export function resolveOrg(
   return { id, title: parsed?.org?.title?.trim() || id };
 }
 
+function readParsed(root: string): unknown {
+  return yaml.parse(
+    fs.readFileSync(path.join(root, product().configFile), "utf-8"),
+  );
+}
+
 export function readOrg(root: string = getDistRoot()): Org | undefined {
   try {
-    return resolveOrg(
-      yaml.parse(
-        fs.readFileSync(path.join(root, product().configFile), "utf-8"),
-      ),
+    return resolveOrg(readParsed(root) as Parameters<typeof resolveOrg>[0]);
+  } catch {
+    return undefined;
+  }
+}
+
+/** Where the shell's org label came from (0.3.0-dev.18, additive). */
+export type OrgTitleSource = "org.title" | "orgs" | "id";
+
+/** The org as the shell labels it: `title` plus where it came from. */
+export interface OrgView extends Org {
+  title_source: OrgTitleSource;
+}
+
+/**
+ * Pure: the org's display label for the top bar. `org.title` first, then
+ * the `orgs:` label of the GitHub org (`github_org`, the label the
+ * Environments page shows), then the id. A distribution with only
+ * `edge.org: <id>` no longer shows its bare id when it has a label.
+ */
+export function resolveOrgView(
+  parsed:
+    | {
+        org?: OrgConfig;
+        edge?: { org?: string };
+        github_org?: string;
+        orgs?: Record<string, { label?: string } | null | undefined>;
+      }
+    | null
+    | undefined,
+): OrgView | undefined {
+  const org = resolveOrg(parsed);
+  if (!org) return undefined;
+  if (parsed?.org?.title?.trim()) return { ...org, title_source: "org.title" };
+  const gh =
+    typeof parsed?.github_org === "string" ? parsed.github_org.trim() : "";
+  const label = gh ? parsed?.orgs?.[gh]?.label : undefined;
+  if (typeof label === "string" && label.trim())
+    return { ...org, title: label.trim(), title_source: "orgs" };
+  return { ...org, title_source: "id" };
+}
+
+export function readOrgView(root: string = getDistRoot()): OrgView | undefined {
+  try {
+    return resolveOrgView(
+      readParsed(root) as Parameters<typeof resolveOrgView>[0],
     );
   } catch {
     return undefined;