@monster-orange/den 0.0.0 → 0.2.0

package/src/shared/stacks/status.ts

@@ -0,0 +1,99 @@
+/**
+ * Read-only stack status: what `stack ls` and `stack health` show, as data.
+ * The CLI prints it; the web server serves it at /api/stacks (and through it
+ * the MCP `stacks` tool).
+ */
+import { readEdgeConfig } from "../edge/config.js";
+import { routeUrl } from "../edge/render.js";
+import {
+  getFocusedWorkspaceName,
+  getWorkspaceByName,
+} from "../environment-manager/workspaces.js";
+import { readStacks } from "./config.js";
+import { projectName, stackWorkspace } from "./render.js";
+import { stackHealth, type StackContext } from "./runtime.js";
+
+export interface StackRoute {
+  name: string;
+  url: string;
+  /** `<service>:<container port>`. */
+  target: string;
+}
+
+export interface StackStatus {
+  name: string;
+  repo: string;
+  dir: string | null;
+  /** The Compose project: `<stack>-<workspace>`. */
+  project: string;
+  routes: StackRoute[];
+  uses: string[];
+  /** Container health (only when asked for: it runs `docker ps`). */
+  health?: { ok: boolean; 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`.
+ */
+export function resolveStackWorkspaces(
+  denWorkspace?: string | null,
+  env: NodeJS.ProcessEnv = process.env,
+): { denWorkspace: string; stackWorkspace: string } {
+  const fkWs =
+    denWorkspace ||
+    env.DEN_WORKSPACE_OVERRIDE ||
+    getFocusedWorkspaceName() ||
+    "default";
+  const ws = env.DEN_STACK_WORKSPACE || stackWorkspace(fkWs);
+  if (!WS_RE.test(ws))
+    throw new Error(
+      `workspace "${ws}" must be lowercase letters, digits and dashes`,
+    );
+  return { denWorkspace: fkWs, stackWorkspace: ws };
+}
+
+/** 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 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 };
+}
+
+/** Each stack's name, project, routes and (optionally) container health. */
+export function stackStatuses(
+  ctx: StackContext,
+  opts: { health?: boolean; healthOf?: typeof stackHealth } = {},
+): StackStatus[] {
+  const healthOf = opts.healthOf ?? stackHealth;
+  return Object.values(ctx.stacks).map((s) => {
+    const status: StackStatus = {
+      name: s.name,
+      repo: s.repo,
+      dir: s.dir ?? null,
+      project: projectName(s.name, ctx.workspace),
+      routes: Object.entries(s.routes).map(([route, target]) => ({
+        name: route,
+        url: routeUrl(`${route}.${s.name}`, ctx.edge),
+        target,
+      })),
+      uses: [...s.uses],
+    };
+    if (opts.health) {
+      try {
+        status.health = healthOf(ctx, s);
+      } catch (e) {
+        status.health = { ok: false, detail: (e as Error).message };
+      }
+    }
+    return status;
+  });
+}

package/src/shared/stacks/types.ts

@@ -0,0 +1,53 @@
+/**
+ * A stack = one repo's Docker Compose project, run behind the edge.
+ *
+ *   stacks:
+ *     webapp:
+ *       repo: sample-webapp
+ *       files: [docker-compose.yml]          # relative to repo/dir
+ *       routes: { app: frontend:80 }         # https://app.webapp.<domain>
+ *       generate: [SECRET_KEY]               # random once, kept in local state
+ *       uses: [ragstack]                    # start first + private link network
+ *       env:                                 # compose ${VAR} substitution
+ *         RAG_PROXY_TARGET: "http://{ragstack.ragstack-server}:80"
+ *
+ * `{stack.service}` expands to that service's container name.
+ */
+export interface StackConfig {
+  name: string;
+  repo: string;
+  /** Absolute checkout path; when unset, `<repos_root>/<repo>`. */
+  repoPath?: string;
+  /** Subdirectory of the repo holding the compose files. */
+  dir?: string;
+  files: string[];
+  /** `<route>` → `<service>:<container port>`. */
+  routes: Record<string, string>;
+  generate: string[];
+  uses: string[];
+  env: Record<string, string>;
+  /** Compose profiles to enable. */
+  profiles: string[];
+  /** service → replacement healthcheck `test`, for a repo's broken check. */
+  healthchecks?: Record<string, string[]>;
+  /**
+   * service → environment variables set on that service (override wins by
+   * key). For values a repo's compose file hard-codes, which `env` (compose
+   * `${VAR}` substitution) cannot change.
+   */
+  serviceEnv?: Record<string, Record<string, string>>;
+}
+
+/** What `docker compose config --format json` tells us about a service. */
+export interface ResolvedService {
+  container_name?: string;
+  ports?: unknown[];
+  networks?: Record<string, unknown> | null;
+  environment?: Record<string, string | null> | null;
+}
+
+export interface ResolvedProject {
+  name: string;
+  services: Record<string, ResolvedService>;
+  networks?: Record<string, { name?: string }>;
+}

package/src/shared/terminal/tabs.ts

@@ -0,0 +1,212 @@
+import * as fs from "fs";
+import { execFileSync } from "child_process";
+
+import { product } from "../product.js";
+export type TerminalApp = "iterm2" | "terminal";
+
+export interface OpenTabOptions {
+  cmd: string;
+  cwd: string;
+  label?: string;
+  terminalApp?: TerminalApp;
+  /**
+   * Variables to export in the tab before running `cmd`. A tab is a fresh
+   * login shell, so den-resolved values (the org config's service_env) are only
+   * present if we put them there — without them a consumer repo silently falls
+   * back to its `../<repo>` sibling default and fails in a nested checkout.
+   *
+   * Keep this to non-secret values: it lands in the tab's shell history.
+   */
+  env?: Record<string, string>;
+}
+
+export interface OpenedTab {
+  terminalApp: TerminalApp;
+  tabId: string;
+}
+
+const APPLE_TERMINAL_APP = fs.existsSync(
+  "/System/Applications/Utilities/Terminal.app",
+)
+  ? "/System/Applications/Utilities/Terminal.app"
+  : "Terminal";
+
+export function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+function appleScriptString(value: string): string {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+function automationHelp(appName: string): string {
+  return (
+    `Could not automate ${appName}. ` +
+    `Allow ${product().title}/your terminal to control Terminal, iTerm, and System Events in ` +
+    "System Settings > Privacy & Security > Automation."
+  );
+}
+
+function runAppleScript(script: string, appName: string): string {
+  try {
+    return execFileSync("osascript", ["-e", script], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+  } catch (error) {
+    const stderr =
+      typeof (error as { stderr?: unknown }).stderr === "string"
+        ? ((error as { stderr: string }).stderr ?? "")
+        : "";
+    const message = stderr.trim() || (error as Error).message;
+    throw new Error(`${automationHelp(appName)} ${message}`.trim());
+  }
+}
+
+function buildTabCommand(opts: OpenTabOptions): string {
+  const exports = Object.entries(opts.env ?? {})
+    .filter(([key, value]) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key) && value)
+    .map(([key, value]) => `export ${key}=${shellQuote(value)}`);
+  const prefix = exports.length > 0 ? `${exports.join(" ")} && ` : "";
+  return `${prefix}cd ${shellQuote(opts.cwd)} && ${opts.cmd}`;
+}
+
+function openITermTab(command: string): OpenedTab {
+  const script = `
+tell application "iTerm"
+  activate
+  if (count of windows) = 0 then
+    set newWindow to (create window with default profile)
+    set newTab to current tab of newWindow
+  else
+    tell current window
+      set newTab to (create tab with default profile)
+    end tell
+  end if
+  tell current session of newTab
+    write text ${appleScriptString(command)}
+  end tell
+  return (id of current session of newTab as text)
+end tell
+`;
+  return { terminalApp: "iterm2", tabId: runAppleScript(script, "iTerm2") };
+}
+
+function openAppleTerminalTab(command: string): OpenedTab {
+  const script = `
+tell application ${appleScriptString(APPLE_TERMINAL_APP)}
+  activate
+  if not (exists front window) then
+    do script ""
+  end if
+end tell
+delay 0.1
+tell application "System Events"
+  tell process "Terminal"
+    keystroke "t" using command down
+  end tell
+end tell
+delay 0.1
+tell application ${appleScriptString(APPLE_TERMINAL_APP)}
+  do script ${appleScriptString(command)} in selected tab of front window
+  return tty of selected tab of front window
+end tell
+`;
+  return {
+    terminalApp: "terminal",
+    tabId: runAppleScript(script, "Apple Terminal"),
+  };
+}
+
+export function openTab(opts: OpenTabOptions): OpenedTab {
+  const terminalApp = opts.terminalApp ?? detectDefaultTerminalApp();
+  const command = buildTabCommand(opts);
+  if (terminalApp === "iterm2") return openITermTab(command);
+  return openAppleTerminalTab(command);
+}
+
+export function closeTab(tabId: string, terminalApp: TerminalApp): void {
+  if (terminalApp === "iterm2") {
+    const script = `
+tell application "iTerm"
+  repeat with w in windows
+    repeat with t in tabs of w
+      if (id of current session of t as text) is ${appleScriptString(tabId)} then
+        close t
+        return "closed"
+      end if
+    end repeat
+  end repeat
+end tell
+return "missing"
+`;
+    runAppleScript(script, "iTerm2");
+    return;
+  }
+
+  const script = `
+tell application ${appleScriptString(APPLE_TERMINAL_APP)}
+  repeat with w in windows
+    repeat with t in tabs of w
+      try
+        if (tty of t) is ${appleScriptString(tabId)} then
+          close t
+          return "closed"
+        end if
+      end try
+    end repeat
+  end repeat
+end tell
+return "missing"
+`;
+  runAppleScript(script, "Apple Terminal");
+}
+
+export function tabExists(tabId: string, terminalApp: TerminalApp): boolean {
+  if (terminalApp === "iterm2") {
+    const script = `
+tell application "iTerm"
+  repeat with w in windows
+    repeat with t in tabs of w
+      if (id of current session of t as text) is ${appleScriptString(tabId)} then return "yes"
+    end repeat
+  end repeat
+end tell
+return "no"
+`;
+    return runAppleScript(script, "iTerm2") === "yes";
+  }
+
+  const script = `
+tell application ${appleScriptString(APPLE_TERMINAL_APP)}
+  repeat with w in windows
+    repeat with t in tabs of w
+      try
+        if (tty of t) is ${appleScriptString(tabId)} then return "yes"
+      end try
+    end repeat
+  end repeat
+end tell
+return "no"
+`;
+  return runAppleScript(script, "Apple Terminal") === "yes";
+}
+
+export function resolveTerminalApp(key: string | undefined): TerminalApp {
+  if (!key) return detectDefaultTerminalApp();
+  if (key === "iterm2") return "iterm2";
+  if (key === "terminal") return "terminal";
+  if (key === "ghostty") {
+    throw new Error(
+      `Tab mode does not support Ghostty yet. Set \`${product().cli} config terminal=iterm2\`, \`${product().cli} config terminal=terminal\`, or run with \`--no-tabs\`.`,
+    );
+  }
+  throw new Error(
+    `Tab mode only supports iTerm2 and Apple Terminal. Configured terminal "${key}" is not supported; run with --no-tabs to use daemon mode.`,
+  );
+}
+
+function detectDefaultTerminalApp(): TerminalApp {
+  if (fs.existsSync("/Applications/iTerm.app")) return "iterm2";
+  return "terminal";
+}