@monster-orange/den 0.0.0 → 0.2.0

package/src/scripts/setup-default-workspace.ts

@@ -0,0 +1,203 @@
+/**
+ * setup-default-workspace
+ *
+ * Builds the "default" workspace non-interactively: every standard system repo,
+ * all managed. No prompts, no cloning at setup time — den clones each
+ * managed repo on first use, and per-repo mode is a one-click change in the web
+ * UX afterwards for anything you actively develop.
+ *
+ * The repo set is the union of:
+ *   1. shop-web (the entry system)
+ *   2. the committed release fleet (config/den.yml `release.repos`) — the
+ *      authoritative list of standard system repos. A dependency-graph walk
+ *      alone misses islands: control-plane has no deps and nothing depends on
+ *      it, so no walk from shop-web can ever reach it.
+ *   3. a best-effort dependency walk from shop-web — catches deps that aren't
+ *      in the release fleet, when sibling checkouts exist to read manifests
+ *      from. On a bare machine this contributes nothing, and that's fine.
+ *   4. infra-stack — the shared local-infra provider. It only appears as a
+ *      dependency inside OTHER repos' manifests, so on a machine with no
+ *      checkouts neither the fleet nor the walk can discover it.
+ *
+ * Usage:
+ *   make setup                                    (called from Step 4)
+ *   npx tsx src/scripts/setup-default-workspace.ts
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { readManifest } from "../shared/manifest/read-manifest.js";
+import { depService } from "../shared/manifest/deps.js";
+import {
+  readWorkspacesFile,
+  writeWorkspacesFile,
+} from "../shared/environment-manager/workspaces.js";
+import { upsertCatalogEntry } from "../shared/environment-manager/catalog.js";
+import { getGitHubCoords } from "../shared/smoke/git-remote.js";
+import {
+  getReposRoot,
+  readDenConfig,
+  readReleaseConfig,
+  requireGithubOrg,
+} from "../shared/den-config.js";
+import type { WorkspaceServiceEntry } from "../shared/types/index.js";
+
+import { product } from "../shared/product.js";
+const WORKSPACE_KEY = "default";
+
+/** The repo the dependency walk starts from: `defaults.workspace.entry`. */
+function entryRepo(): string | undefined {
+  return readDenConfig().defaults?.workspace?.entry?.trim() || undefined;
+}
+
+/**
+ * Repos invisible to both the release fleet and a manifest walk on a fresh
+ * machine: the shared local-infra repo (`graph.infra.repo`), if any.
+ */
+function extraStandardRepos(): string[] {
+  const infra = readDenConfig().graph?.infra?.repo?.trim();
+  return infra ? [infra] : [];
+}
+
+/** Extract unique dep repo names from a manifest (strips subsystem, e.g. "shop/api" → "shop"). */
+function getDepsFromManifest(repoPath: string): string[] {
+  const manifest = readManifest(repoPath);
+  if (!manifest?.services) return [];
+  const deps = new Set<string>();
+  for (const svc of Object.values(manifest.services)) {
+    for (const rawDep of svc.depends_on ?? []) {
+      const dep = depService(rawDep);
+      deps.add(dep.includes("/") ? dep.split("/")[0] : dep);
+    }
+  }
+  return Array.from(deps);
+}
+
+/**
+ * BFS through the dependency graph, only following repos that exist locally.
+ * Returns all reachable dep repo names (excludes startRepoName itself),
+ * ordered by discovery depth. Best-effort by construction: a repo that isn't
+ * checked out truncates its branch of the walk, which is why the release
+ * fleet — not this walk — is the primary seed source.
+ */
+function collectAllDeps(startRepoName: string, reposRoot: string): string[] {
+  const visited = new Set<string>([startRepoName]);
+  const ordered: string[] = [];
+  const queue: string[] = [path.join(reposRoot, startRepoName)];
+
+  while (queue.length > 0) {
+    const repoPath = queue.shift()!;
+    if (!fs.existsSync(repoPath)) continue;
+
+    for (const depName of getDepsFromManifest(repoPath)) {
+      if (!visited.has(depName)) {
+        visited.add(depName);
+        ordered.push(depName);
+        queue.push(path.join(reposRoot, depName));
+      }
+    }
+  }
+
+  return ordered;
+}
+
+/** Union of seed sources, deduped, the entry repo first. Pure given its inputs. */
+export function computeSeedRepos(
+  fleetRepos: string[],
+  graphDeps: string[],
+  extras: string[] = [],
+  entry?: string,
+): string[] {
+  const seen = new Set<string>();
+  const ordered: string[] = [];
+  for (const name of [entry, ...fleetRepos, ...graphDeps, ...extras]) {
+    if (!name || seen.has(name)) continue;
+    seen.add(name);
+    ordered.push(name);
+  }
+  return ordered;
+}
+
+/** Resolve the full seed list from live config + a best-effort manifest walk. Read-only. */
+export function deriveSeedRepos(): string[] {
+  const reposRoot = getReposRoot();
+  const fleet = (readReleaseConfig().repos ?? [])
+    .filter((r) => r.enabled !== false)
+    .map((r) => r.name);
+  const entry = entryRepo();
+  return computeSeedRepos(
+    fleet,
+    entry ? collectAllDeps(entry, reposRoot) : [],
+    extraStandardRepos(),
+    entry,
+  );
+}
+
+/** Derive the GitHub slug from a local repo path, falling back to org/repoName. */
+function ghSlugFor(repoPath: string, repoName: string, org: string): string {
+  const coords = getGitHubCoords(repoPath);
+  return coords ? `${coords.owner}/${coords.repo}` : `${org}/${repoName}`;
+}
+
+async function main() {
+  console.log(`\n  ${product().cli} · Default Workspace Setup\n`);
+  console.log(
+    '  This builds the "default" workspace — every standard system repo,\n' +
+      `  all managed: ${product().cli} clones and keeps each one up to date for\n` +
+      "  you, no checkouts or decisions required. For anything you actively\n" +
+      "  develop, flip that repo to dev-managed in the web UX (Local Dev)\n" +
+      "  and point it at your own checkout.\n",
+  );
+
+  const reposRoot = getReposRoot();
+  const org = requireGithubOrg();
+  const seed = deriveSeedRepos();
+
+  const services: Record<string, WorkspaceServiceEntry> = {};
+  for (const repoName of seed) {
+    const localPath = path.join(reposRoot, repoName);
+    const exists = fs.existsSync(localPath);
+    const slug = exists
+      ? ghSlugFor(localPath, repoName, org)
+      : `${org}/${repoName}`;
+
+    services[repoName] = { mode: "managed", branch: "main" };
+    upsertCatalogEntry(repoName, { gh: slug });
+
+    // Every row gets a trailer — a bare row in a column of annotated rows
+    // reads as "skipped" even though the entry was written either way.
+    console.log(
+      `  ✓ ${repoName.padEnd(18)} →  managed (main)${
+        exists
+          ? `   local checkout at ${localPath} left untouched`
+          : `   no local checkout — ${product().cli} clones it on first use`
+      }`,
+    );
+  }
+
+  const wsFile = readWorkspacesFile();
+  wsFile.workspaces[WORKSPACE_KEY] = { services };
+  writeWorkspacesFile(wsFile);
+
+  console.log(
+    `\n  ✓ Default workspace configured with ${seed.length} service(s), all managed.`,
+  );
+  console.log(
+    "  Change any repo to dev-managed in the web UX: make web → Local Dev.",
+  );
+  console.log(`  Run 'make ${product().cli}-up' to start your services.\n`);
+}
+
+// Importable without side effects (tests import computeSeedRepos/deriveSeedRepos);
+// main runs only when executed directly. argv-based rather than import.meta:
+// jest's CJS transform rejects import.meta, and this file must be importable
+// under test.
+const isDirectRun = Boolean(
+  process.argv[1] && /setup-default-workspace\.(ts|js)$/.test(process.argv[1]),
+);
+if (isDirectRun) {
+  main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}

package/src/shared/agent-actor.ts

@@ -0,0 +1,77 @@
+/**
+ * Who asked: the headers the MCP server (`<cli> mcp`) sends with every web
+ * API call, so the server can record an action as an agent's. The client
+ * name and version are what the MCP client reported about itself at
+ * initialize: a label for the audit trail, never used for authorization.
+ */
+import type { IncomingHttpHeaders } from "http";
+
+export const AUDIT_HEADERS = {
+  actor: "x-den-actor",
+  client: "x-den-mcp-client",
+  clientVersion: "x-den-mcp-client-version",
+  pid: "x-den-mcp-pid",
+  session: "x-den-mcp-session",
+} as const;
+
+export interface AgentInfo {
+  /** The MCP client's self-reported name (clientInfo.name). */
+  client: string;
+  /** The MCP client's self-reported version (clientInfo.version). */
+  clientVersion: string;
+  /** The MCP server process's pid. */
+  mcpPid: number | null;
+  /** The MCP server's session id (one per `<cli> mcp` process). */
+  session: string;
+}
+
+export interface AgentActor extends AgentInfo {
+  kind: "agent";
+}
+
+/** null: a person in the web UI (no agent headers). */
+export type Actor = AgentActor | null;
+
+/** Printable, single-line, bounded: these values land in log lines. */
+function clean(v: unknown, max = 64): string {
+  const s = Array.isArray(v) ? v[0] : v;
+  return String(s ?? "")
+    .replace(/[^\x20-\x7e]/g, "")
+    .trim()
+    .slice(0, max);
+}
+
+/** The headers the MCP client sends (see AUDIT_HEADERS). */
+export function agentAuditHeaders(info: AgentInfo): Record<string, string> {
+  return {
+    [AUDIT_HEADERS.actor]: "agent",
+    [AUDIT_HEADERS.client]: clean(info.client) || "unknown",
+    [AUDIT_HEADERS.clientVersion]: clean(info.clientVersion) || "unknown",
+    [AUDIT_HEADERS.pid]: info.mcpPid === null ? "" : String(info.mcpPid),
+    [AUDIT_HEADERS.session]: clean(info.session).replace(/[^A-Za-z0-9-]/g, ""),
+  };
+}
+
+/** The actor an incoming request names, or null for a person in the UI. */
+export function actorFromHeaders(
+  headers: IncomingHttpHeaders | Record<string, string | undefined>,
+): Actor {
+  const h = headers as Record<string, string | string[] | undefined>;
+  if (clean(h[AUDIT_HEADERS.actor]) !== "agent") return null;
+  const pid = clean(h[AUDIT_HEADERS.pid], 10);
+  return {
+    kind: "agent",
+    client: clean(h[AUDIT_HEADERS.client]) || "unknown",
+    clientVersion: clean(h[AUDIT_HEADERS.clientVersion], 32) || "unknown",
+    mcpPid: /^\d+$/.test(pid) ? Number(pid) : null,
+    session: clean(h[AUDIT_HEADERS.session]).replace(/[^A-Za-z0-9-]/g, ""),
+  };
+}
+
+/** "agent <client> <version> (mcp pid <pid>, session <id>)". */
+export function actorLabel(actor: AgentActor): string {
+  return (
+    `agent ${actor.client} ${actor.clientVersion} ` +
+    `(mcp pid ${actor.mcpPid ?? "?"}, session ${actor.session || "?"})`
+  );
+}

package/src/shared/applications.ts

@@ -0,0 +1,138 @@
+/**
+ * Applications: the boundary between an org and its repos.
+ *
+ *   Org > Application > Repo > Services
+ *
+ *  - declared: `applications:` in config/den.yml, plus any repo whose own
+ *    `.den.yml` sets `application:` (the repo's own setting wins);
+ *  - repo:     every other repo is its own application, named after the repo
+ *    (a mono-repo: Application == Repo).
+ *
+ * An application's `repos` are the ones with a runtime (services). Modules and
+ * libraries are placed the same way but listed as `contributors`: code that
+ * ships inside another repo's runtime, with no status of its own.
+ *
+ * Pure: callers pass the config, manifest applications and kinds.
+ */
+import type { ApplicationConfig } from "./den-config.js";
+import type { RepoKind } from "./types/index.js";
+
+export interface ApplicationContributor {
+  repo: string;
+  kind: Exclude<RepoKind, "service">;
+  /** Repos whose runtime this code ships in. */
+  contributesTo: string[];
+}
+
+export interface Application {
+  name: string;
+  title: string;
+  description?: string;
+  /** Who builds it. */
+  owner?: string;
+  /** declared in config or a manifest, or a repo standing as its own application. */
+  source: "declared" | "repo";
+  /** Repos with a runtime: these get status, up and down. */
+  repos: string[];
+  /** Modules and libraries in the application: no runtime of their own. */
+  contributors: ApplicationContributor[];
+}
+
+export function resolveApplications(opts: {
+  /** Repos to place (normally the workspace's). */
+  repos: string[];
+  config?: Record<string, ApplicationConfig>;
+  /** repo → application named in that repo's manifest. */
+  manifestApplications?: Record<string, string>;
+  /** repo → kind; repos not listed are services. */
+  kinds?: Record<string, RepoKind>;
+  /** repo → repos it contributes to (for modules and libraries). */
+  contributesTo?: Record<string, string[]>;
+}): Application[] {
+  const inScope = new Set(opts.repos);
+  const placed = new Set<string>();
+  const apps = new Map<string, Application>();
+  const declare = (name: string): Application => {
+    let a = apps.get(name);
+    if (!a) {
+      const c = opts.config?.[name];
+      a = {
+        name,
+        title: c?.title ?? name,
+        ...(c?.description ? { description: c.description } : {}),
+        ...(c?.owner ? { owner: c.owner } : {}),
+        source: "declared",
+        repos: [],
+        contributors: [],
+      };
+      apps.set(name, a);
+    }
+    return a;
+  };
+  const place = (a: Application, repo: string) => {
+    if (!inScope.has(repo) || placed.has(repo)) return;
+    placed.add(repo);
+    a.repos.push(repo);
+  };
+
+  // Config order first; declared applications exist even when none of their
+  // repos are in scope.
+  for (const name of Object.keys(opts.config ?? {})) declare(name);
+  // A repo's own manifest wins over the team list.
+  for (const [repo, name] of Object.entries(opts.manifestApplications ?? {}))
+    place(declare(name), repo);
+  for (const [name, c] of Object.entries(opts.config ?? {}))
+    for (const repo of c.repos ?? []) place(declare(name), repo);
+
+  // Every other repo is its own application. A declared application that
+  // already carries the repo's name takes it in instead.
+  const standalone: Application[] = [];
+  for (const repo of [...opts.repos].sort()) {
+    if (placed.has(repo)) continue;
+    const named = apps.get(repo);
+    if (named) {
+      place(named, repo);
+      continue;
+    }
+    placed.add(repo);
+    standalone.push({
+      name: repo,
+      title: repo,
+      source: "repo",
+      repos: [repo],
+      contributors: [],
+    });
+  }
+
+  return [...apps.values(), ...standalone].map((a) =>
+    splitByKind(a, opts.kinds, opts.contributesTo),
+  );
+}
+
+function splitByKind(
+  a: Application,
+  kinds: Record<string, RepoKind> = {},
+  contributesTo: Record<string, string[]> = {},
+): Application {
+  const repos: string[] = [];
+  const contributors: ApplicationContributor[] = [];
+  for (const repo of [...a.repos].sort()) {
+    const kind = kinds[repo] ?? "service";
+    if (kind === "service") repos.push(repo);
+    else
+      contributors.push({
+        repo,
+        kind,
+        contributesTo: contributesTo[repo] ?? [],
+      });
+  }
+  return { ...a, repos, contributors };
+}
+
+/** The application named `name`. */
+export function findApplication(
+  apps: Application[],
+  name: string,
+): Application | undefined {
+  return apps.find((a) => a.name === name);
+}