@monster-orange/den 0.0.0-stage → 0.1.0

package/src/ui/server/changelog-parser.ts

@@ -0,0 +1,94 @@
+/**
+ * Changelog parser — parses Keep a Changelog format into structured entries.
+ *
+ * Extracted from server/index.ts. Used by the /api/changelog endpoint
+ * and the startup banner version detection.
+ */
+
+export interface ChangelogBullet {
+  text: string;
+  sub: string[];
+}
+
+export interface ChangelogEntry {
+  version: string;
+  date: string;
+  /** Free-form text between the version header and the first ### section. */
+  note?: string;
+  sections: Record<string, ChangelogBullet[]>;
+  /** Raw markdown block for this version entry, suitable for sharing. */
+  raw: string;
+}
+
+/**
+ * Parse a Keep a Changelog-style CHANGELOG.md into structured entries.
+ * Each section starts with: ## [version] — YYYY-MM-DD
+ */
+export function parseChangelog(raw: string): ChangelogEntry[] {
+  const entries: ChangelogEntry[] = [];
+  const versionPattern = /^##\s+\[([^\]]+)\]\s*[—–-]\s*(\S+)/;
+  const sectionPattern = /^###\s+(.+)/;
+
+  let current: ChangelogEntry | null = null;
+  let currentSection: string | null = null;
+  let currentLines: string[] = [];
+
+  const lines = raw.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const vMatch = line.match(versionPattern);
+    if (vMatch) {
+      if (current) {
+        current.raw = currentLines.join("\n").trimEnd();
+        entries.push(current);
+      }
+      current = { version: vMatch[1], date: vMatch[2], sections: {}, raw: "" };
+      currentSection = null;
+      currentLines = [line];
+      continue;
+    }
+    if (!current) continue;
+
+    // Stop collecting raw lines when we hit the next version separator ("---")
+    if (line.trim() === "---") {
+      current.raw = currentLines.join("\n").trimEnd();
+      entries.push(current);
+      current = null;
+      currentLines = [];
+      continue;
+    }
+
+    currentLines.push(line);
+
+    const sMatch = line.match(sectionPattern);
+    if (sMatch) {
+      currentSection = sMatch[1];
+      current.sections[currentSection] = [];
+      continue;
+    }
+
+    // Capture free text before the first ### section as a note
+    if (!currentSection && line.trim() && !line.startsWith("#")) {
+      current.note = (current.note ? current.note + " " : "") + line.trim();
+    }
+
+    if (currentSection && line.startsWith("- ")) {
+      current.sections[currentSection].push({
+        text: line.slice(2).trim(),
+        sub: [],
+      });
+    } else if (currentSection && /^ {2}- /.test(line)) {
+      const bullets = current.sections[currentSection];
+      if (bullets.length > 0) {
+        bullets[bullets.length - 1].sub.push(
+          line.replace(/^ {2}- /, "").trim(),
+        );
+      }
+    }
+  }
+  if (current) {
+    current.raw = currentLines.join("\n").trimEnd();
+    entries.push(current);
+  }
+  return entries;
+}

package/src/ui/server/daemon-reaper.ts

@@ -0,0 +1,129 @@
+/**
+ * Daemon-registry recovery sweep (Web-UI server startup).
+ *
+ * After a den restart, previously registered daemons are reloaded from
+ * disk and health-checked. Entries whose service is explicitly unhealthy
+ * (was stopped outside of den) are removed so the shutdown prompt
+ * doesn't list them.
+ *
+ * Removal requires STRONG evidence (review finding 11): a single
+ * transient timeout/5xx must never unregister a possibly-running daemon,
+ * so an "error" health result is only acted on after a SECOND
+ * consecutive "error" check separated by a retry delay. "unknown"
+ * results and thrown checks always keep the entry (err on the side of
+ * keeping). A daemon whose address no longer resolves to any
+ * workspace/catalog service is process-death-equivalent evidence and is
+ * removed directly.
+ */
+
+import type { ServiceHealthResult } from "../../shared/environment-manager/health.js";
+import type { DaemonRecord } from "../../shared/environment-manager/service-runner.js";
+import type { ResolvedService } from "../../shared/types/index.js";
+
+export interface DaemonReaperDeps {
+  listDaemons: () => DaemonRecord[];
+  /**
+   * Resolve an address, optionally against a named workspace. Omitting the
+   * workspace resolves against the focused one only, which is not enough with
+   * several workspaces active — see `resolveForDaemon`.
+   */
+  resolveService: (
+    address: string,
+    workspace?: string,
+  ) => ResolvedService | null;
+  /** Names of the currently active workspaces — see `resolveForDaemon`. */
+  getActiveWorkspaces: () => string[];
+  checkServiceHealth: (
+    service: ResolvedService,
+  ) => Promise<ServiceHealthResult>;
+  unregisterDaemon: (address: string) => void;
+  /** Injectable sleep between the two confirmation checks. */
+  delay: (ms: number) => Promise<void>;
+  /** Gap between the first "error" result and the confirming re-check. */
+  retryDelayMs: number;
+}
+
+export interface DaemonReapResult {
+  /** Addresses removed from the registry. */
+  removed: string[];
+  /** Addresses kept (healthy, unknown, transient failure, or check threw). */
+  kept: string[];
+}
+
+/**
+ * Resolve a daemon's service, trying the focus, then each workspace that owns
+ * it, then every other active workspace, before concluding the service is gone.
+ * The focused workspace alone would drop every daemon belonging to another
+ * active workspace the moment focus moves — and its containers keep running, so
+ * the record is exactly what's needed to stop them.
+ *
+ * The active set is the last resort because a legacy record carries no owners
+ * at all: without it, a running service defined only in a non-focused active
+ * workspace looks unresolvable and gets reaped. This mirrors
+ * `canResolveDaemonAddress`, which `pruneDeadDaemons` uses for the same call.
+ */
+function resolveForDaemon(
+  deps: DaemonReaperDeps,
+  daemon: DaemonRecord,
+): ResolvedService | null {
+  const direct = deps.resolveService(daemon.address);
+  if (direct) return direct;
+  const candidates = [
+    ...new Set([...(daemon.workspaces ?? []), ...deps.getActiveWorkspaces()]),
+  ];
+  for (const workspace of candidates) {
+    const owned = deps.resolveService(daemon.address, workspace);
+    if (owned) return owned;
+  }
+  return null;
+}
+
+/**
+ * Sweep the daemon registry once. Unregisters an entry only when its
+ * service is gone from every owning workspace/catalog, or when TWO
+ * consecutive health checks report "error".
+ */
+export async function reapDeadDaemons(
+  deps: DaemonReaperDeps,
+): Promise<DaemonReapResult> {
+  const removed: string[] = [];
+  const kept: string[] = [];
+
+  await Promise.allSettled(
+    deps.listDaemons().map(async (daemon) => {
+      try {
+        const service = resolveForDaemon(deps, daemon);
+        if (!service) {
+          // No longer in any owning workspace/catalog — nothing could restart it.
+          deps.unregisterDaemon(daemon.address);
+          removed.push(daemon.address);
+          return;
+        }
+
+        const first = await deps.checkServiceHealth(service);
+        if (first.health !== "error") {
+          // "ok" and "unknown" both keep the entry.
+          kept.push(daemon.address);
+          return;
+        }
+
+        // One "error" may be a transient timeout/5xx — confirm before
+        // unregistering a possibly-running daemon.
+        await deps.delay(deps.retryDelayMs);
+        const second = await deps.checkServiceHealth(service);
+        if (second.health === "error") {
+          deps.unregisterDaemon(daemon.address);
+          removed.push(daemon.address);
+        } else {
+          kept.push(daemon.address);
+        }
+      } catch {
+        // Err on the side of keeping the entry rather than wrongly
+        // removing it.
+        kept.push(daemon.address);
+      }
+    }),
+  );
+
+  return { removed, kept };
+}

package/src/ui/server/editor-manager.ts

@@ -0,0 +1,301 @@
+/**
+ * Editor & Terminal Manager
+ *
+ * Extracted from server/index.ts. Handles detection of installed editors
+ * and terminal apps, path resolution, and availability listing.
+ */
+
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { spawnSync } from "child_process";
+import { detectStackConfig } from "../../ui/cli/init.js";
+
+// ── Editor definitions ───────────────────────────────────────────────────────
+
+interface EditorDef {
+  key: string;
+  name: string;
+  /** Binary name for `which` fallback (may differ from key). */
+  binName: string;
+  terminal: boolean;
+  paths: readonly string[];
+}
+
+const KNOWN_EDITORS: readonly EditorDef[] = [
+  {
+    key: "vscode",
+    name: "VS Code",
+    binName: "code",
+    terminal: false,
+    paths: [
+      "/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code",
+      path.join(
+        os.homedir(),
+        "Applications/Visual Studio Code.app/Contents/Resources/app/bin/code",
+      ),
+      "/usr/local/bin/code",
+      "/opt/homebrew/bin/code",
+    ],
+  },
+  {
+    key: "cursor",
+    name: "Cursor",
+    binName: "cursor",
+    terminal: false,
+    paths: [
+      "/Applications/Cursor.app/Contents/Resources/app/bin/cursor",
+      path.join(
+        os.homedir(),
+        "Applications/Cursor.app/Contents/Resources/app/bin/cursor",
+      ),
+      "/usr/local/bin/cursor",
+    ],
+  },
+  {
+    key: "webstorm",
+    name: "WebStorm",
+    binName: "webstorm",
+    terminal: false,
+    paths: [
+      path.join(
+        os.homedir(),
+        "Library/Application Support/JetBrains/Toolbox/scripts/webstorm",
+      ),
+      "/usr/local/bin/webstorm",
+    ],
+  },
+  {
+    key: "idea",
+    name: "IntelliJ IDEA",
+    binName: "idea",
+    terminal: false,
+    paths: [
+      path.join(
+        os.homedir(),
+        "Library/Application Support/JetBrains/Toolbox/scripts/idea",
+      ),
+      "/usr/local/bin/idea",
+    ],
+  },
+  {
+    key: "zed",
+    name: "Zed",
+    binName: "zed",
+    terminal: false,
+    paths: [
+      "/Applications/Zed.app/Contents/MacOS/cli",
+      path.join(os.homedir(), "Applications/Zed.app/Contents/MacOS/cli"),
+      "/usr/local/bin/zed",
+    ],
+  },
+  {
+    key: "vim",
+    name: "vim",
+    binName: "vim",
+    terminal: true,
+    paths: ["/usr/bin/vim", "/opt/homebrew/bin/vim", "/usr/local/bin/vim"],
+  },
+  {
+    key: "nvim",
+    name: "Neovim",
+    binName: "nvim",
+    terminal: true,
+    paths: ["/opt/homebrew/bin/nvim", "/usr/local/bin/nvim", "/usr/bin/nvim"],
+  },
+  {
+    key: "emacs",
+    name: "Emacs",
+    binName: "emacs",
+    terminal: true,
+    paths: [
+      "/Applications/Emacs.app/Contents/MacOS/emacs",
+      "/opt/homebrew/bin/emacs",
+      "/usr/bin/emacs",
+    ],
+  },
+];
+
+// ── Terminal definitions (macOS) ─────────────────────────────────────────────
+
+interface TerminalDef {
+  key: string;
+  name: string;
+  appName: string;
+  appPaths: readonly string[];
+}
+
+const KNOWN_TERMINALS: readonly TerminalDef[] = [
+  {
+    key: "terminal",
+    name: "Terminal",
+    appName: "Terminal",
+    appPaths: ["/System/Applications/Utilities/Terminal.app"],
+  },
+  {
+    key: "iterm2",
+    name: "iTerm2",
+    appName: "iTerm",
+    appPaths: ["/Applications/iTerm.app"],
+  },
+  {
+    key: "ghostty",
+    name: "Ghostty",
+    appName: "Ghostty",
+    appPaths: [
+      "/Applications/Ghostty.app",
+      path.join(os.homedir(), "Applications/Ghostty.app"),
+    ],
+  },
+  {
+    key: "warp",
+    name: "Warp",
+    appName: "Warp",
+    appPaths: ["/Applications/Warp.app"],
+  },
+  {
+    key: "kitty",
+    name: "kitty",
+    appName: "kitty",
+    appPaths: [
+      "/Applications/kitty.app",
+      path.join(os.homedir(), "Applications/kitty.app"),
+    ],
+  },
+  {
+    key: "alacritty",
+    name: "Alacritty",
+    appName: "Alacritty",
+    appPaths: [
+      "/Applications/Alacritty.app",
+      path.join(os.homedir(), "Applications/Alacritty.app"),
+    ],
+  },
+  {
+    key: "hyper",
+    name: "Hyper",
+    appName: "Hyper",
+    appPaths: ["/Applications/Hyper.app"],
+  },
+];
+
+/** JetBrains editors that open via CLI but need special `--line` arg handling. */
+export const JETBRAINS_EDITORS = new Set(["webstorm", "idea"]);
+
+// ── Supported languages for per-language IDE overrides ───────────────────────
+
+export const SUPPORTED_LANGUAGES = [
+  { key: "go", name: "Go" },
+  { key: "python", name: "Python" },
+  { key: "typescript", name: "TypeScript" },
+  { key: "javascript", name: "JavaScript" },
+  { key: "java", name: "Java" },
+  { key: "kotlin", name: "Kotlin" },
+  { key: "rust", name: "Rust" },
+  { key: "ruby", name: "Ruby" },
+  { key: "swift", name: "Swift" },
+  { key: "csharp", name: "C#" },
+] as const;
+
+// ── EditorManager ────────────────────────────────────────────────────────────
+
+export class EditorManager {
+  /** Resolve the executable path for an editor key, or null if not installed. */
+  resolveEditorCmd(key: string): string | null {
+    const editor = KNOWN_EDITORS.find((e) => e.key === key);
+    if (!editor) return null;
+    for (const p of editor.paths) {
+      if (fs.existsSync(p)) return p;
+    }
+    try {
+      const result = spawnSync("which", [editor.binName], {
+        encoding: "utf-8",
+      });
+      const found = result.stdout?.trim();
+      if (found && fs.existsSync(found)) return found;
+    } catch {
+      // ignore
+    }
+    return null;
+  }
+
+  /** Resolve the macOS app name for a terminal key, or null if not installed. */
+  resolveTerminalApp(key: string): string | null {
+    const terminal = KNOWN_TERMINALS.find((t) => t.key === key);
+    if (!terminal) return null;
+    for (const p of terminal.appPaths) {
+      if (fs.existsSync(p)) return terminal.appName;
+    }
+    return null;
+  }
+
+  /** List all known editors with their availability status. */
+  listEditors(): Array<{
+    key: string;
+    name: string;
+    terminal: boolean;
+    available: boolean;
+  }> {
+    return KNOWN_EDITORS.map((e) => ({
+      key: e.key,
+      name: e.name,
+      terminal: e.terminal,
+      available: !!this.resolveEditorCmd(e.key),
+    }));
+  }
+
+  /** List all known terminals with their availability status. */
+  listTerminals(): Array<{ key: string; name: string; available: boolean }> {
+    return KNOWN_TERMINALS.map((t) => ({
+      key: t.key,
+      name: t.name,
+      available: !!this.resolveTerminalApp(t.key),
+    }));
+  }
+
+  /** True if the editor key is a terminal-based editor (vim, nvim, emacs). */
+  isTerminalEditor(key: string): boolean {
+    return KNOWN_EDITORS.find((e) => e.key === key)?.terminal ?? false;
+  }
+
+  /** True if the key matches a known editor. */
+  isKnownEditor(key: string): boolean {
+    return KNOWN_EDITORS.some((e) => e.key === key);
+  }
+
+  /** True if the key matches a known terminal. */
+  isKnownTerminal(key: string): boolean {
+    return KNOWN_TERMINALS.some((t) => t.key === key);
+  }
+
+  /**
+   * Resolve which editor to use for a path, considering overrides.
+   *
+   * Resolution order (first match wins):
+   *   1. Per-language override — repo has stack.yml with `language` field
+   *      matching a key in `languageOverrides`
+   *   2. Workspace editor — the active workspace has an `editor` override
+   *   3. Global default — the user's default editor from settings
+   */
+  resolveEditorForRepo(
+    repoPath: string,
+    defaultEditor: string | undefined,
+    languageOverrides: Record<string, string> | undefined,
+    workspaceEditor?: string,
+  ): string | undefined {
+    // 1. Per-language override (repo-level)
+    if (languageOverrides && Object.keys(languageOverrides).length > 0) {
+      const stack = detectStackConfig(repoPath);
+      const lang = stack?.language;
+      if (lang && languageOverrides[lang]) {
+        return languageOverrides[lang];
+      }
+    }
+    // 2. Workspace editor override
+    if (workspaceEditor) {
+      return workspaceEditor;
+    }
+    // 3. Global default
+    return defaultEditor;
+  }
+}