@monster-orange/den 0.2.6 → 0.2.7

package/src/shared/environment-manager/service-runner.ts

@@ -69,7 +69,7 @@ import type {
   WorkspaceConfig,
 } from "../types/index.js";
 import type { ChildProcess } from "child_process";
-import { getStateDir } from "../paths.js";
+import { getDistRoot, getStateDir } from "../paths.js";
 
 import { product } from "../product.js";
 // Re-export so existing callers don't need to change their import path.
@@ -101,6 +101,33 @@ export interface DaemonRecord {
    * command. Optional for backward-compat with records written before this.
    */
   containers?: string[];
+  /**
+   * The distribution root (realpath) whose server or CLI registered this
+   * daemon. Every root of a product shares one daemons file, so startup
+   * pruning skips records stamped by another root. Missing on records
+   * written before 0.2.7.
+   */
+  root?: string;
+}
+
+/** This process's distribution root, as stamped on its daemon records. */
+function daemonRoot(): string | null {
+  try {
+    return fs.realpathSync(getDistRoot());
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Whose a daemon record is: this root's, another root's (all roots of a
+ * product share one daemons file), or unstamped (written before 0.2.7).
+ */
+export function daemonRootOf(
+  d: Pick<DaemonRecord, "root">,
+): "here" | "other" | "unstamped" {
+  if (!d.root) return "unstamped";
+  return d.root === daemonRoot() ? "here" : "other";
 }
 
 export type ServiceConflictReason = "identity_mismatch" | "orphan_containers";
@@ -263,8 +290,10 @@ export function registerDaemon(record: DaemonRecord): void {
     ? (existing?.workspaces ?? [])
     : [];
   const workspaces = [...new Set([...inherited, ...(record.workspaces ?? [])])];
+  const root = daemonRoot() ?? record.root;
   _daemonRegistry.set(record.address, {
     ...record,
+    ...(root ? { root } : {}),
     workspaces,
     branch: normalizeBranch(record.branch),
   });
@@ -296,9 +325,17 @@ export function updateDaemonContainers(
   saveDaemonsFile(getDaemonsFile());
 }
 
+/**
+ * This root's daemons (and unstamped legacy ones). Every root of a product
+ * shares one daemons file; another root's records stay in it untouched but
+ * are not listed, so this server never shows, stops, releases or sweeps
+ * them. Lookups by address (findDaemonByAddress) still see every record.
+ */
 export function listDaemons(): DaemonRecord[] {
   loadDaemonsFromFile();
-  return Array.from(_daemonRegistry.values());
+  return Array.from(_daemonRegistry.values()).filter(
+    (d) => daemonRootOf(d) !== "other",
+  );
 }
 
 export function findDaemonByAddress(address: string): DaemonRecord | undefined {
@@ -646,8 +683,11 @@ export function isDaemonVerifiablyDead(
  * clear stale entries from previous sessions. Otherwise they reopen as tabs in
  * the web UI and clutter the shutdown prompt.
  *
- * A daemon is dropped when:
- *  - its address no longer resolves to a workspace/catalog service, OR
+ * A daemon stamped by another root (all roots of a product share the file)
+ * is never touched. Otherwise it is dropped when:
+ *  - it was stamped by this root and its address no longer resolves to a
+ *    workspace/catalog service (an unstamped legacy record might belong to
+ *    another root, so this alone never drops one), OR
  *  - it is opctl-based (has captured containers or a discoverable dev-op) and
  *    NONE of its candidate containers are currently running.
  *
@@ -687,7 +727,13 @@ function pruneAgainst(
   const pruned: string[] = [];
   for (const d of daemons) {
     try {
-      if (!canResolveDaemonAddress(d)) {
+      const root = daemonRootOf(d);
+      // Another root's daemon: its services resolve in its workspaces, not
+      // ours, and its liveness is its own server's call.
+      if (root === "other") continue;
+      // An unresolvable address is only proof of staleness for a record
+      // this root wrote; an unstamped one may belong to another root.
+      if (root === "here" && !canResolveDaemonAddress(d)) {
         unregisterDaemon(d.address);
         pruned.push(d.address);
         continue;

package/src/shared/environment-manager/workspace-manager.ts

@@ -91,7 +91,8 @@ function gitCapture(cmd: string, cwd?: string): string {
   }).trim();
 }
 
-function ghCloneUrl(ghSlug: string): string {
+/** The HTTPS URL a managed clone of `ghSlug` is made from. */
+export function ghCloneUrl(ghSlug: string): string {
   return `https://github.com/${ghSlug}.git`;
 }
 

package/src/shared/environment-manager/workspace-org.ts

@@ -0,0 +1,264 @@
+/**
+ * Which work org a workspace belongs to (ORG-1a, ORG-SPEC §2).
+ *
+ * An org is a key of `orgs:` or a GitHub owner. ORG-1a keeps today's model:
+ * an org with no `sources` is the GitHub owner of the same name, and
+ * `github_org` is the default org. A workspace's org resolves through this
+ * chain, first match wins:
+ *
+ *   1. `org:` on the workspace in workspaces.yml (per machine)
+ *   2. `org:` on the same-named blueprint workspace (`defaults.workspaces`)
+ *   3. the single non-empty catalog owner of its repos (case-insensitive)
+ *   4. `github_org`
+ *
+ * Computed on read and never written back to workspaces.yml, so an inferred
+ * org never looks like an explicit one. Every rule broken here is a warning,
+ * never an error (C1): an old config resolves as before, to `github_org`.
+ */
+import {
+  readDenConfig,
+  readWorkspaceBlueprints,
+  requireGithubOrg,
+  type DenConfig,
+  type ResolvedWorkspaceBlueprint,
+} from "../den-config.js";
+import { readCatalog } from "./catalog.js";
+import { parseAddress, readWorkspacesFile } from "./workspaces.js";
+import { orgOf } from "../manifest/service-links.js";
+import { cachedRead } from "../read-cache.js";
+import type {
+  ServiceCatalog,
+  WorkspaceConfig,
+  WorkspacesFile,
+} from "../types/index.js";
+
+/** Which step of the chain gave the org. */
+export type OrgSource = "workspace" | "blueprint" | "catalog" | "default";
+
+export interface WorkspaceOrg {
+  workspace: string;
+  /** The resolved org id (the `orgs:` key's spelling when one matches), or null. */
+  org: string | null;
+  source: OrgSource | null;
+  /** Each broken org rule, as a sentence (C1: warnings, never errors). */
+  warnings: string[];
+}
+
+export interface OrgContext {
+  config: DenConfig;
+  catalog: ServiceCatalog;
+  file: WorkspacesFile;
+  blueprints: ResolvedWorkspaceBlueprint[];
+}
+
+const lower = (s: string): string => s.toLowerCase();
+
+/** The current config, catalog, workspaces.yml and blueprint. */
+export function readOrgContext(): OrgContext {
+  const config = readDenConfig();
+  let blueprints: ResolvedWorkspaceBlueprint[] = [];
+  try {
+    blueprints = readWorkspaceBlueprints(config).workspaces;
+  } catch {
+    // A malformed blueprint is reported where seeding reads it; it must not
+    // turn an org listing into a failure (C1).
+  }
+  return {
+    config,
+    catalog: readCatalog(),
+    file: readWorkspacesFile(),
+    blueprints,
+  };
+}
+
+/** `id` spelled as its `orgs:` key when one matches case-insensitively. */
+export function canonicalOrg(id: string, config: DenConfig): string {
+  const key = Object.keys(config.orgs ?? {}).find(
+    (k) => lower(k) === lower(id),
+  );
+  return key ?? id;
+}
+
+/** The default org: `github_org`, or null when unset. */
+export function defaultOrg(config: DenConfig): string | null {
+  const d = config.github_org?.trim();
+  return d ? canonicalOrg(d, config) : null;
+}
+
+/** The repos a workspace holds; a workspace not set up yet holds its blueprint's. */
+function workspaceRepos(
+  ws: WorkspaceConfig | undefined,
+  bp: ResolvedWorkspaceBlueprint | undefined,
+  catalog: ServiceCatalog,
+): string[] {
+  const held = [
+    ...Object.keys(ws?.services ?? {}).map(
+      (k) => parseAddress(k, catalog).repoName,
+    ),
+    ...Object.keys(ws?.repos ?? {}),
+  ];
+  return [...new Set(held.length > 0 ? held : (bp?.repos ?? []))];
+}
+
+/** Owners Den knows of: `orgs:` keys, catalog owners and `github_org`. */
+function knownOrgs(ctx: OrgContext): Set<string> {
+  const ids = new Set(Object.keys(ctx.config.orgs ?? {}).map(lower));
+  for (const repo of Object.keys(ctx.catalog)) {
+    const o = orgOf(repo, ctx.catalog);
+    if (o) ids.add(lower(o));
+  }
+  const d = ctx.config.github_org?.trim();
+  if (d) ids.add(lower(d));
+  return ids;
+}
+
+/** Resolve one workspace's org through the chain. */
+export function resolveWorkspaceOrg(
+  name: string,
+  ctx: OrgContext,
+): WorkspaceOrg {
+  const warnings: string[] = [];
+  const ws = ctx.file.workspaces[name];
+  const bp = ctx.blueprints.find((b) => b.name === name);
+  const rawWsOrg = ws?.org as unknown;
+  const wsOrg =
+    typeof rawWsOrg === "string" && rawWsOrg.trim()
+      ? rawWsOrg.trim()
+      : undefined;
+  if (rawWsOrg !== undefined && rawWsOrg !== null && !wsOrg)
+    warnings.push(
+      `workspace ${name}: org in workspaces.yml is not an org id; ignored`,
+    );
+
+  const repos = workspaceRepos(ws, bp, ctx.catalog);
+  const owners = new Map<string, string>(); // lowercased → first spelling
+  for (const repo of repos) {
+    const o = orgOf(repo, ctx.catalog);
+    if (o && !owners.has(lower(o))) owners.set(lower(o), o);
+  }
+
+  let org: string | null = null;
+  let source: OrgSource | null = null;
+  if (wsOrg) {
+    org = wsOrg;
+    source = "workspace";
+    if (bp?.org && lower(bp.org) !== lower(wsOrg))
+      warnings.push(
+        `workspace ${name}: org ${wsOrg} in workspaces.yml overrides the blueprint's org ${bp.org}`,
+      );
+  } else if (bp?.org) {
+    org = bp.org;
+    source = "blueprint";
+  } else if (owners.size === 1) {
+    org = [...owners.values()][0];
+    source = "catalog";
+  } else {
+    org = ctx.config.github_org?.trim() || null;
+    source = org ? "default" : null;
+    if (owners.size > 1)
+      warnings.push(
+        `workspace ${name}: its repos belong to several owners (${[...owners.values()].join(", ")}); ` +
+          `using ${org ?? "no org"}. Set org: on the workspace to choose one`,
+      );
+  }
+  if (org) org = canonicalOrg(org, ctx.config);
+
+  if (
+    org &&
+    (source === "workspace" || source === "blueprint") &&
+    !knownOrgs(ctx).has(lower(org))
+  )
+    warnings.push(
+      `workspace ${name}: org ${org} is not in orgs:, the catalog or github_org`,
+    );
+
+  // A repo in another owner than its workspace's org. A mixed workspace with
+  // no org of its own already said so above.
+  if (
+    org &&
+    (owners.size <= 1 || source === "workspace" || source === "blueprint")
+  )
+    for (const repo of repos) {
+      const o = orgOf(repo, ctx.catalog);
+      if (o && lower(o) !== lower(org))
+        warnings.push(
+          `workspace ${name}: repo ${repo} belongs to ${o}, not the workspace's org ${org}`,
+        );
+    }
+
+  return { workspace: name, org, source, warnings };
+}
+
+/** Every workspace on this machine, then blueprint workspaces not set up yet. */
+function workspaceNames(ctx: OrgContext): string[] {
+  return [
+    ...new Set([
+      ...Object.keys(ctx.file.workspaces),
+      ...ctx.blueprints.map((b) => b.name),
+    ]),
+  ];
+}
+
+/** Every workspace's resolved org (cached for the web server's read TTL). */
+export function resolveAllWorkspaceOrgs(ctx?: OrgContext): WorkspaceOrg[] {
+  const compute = (c: OrgContext) =>
+    workspaceNames(c).map((n) => resolveWorkspaceOrg(n, c));
+  if (ctx) return compute(ctx);
+  return cachedRead("workspace-orgs", () => compute(readOrgContext()));
+}
+
+/**
+ * The GitHub owner to clone and register a workspace's repos under: its
+ * resolved org. With none at all (no org anywhere and no `github_org`) this
+ * throws exactly as requireGithubOrg does, so an old config fails as before.
+ */
+export function githubOrgFor(workspace: string, ctx?: OrgContext): string {
+  const hit = ctx
+    ? resolveWorkspaceOrg(workspace, ctx)
+    : (resolveAllWorkspaceOrgs().find((w) => w.workspace === workspace) ??
+      resolveWorkspaceOrg(workspace, readOrgContext()));
+  if (hit.org) return hit.org;
+  return requireGithubOrg(ctx?.config);
+}
+
+export interface OrgEntry {
+  id: string;
+  label: string;
+  color?: string;
+}
+
+/**
+ * The org listing with `default` and `workspaces` added to each entry and
+ * nothing else changed (C3): same entries, same order, same fields. Only
+ * workspaces on this machine (workspaces.yml) are listed.
+ */
+export function withOrgMembership<T extends OrgEntry>(
+  orgs: T[],
+  resolved: WorkspaceOrg[],
+  file: WorkspacesFile,
+  config: DenConfig,
+): Array<T & { default: boolean; workspaces: string[] }> {
+  // The listing can hold one owner twice in different case (catalog owners
+  // are listed as spelled); an org lands on the entry spelled exactly like
+  // it, else the first that matches case-insensitively.
+  const entryFor = (id: string): number => {
+    const exact = orgs.findIndex((o) => o.id === id);
+    return exact !== -1
+      ? exact
+      : orgs.findIndex((o) => lower(o.id) === lower(id));
+  };
+  const d = defaultOrg(config);
+  const defaultAt = d === null ? -1 : entryFor(d);
+  const members = orgs.map((): string[] => []);
+  const local = new Set(Object.keys(file.workspaces));
+  for (const w of resolved) {
+    if (!w.org || !local.has(w.workspace)) continue;
+    const at = entryFor(w.org);
+    if (at !== -1) members[at].push(w.workspace);
+  }
+  return orgs.map((o, i) => ({
+    ...o,
+    default: i === defaultAt,
+    workspaces: members[i],
+  }));
+}

package/src/shared/types/index.ts

@@ -686,6 +686,13 @@ export interface WorkspaceConfig {
    * newly JOIN the blueprint are added.
    */
   seeded_repos?: string[];
+  /**
+   * The org this workspace belongs to (ORG-1a), set per machine. Wins over
+   * the blueprint's `org:`; when neither is set the org is inferred from the
+   * repos' catalog owners, then `github_org`. Never written by Den: the
+   * resolved org is computed on read (see workspace-org.ts).
+   */
+  org?: string;
 }
 
 export interface WorkspacesFile {

package/src/ui/cli/clone-plan.ts

@@ -0,0 +1,243 @@
+/**
+ * `<cli> setup --plan` and the clone half of `<cli> up --plan` (ORG-1a):
+ * each repo's resolved org and the URL it would be cloned from. Read-only:
+ * nothing is cloned, seeded or written (the catalog included).
+ *
+ * On a fresh machine (no workspace set up yet, a blueprint in the config)
+ * the plan is what `<cli> workspace seed` and then setup would do, for every
+ * blueprint workspace. Otherwise it is the focused workspace's repos, the
+ * ones setup works on.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { readCatalog } from "../../shared/environment-manager/catalog.js";
+import {
+  blueprintWorkspaces,
+  catalogFill,
+  isFreshWorkspaceSetup,
+  isMultiBlueprint,
+} from "../../shared/environment-manager/default-workspace.js";
+import {
+  DEN_SERVICES_DIR,
+  getActiveWorkspace,
+  parseAddress,
+} from "../../shared/environment-manager/workspaces.js";
+import { ghCloneUrl } from "../../shared/environment-manager/workspace-manager.js";
+import {
+  githubOrgFor,
+  readOrgContext,
+  resolveWorkspaceOrg,
+  type OrgContext,
+  type OrgSource,
+} from "../../shared/environment-manager/workspace-org.js";
+import { orgOf } from "../../shared/manifest/service-links.js";
+import type { ServiceCatalog } from "../../shared/types/index.js";
+
+export type ClonePlanState =
+  | "cloned"
+  | "would-clone"
+  | "not-in-catalog"
+  | "checkout"
+  | "no-org";
+
+export interface ClonePlanRow {
+  repo: string;
+  mode: "managed" | "dev-managed";
+  branch: string;
+  /** The GitHub owner the repo clones from (its slug's owner), or null. */
+  owner: string | null;
+  url: string | null;
+  state: ClonePlanState;
+  /** A dev-managed checkout's path, or a managed clone's directory. */
+  path?: string;
+}
+
+export interface ClonePlanWorkspace {
+  name: string;
+  org: string | null;
+  source: OrgSource | null;
+  warnings: string[];
+  rows: ClonePlanRow[];
+}
+
+export interface ClonePlan {
+  /** True when planned from the blueprint (nothing seeded yet). */
+  fromBlueprint: boolean;
+  workspaces: ClonePlanWorkspace[];
+}
+
+const ownerOf = (slug: string): string => slug.slice(0, slug.indexOf("/"));
+
+function cloneDir(repo: string, branch: string): string {
+  return path.join(DEN_SERVICES_DIR, repo, branch);
+}
+
+/** The slug setup and up would clone `repo` from, or null without an org. */
+function slugFor(
+  repo: string,
+  workspace: string,
+  catalog: ServiceCatalog,
+  ctx: OrgContext,
+): string | null {
+  const gh = catalog[repo]?.gh?.trim();
+  if (gh) return gh;
+  try {
+    return `${githubOrgFor(workspace, ctx)}/${repo}`;
+  } catch {
+    return null;
+  }
+}
+
+function managedRow(
+  repo: string,
+  branch: string,
+  slug: string | null,
+  inCatalog: boolean,
+): ClonePlanRow {
+  const dir = cloneDir(repo, branch);
+  const cloned = fs.existsSync(dir);
+  return {
+    repo,
+    mode: "managed",
+    branch,
+    owner: slug ? ownerOf(slug) : null,
+    url: slug ? ghCloneUrl(slug) : null,
+    state: cloned
+      ? "cloned"
+      : !slug
+        ? "no-org"
+        : inCatalog
+          ? "would-clone"
+          : "not-in-catalog",
+    path: dir,
+  };
+}
+
+/** The plan for one workspace on this machine, limited to `repos` when given. */
+export function workspaceClonePlan(
+  name: string,
+  repos?: readonly string[],
+  ctx: OrgContext = readOrgContext(),
+): ClonePlanWorkspace {
+  const resolved = resolveWorkspaceOrg(name, ctx);
+  const ws = ctx.file.workspaces[name];
+  const want = repos ? new Set(repos) : null;
+  const rows: ClonePlanRow[] = [];
+  const seen = new Set<string>();
+  for (const [address, entry] of Object.entries(ws?.services ?? {})) {
+    const { repoName } = parseAddress(address, ctx.catalog);
+    if (seen.has(repoName)) continue;
+    if (want && !want.has(repoName) && !want.has(address)) continue;
+    seen.add(repoName);
+    const branch = entry.branch ?? "main";
+    if (entry.mode === "dev-managed") {
+      const owner = orgOf(repoName, ctx.catalog);
+      rows.push({
+        repo: repoName,
+        mode: "dev-managed",
+        branch,
+        owner: owner || null,
+        url: null,
+        state: "checkout",
+        ...(entry.path ? { path: entry.path } : {}),
+      });
+      continue;
+    }
+    rows.push(
+      managedRow(
+        repoName,
+        branch,
+        slugFor(repoName, name, ctx.catalog, ctx),
+        Boolean(ctx.catalog[repoName]),
+      ),
+    );
+  }
+  return { ...resolved, name, rows };
+}
+
+/** What `<cli> workspace seed` and then setup would clone, per blueprint workspace. */
+function blueprintClonePlan(ctx: OrgContext): ClonePlanWorkspace[] {
+  const multi = isMultiBlueprint();
+  const bps = blueprintWorkspaces().map((b) => ({
+    ...b,
+    name: multi ? b.name : "default",
+  }));
+  let fill = new Map<string, string>();
+  try {
+    fill = catalogFill(bps, ctx.catalog, ctx);
+  } catch {
+    // No org for some repo: those rows say so below.
+  }
+  return bps.map((bp) => ({
+    ...resolveWorkspaceOrg(bp.name, ctx),
+    name: bp.name,
+    rows: bp.repos.map((repo) =>
+      managedRow(
+        repo,
+        bp.branch,
+        ctx.catalog[repo]?.gh?.trim() || fill.get(repo) || null,
+        true, // seeding writes every blueprint repo into the catalog
+      ),
+    ),
+  }));
+}
+
+/** `<cli> setup --plan`: the plan for `names` (every repo when empty). */
+export function buildSetupPlan(names: readonly string[] = []): ClonePlan {
+  const ctx = readOrgContext();
+  if (isFreshWorkspaceSetup(ctx.file) && blueprintWorkspaces().length > 0)
+    return { fromBlueprint: true, workspaces: blueprintClonePlan(ctx) };
+  const ws = getActiveWorkspace();
+  if (!ws) return { fromBlueprint: false, workspaces: [] };
+  return {
+    fromBlueprint: false,
+    workspaces: [
+      workspaceClonePlan(ws.name, names.length ? names : undefined, ctx),
+    ],
+  };
+}
+
+const STATE_TEXT: Record<ClonePlanState, string> = {
+  cloned: "cloned",
+  "would-clone": "would clone",
+  "not-in-catalog": "not in the catalog: setup skips it, up clones it",
+  checkout: "your checkout (setup skips it without --force)",
+  "no-org": "no org: set github_org, or org: on the workspace",
+};
+
+/** The plan as plain lines (the caller colours and prints them). */
+export function renderClonePlan(
+  plan: ClonePlan,
+  cli: string,
+  catalog: ServiceCatalog = readCatalog(),
+): string[] {
+  const out: string[] = [];
+  if (plan.fromBlueprint)
+    out.push(
+      `From the blueprint: nothing is set up yet. \`${cli} workspace seed\` creates these workspaces.`,
+      "",
+    );
+  if (plan.workspaces.length === 0) out.push("No workspace to plan.");
+  for (const ws of plan.workspaces) {
+    out.push(
+      `Workspace ${ws.name}  org: ${ws.org ?? "(none)"}${ws.source ? ` (${ws.source})` : ""}`,
+    );
+    if (ws.rows.length === 0) out.push("  (no repos)");
+    for (const r of ws.rows) {
+      const where =
+        r.state === "cloned" || r.state === "checkout"
+          ? r.path
+            ? `  ${r.path}`
+            : ""
+          : "";
+      const owner = r.owner ?? orgOf(r.repo, catalog) ?? "";
+      out.push(
+        `  ${r.repo}  ${r.mode} ${r.branch}  org: ${owner || "(unknown)"}` +
+          `${r.url ? `  ${r.url}` : ""}  ${STATE_TEXT[r.state]}${where}`,
+      );
+    }
+    for (const w of ws.warnings) out.push(`  ⚠ ${w}`);
+  }
+  out.push("", "Plan only: nothing was cloned, seeded or written.");
+  return out;
+}

package/src/ui/cli/flag-parser.ts

@@ -180,7 +180,7 @@ const COMMAND_FLAGS: Record<string, readonly string[]> = {
   ],
   restart: ["-A", "--app", "-n", "--dry-run"],
   logs: [],
-  setup: ["-f", "--force"],
+  setup: ["-f", "--force", "--plan"],
   sync: [],
 };