@monster-orange/den 0.0.0 → 0.2.0

package/src/shared/environment-manager/load-applications.ts

@@ -0,0 +1,108 @@
+/** Applications for a workspace, from config and repo manifests. */
+import { readDenConfig } from "../den-config.js";
+import { resolveApplications, type Application } from "../applications.js";
+import { readManifest } from "../manifest/read-manifest.js";
+import { contributesTo, repoKind } from "../repo-kind.js";
+import type { RepoKind } from "../types/index.js";
+import { deriveGraph } from "./derivation/derive-graph.js";
+import type { DerivedGraph } from "./derivation/types.js";
+import { getWorkspaceServices } from "./service-runner.js";
+import { readOrg, type Org } from "../org.js";
+import {
+  rollupPlacement,
+  servicePlacement,
+  type Placement,
+  type RollupPlacement,
+} from "../manifest/placement.js";
+
+export function loadApplications(workspace?: string): Application[] {
+  const services = getWorkspaceServices(workspace);
+  const repos = [...new Set(services.map((s) => s.repoName))];
+  const manifestApplications: Record<string, string> = {};
+  const kinds: Record<string, RepoKind> = {};
+  const contributes: Record<string, string[]> = {};
+  // The graph only tells a module/library where it ships; derive it lazily.
+  let graph: DerivedGraph | undefined;
+  for (const s of services) {
+    const a = readManifest(s.repoPath)?.application;
+    if (a) manifestApplications[s.repoName] = a;
+    const kind = repoKind(s.repoPath);
+    if (kind !== "service") {
+      graph ??= deriveGraph({
+        scope: "all",
+        ...(workspace ? { workspace } : {}),
+      });
+      kinds[s.repoName] = kind;
+      contributes[s.repoName] = contributesTo(s.repoName, s.repoPath, graph);
+    }
+  }
+  return resolveApplications({
+    repos,
+    config: readDenConfig().applications,
+    manifestApplications,
+    kinds,
+    contributesTo: contributes,
+  });
+}
+
+/** An application with what the workspace runs of it. */
+export interface ApplicationView extends Application {
+  /** repo → its service addresses in the workspace ("repo" or "repo/sub"). */
+  services: Record<string, string[]>;
+  /** Every service address in the application, for app-wide up/down. */
+  addresses: string[];
+  /** Repos the team config lists for it that are not in this workspace. */
+  absent: string[];
+  /** address → where that service runs locally, and where a remote one is. */
+  placements: Record<string, Placement>;
+  /** local | remote | hybrid | none, over its services (R13). */
+  placement: RollupPlacement;
+  /** "shop-frontend local · shop-core remote (dev)" */
+  summary: string;
+}
+
+/** Org > Application > Repo > Services for a workspace (CLI `apps`, web UI). */
+export function loadApplicationTree(workspace?: string): {
+  org?: Org;
+  applications: ApplicationView[];
+} {
+  const byRepo = new Map<string, string[]>();
+  const placed = new Map<
+    string,
+    Placement & { repo: string; service: string }
+  >();
+  for (const s of getWorkspaceServices(workspace)) {
+    if (!byRepo.has(s.repoName)) byRepo.set(s.repoName, []);
+    byRepo.get(s.repoName)!.push(s.address);
+    placed.set(s.address, {
+      repo: s.repoName,
+      service: s.subsystem,
+      ...servicePlacement(readManifest(s.repoPath), s.subsystem, "local"),
+    });
+  }
+  const config = readDenConfig().applications ?? {};
+  const org = readOrg();
+  return {
+    ...(org ? { org } : {}),
+    applications: loadApplications(workspace).map((a) => {
+      const services = Object.fromEntries(
+        a.repos.map((r) => [r, byRepo.get(r) ?? []]),
+      );
+      const addresses = Object.values(services).flat();
+      const rows = addresses.flatMap((addr) => placed.get(addr) ?? []);
+      return {
+        ...a,
+        services,
+        addresses,
+        absent: (config[a.name]?.repos ?? []).filter((r) => !byRepo.has(r)),
+        placements: Object.fromEntries(
+          addresses.flatMap((addr) => {
+            const p = placed.get(addr);
+            return p ? [[addr, { runs: p.runs, target: p.target }]] : [];
+          }),
+        ),
+        ...rollupPlacement(rows),
+      };
+    }),
+  };
+}

package/src/shared/environment-manager/log-tail.ts

@@ -0,0 +1,213 @@
+/**
+ * Live log tailing for a local service — the CLI-side counterpart of the web
+ * /api/service/taillog SSE endpoint. Source resolution, in order:
+ *   1. The service's manifest `logs.local` shell command (e.g. `docker logs -f`)
+ *   2. The service's running container → `docker logs -f`: a compose stack's
+ *      `<stack>-<workspace>-<service>-1`, else an `opctl_<base>_<hash>` one —
+ *      real runtime logs with zero manifest config
+ *   3. The den daemon startup log (~/.den/logs/<repo>/<subsystem>.log) —
+ *      last resort, covers host-run processes with no container
+ * A source whose command exits within the quick-exit window (container not
+ * found, stale filter) is treated as broken and the next tier takes over.
+ */
+
+import * as fs from "fs";
+import { DAEMON_QUICK_EXIT_MS, LIVE_TAIL_LINES } from "../constants.js";
+import { readManifest } from "../manifest/read-manifest.js";
+import { findServiceContainer } from "./service-container.js";
+import {
+  getServiceLogPath,
+  spawnStreaming,
+} from "../process/spawn-streaming.js";
+import type { LogSource, ResolvedService } from "../types/index.js";
+
+export interface TailSource {
+  kind: "manifest" | "docker" | "file";
+  /** Executable (argv mode) or a full shell command (when args is empty). */
+  cmd: string;
+  /**
+   * Argv for cmd. Empty → cmd runs through the shell (manifest `logs.local`
+   * commands are arbitrary shell by design). Den-BUILT commands always use
+   * argv mode so container/subsystem names from manifests or docker output
+   * can never be shell-interpreted (`$(…)`, backticks, quotes).
+   */
+  args: string[];
+  /** Working directory for the command (manifest commands run in the repo). */
+  cwd?: string;
+  /** Human-readable description for the stream header. */
+  label: string;
+}
+
+export interface TailSourceInputs {
+  repoPath?: string;
+  /** The subsystem's manifest `logs.local` entry, if any. */
+  logSource?: LogSource;
+  /** A running conventional opctl container name, if any. */
+  container: string | null;
+  daemonLogPath: string;
+  daemonLogExists: boolean;
+}
+
+/** Ordered tail-source candidates (best source first). Pure — see resolveTailSources. */
+export function tailSourceCandidates(
+  inputs: TailSourceInputs,
+  lines: number = LIVE_TAIL_LINES,
+): TailSource[] {
+  const candidates: TailSource[] = [];
+  if (inputs.logSource?.type === "shell" && inputs.logSource.cmd) {
+    candidates.push({
+      kind: "manifest",
+      cmd: inputs.logSource.cmd,
+      args: [],
+      cwd: inputs.repoPath,
+      label: `manifest log command: ${inputs.logSource.cmd}`,
+    });
+  }
+  if (inputs.container) {
+    candidates.push({
+      kind: "docker",
+      cmd: "docker",
+      args: ["logs", "-f", "--tail", String(lines), inputs.container],
+      label: `container logs: ${inputs.container}`,
+    });
+  }
+  if (inputs.daemonLogExists) {
+    candidates.push({
+      kind: "file",
+      cmd: "tail",
+      args: ["-F", "-n", String(lines), inputs.daemonLogPath],
+      label: `startup log: ${inputs.daemonLogPath}`,
+    });
+  }
+  return candidates;
+}
+
+/** Gather live inputs for `resolved` and build its tail-source candidates. */
+export function resolveTailSources(resolved: ResolvedService): TailSource[] {
+  const manifest = readManifest(resolved.repoPath);
+  const logSource = manifest?.services?.[resolved.subsystem]?.logs?.local;
+  const container = findServiceContainer(
+    resolved.repoName,
+    resolved.repoPath,
+    resolved.subsystem,
+  );
+  const daemonLogPath = getServiceLogPath(
+    resolved.repoName,
+    resolved.subsystem,
+  );
+  return tailSourceCandidates({
+    repoPath: resolved.repoPath,
+    logSource,
+    container,
+    daemonLogPath,
+    daemonLogExists: fs.existsSync(daemonLogPath),
+  });
+}
+
+export interface FollowCallbacks {
+  onLine: (line: string) => void;
+  /** Stream headers / end-of-stream notices (rendered dim by the CLI). */
+  onMeta: (line: string) => void;
+}
+
+export interface FollowHandle {
+  /** Resolves with the final stream's exit code (0 after stop()). */
+  done: Promise<number>;
+  /** Stop tailing without stopping the service. */
+  stop: () => void;
+}
+
+export interface FollowDeps {
+  spawn?: typeof spawnStreaming;
+  quickExitMs?: number;
+}
+
+/**
+ * Follow the first working candidate, falling through the tiers when a
+ * command quick-exits. Lines seen before a source survives the quick-exit
+ * window are buffered (flushed on confirm, discarded on fallback) so a broken
+ * tier's error spew never reaches the caller.
+ */
+export function followTailSources(
+  candidates: TailSource[],
+  { onLine, onMeta }: FollowCallbacks,
+  deps: FollowDeps = {},
+): FollowHandle {
+  const spawn = deps.spawn ?? spawnStreaming;
+  const quickExitMs = deps.quickExitMs ?? DAEMON_QUICK_EXIT_MS;
+
+  let stopped = false;
+  let current: ReturnType<typeof spawnStreaming> | null = null;
+  let resolveDone!: (code: number) => void;
+  const done = new Promise<number>((resolve) => (resolveDone = resolve));
+
+  const tryCandidate = (index: number): void => {
+    if (index >= candidates.length) {
+      onMeta("── no live log stream available ──");
+      resolveDone(1);
+      return;
+    }
+    const source = candidates[index];
+    const buffer: string[] = [];
+    let confirmed = false;
+    let quickTimer: ReturnType<typeof setTimeout> | null = setTimeout(() => {
+      quickTimer = null;
+      confirmed = true;
+      onMeta(`── ${source.label} ──`);
+      for (const line of buffer) onLine(line);
+      buffer.length = 0;
+    }, quickExitMs);
+
+    // Detached: the tail child leads its own process group, so stop() can
+    // SIGTERM the whole tree. Shell-wrapped commands (e.g. `docker logs -f
+    // $(docker ps …)`) keep `sh` as the parent — killing only its pid would
+    // orphan a live `docker logs -f`. The child's stdio pipes keep the event
+    // loop alive; killing it stops the stream, never the service.
+    current = spawn(
+      source.cmd,
+      source.args,
+      { ...process.env },
+      (line) => (confirmed ? onLine(line) : buffer.push(line)),
+      (exitCode) => {
+        if (quickTimer !== null) {
+          clearTimeout(quickTimer);
+          quickTimer = null;
+        }
+        if (stopped) {
+          resolveDone(0);
+          return;
+        }
+        if (!confirmed) {
+          buffer.length = 0;
+          tryCandidate(index + 1);
+          return;
+        }
+        onMeta(`── log stream ended (${exitCode}) ──`);
+        resolveDone(exitCode);
+      },
+      source.cwd,
+      true,
+    );
+  };
+
+  tryCandidate(0);
+
+  return {
+    done,
+    stop: (): void => {
+      stopped = true;
+      if (!current) return;
+      try {
+        // Negative pid → the child's whole process group (it is detached).
+        if (current.pid) process.kill(-current.pid, "SIGTERM");
+        else current.kill("SIGTERM");
+      } catch {
+        try {
+          current.kill("SIGTERM");
+        } catch {
+          /* already exited */
+        }
+      }
+    },
+  };
+}

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

@@ -0,0 +1,78 @@
+/**
+ * Lightweight Makefile target discovery.
+ *
+ * `den graph`/`up` annotate each node with the make targets it exposes and
+ * warn when the ones den drives (`setup`/`up`/`down`) are missing. We parse
+ * the root `Makefile` plus any `include`d `*.mk` for target definitions —
+ * deliberately simple (no variable expansion), reading a fixed set of files.
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+
+export interface MakeTargets {
+  /** Sorted, unique runnable target names. */
+  targets: string[];
+  /** Makefiles parsed, relative to repo root. */
+  files: string[];
+}
+
+const TARGET_LINE = /^([A-Za-z0-9][A-Za-z0-9_.-]*)[ \t]*:(?!=)/gm;
+const INCLUDE_LINE = /^[ \t]*-?include[ \t]+(.+)$/gm;
+
+function readSafe(abs: string): string | null {
+  try {
+    return fs.readFileSync(abs, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+function collectTargets(content: string, into: Set<string>): void {
+  for (const m of content.matchAll(TARGET_LINE)) {
+    const name = m[1];
+    if (name.startsWith(".")) continue; // .PHONY, .DEFAULT_GOAL, …
+    into.add(name);
+  }
+}
+
+/** Parse the root Makefile (+ statically-includable `*.mk`) for target names. */
+export function listMakeTargets(repoPath: string): MakeTargets {
+  const rootMk = path.join(repoPath, "Makefile");
+  const rootContent = readSafe(rootMk);
+  if (rootContent === null) return { targets: [], files: [] };
+
+  const targets = new Set<string>();
+  const filesParsed: string[] = ["Makefile"];
+  collectTargets(rootContent, targets);
+
+  // Follow one level of `include`d makefiles with literal (non-variable) paths.
+  const seen = new Set<string>([rootMk]);
+  for (const inc of rootContent.matchAll(INCLUDE_LINE)) {
+    const spec = inc[1].trim();
+    if (spec.includes("$")) continue; // variable path — can't resolve statically
+    for (const rel of spec.split(/\s+/)) {
+      const abs = path.join(repoPath, rel);
+      if (seen.has(abs)) continue;
+      seen.add(abs);
+      const content = readSafe(abs);
+      if (content === null) continue;
+      filesParsed.push(rel);
+      collectTargets(content, targets);
+    }
+  }
+
+  return { targets: [...targets].sort(), files: filesParsed };
+}
+
+/** Split `required` into those present in the repo's Makefile(s) and those missing. */
+export function requireTargets(
+  repoPath: string,
+  required: string[],
+): { present: string[]; missing: string[] } {
+  const have = new Set(listMakeTargets(repoPath).targets);
+  const present: string[] = [];
+  const missing: string[] = [];
+  for (const t of required) (have.has(t) ? present : missing).push(t);
+  return { present, missing };
+}