@monster-orange/den 0.4.16 → 0.4.18

package/src/ui/server/public/topbar.js

@@ -421,7 +421,15 @@ export function runOf(url, base = "http://localhost/") {
 
 const LS_LAST_RUN = "__DEN_CLI__-last-run";
 const SS_PENDING = "__DEN_CLI__-pending-action";
-const KIND = ["page", "service", "app", "agent", "action", "setting"];
+const KIND = [
+  "page",
+  "service",
+  "app",
+  "agent",
+  "workspace",
+  "action",
+  "setting",
+];
 const kindLabel = (k) =>
   KIND.includes(k)
     ? t(`kind.${k}`)
@@ -906,6 +914,31 @@ function paletteItems() {
       run: () => go(`/agents?open=${encodeURIComponent(x.id)}`),
     });
   }
+  // 0.4.17: Go to workspace <ws>, for every workspace, the front agent's
+  // first (on the Agents page); an agent's name finds its workspace too.
+  const byWs = new Map();
+  const front = document.querySelector("#agr")?.dataset.ws;
+  if (front) byWs.set(front, []);
+  // Every workspace: the Workspace menu's list (the header read it).
+  for (const ws of s?.workspaceNames?.() ?? [])
+    if (!byWs.has(ws)) byWs.set(ws, []);
+  for (const x of palSessions) {
+    if (!x.workspace) continue;
+    const names = byWs.get(x.workspace) ?? [];
+    names.push(x.label, x.displayName ?? "", x.persona ?? "");
+    byWs.set(x.workspace, names);
+  }
+  const wsBase =
+    s?.nav?.().find((n) => n.id === "local-dev")?.href ?? "/local-dev";
+  for (const [ws, names] of byWs)
+    items.push({
+      key: `ws:${ws}`,
+      kind: "workspace",
+      label: t("pal.goWs", { ws }),
+      keywords: [ws, "workspace", "workspaces", ...names.filter(Boolean)],
+      hideEmpty: true,
+      run: () => go(`${wsBase}?ws=${encodeURIComponent(ws)}`),
+    });
   if (s?.nav?.().some((n) => n.id === "agents"))
     items.push({
       key: "agent:start",

package/src/ui/server/public/view-scope.js

@@ -0,0 +1,61 @@
+/**
+ * One rule for org and workspace on a page (0.4.17, ORG-SPEC §5): a page
+ * shows its own org picker only when it filters by org. Otherwise it
+ * follows the top bar's View (Org and Workspace ▾), and says so with the
+ * same note. Environments and Releases both use this.
+ *
+ *   viewScope()            → { scope: "all" | <workspace>, inView: [names] }
+ *   viewNoteHtml(view)     → the "Follows the top bar" note's HTML
+ *   viewQuery(view)        → "&workspace=<ws>" for one workspace, else ""
+ *   viewRepos(view)        → the repos in view (a Set), or null for all
+ */
+
+const esc = (s) =>
+  String(s ?? "").replace(
+    /[&<>"']/g,
+    (c) =>
+      ({
+        "&": "&amp;",
+        "<": "&lt;",
+        ">": "&gt;",
+        '"': "&quot;",
+        "'": "&#39;",
+      })[c],
+  );
+
+/** The top bar's View: all active workspaces, or one. */
+export async function viewScope() {
+  const v = await fetch("/api/scope", { headers: { accept: "json" } })
+    .then((r) => (r.ok ? r.json() : null))
+    .catch(() => null);
+  return {
+    scope: typeof v?.scope === "string" && v.scope ? v.scope : "all",
+    inView: Array.isArray(v?.inView) ? v.inView : [],
+  };
+}
+
+/** The same note on every page that follows the View. */
+export function viewNoteHtml(view) {
+  const what =
+    view.scope === "all"
+      ? "all active workspaces"
+      : `workspace <b>${esc(view.scope)}</b>`;
+  return `<span class="note view-note" data-view="${esc(view.scope)}">Shows ${what}, as the top bar's View. Change it there.</span>`;
+}
+
+/** The health and services query for the View: one workspace, or none. */
+export function viewQuery(view) {
+  return view.scope === "all"
+    ? ""
+    : `&workspace=${encodeURIComponent(view.scope)}`;
+}
+
+/** The repos in the View's workspace, or null when it is all active. */
+export async function viewRepos(view) {
+  if (view.scope === "all") return null;
+  const d = await fetch("/api/workspaces", { headers: { accept: "json" } })
+    .then((r) => (r.ok ? r.json() : null))
+    .catch(() => null);
+  const ws = d?.workspaces?.[view.scope];
+  return ws ? new Set(Object.keys(ws.services ?? {})) : null;
+}

package/src/ui/server/public/workspace-picker.js

@@ -93,6 +93,8 @@ export function buildScopeMenuModel(scope, data, t = enT) {
   return {
     label: active.length === 0 ? t("ws.noneLabel") : (one ?? t("ws.all")),
     items,
+    // Every workspace, active or not: ⌘K's Go to workspace (0.4.17).
+    names: Object.keys(data?.workspaces ?? {}),
     focus: focus ?? null,
     title: t(focus ? "ws.viewTitleFocus" : "ws.viewTitle", {
       ws: inView.join(", ") || t("ws.noneLabel"),

package/src/ui/server/route-classes.ts

@@ -127,6 +127,8 @@ export const ROUTES: readonly RouteEntry[] = [
     "/api/release/config",
     "/api/release/status",
     "/api/release/runs",
+    // 0.4.17: each repo's last test run, from the run-history file.
+    "/api/runs/last",
     "/api/release/branches",
     "/api/release/deploy/active",
     "/api/changelog",

package/src/ui/server/run-history.ts

@@ -0,0 +1,181 @@
+/**
+ * The server's test-run history (0.4.17): every `/api/run` from every
+ * browser, kept in `<state>/run-history.jsonl`, one JSON line per start and
+ * one per end. Workspaces' "Last test run" column reads each repo's latest
+ * from it, so it fills in whoever ran it and survives a restart.
+ *
+ * The file is bounded: past MAX_LINES it keeps the newest KEEP_LINES.
+ * Never throws: a history it can't read or write is an empty one.
+ */
+import * as fs from "fs";
+import * as path from "path";
+
+/** One test run, as its lines describe it. */
+export interface RunEntry {
+  id: string;
+  pillar: string;
+  env: string;
+  /** The repos it tested (the pillar's sources), when known. */
+  repos: string[];
+  startedAt: string;
+  endedAt?: string;
+  exitCode?: number;
+}
+
+type Line =
+  | {
+      t: "start";
+      id: string;
+      pillar: string;
+      env: string;
+      repos: string[];
+      at: string;
+    }
+  | { t: "end"; id: string; at: string; exitCode: number };
+
+/** What `reposOfRun` asks about the repos (index.ts gives the real ones). */
+export interface RunRepoSources {
+  /** synthetic, smoke, journeys, security: the repos the pillar reads. */
+  pillarSources(pillar: string): string[];
+  /** suites: the repos whose `tests:` suites the run will run. */
+  suiteRepos(env: string, only: string[]): string[];
+  /** performance: every module's name (a repo's is `<repo>/<module>`). */
+  perfModules(): Promise<string[]>;
+  /** Every repo's name. */
+  repoNames(): string[];
+}
+
+/**
+ * The repos a run tests, for its history (0.4.17): every run kind that
+ * runs a repo's own tests fills its Last test run. integration is Den's
+ * own: no repo. Never throws: a source it can't read gives none.
+ */
+export async function reposOfRun(
+  pillar: string,
+  env: string,
+  modules: string[],
+  src: RunRepoSources,
+): Promise<string[]> {
+  const uniq = (xs: string[]) => [...new Set(xs.filter(Boolean))];
+  try {
+    if (["synthetic", "smoke", "journeys", "security"].includes(pillar))
+      return uniq(src.pillarSources(pillar));
+    if (pillar === "suites") return uniq(src.suiteRepos(env, modules));
+    if (pillar === "performance") {
+      const repos = new Set(src.repoNames());
+      const chosen = modules.length ? modules : await src.perfModules();
+      return uniq(
+        chosen
+          .filter((n) => n.includes("/"))
+          .map((n) => n.split("/")[0])
+          .filter((r) => repos.has(r)),
+      );
+    }
+  } catch {
+    /* no repos known: the history still has the run */
+  }
+  return [];
+}
+
+export const MAX_LINES = 2000;
+export const KEEP_LINES = 1000;
+
+export function runHistoryFile(stateDir: string): string {
+  return path.join(stateDir, "run-history.jsonl");
+}
+
+function append(stateDir: string, line: Line): void {
+  const file = runHistoryFile(stateDir);
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, `${JSON.stringify(line)}\n`, { mode: 0o600 });
+    const text = fs.readFileSync(file, "utf-8");
+    const lines = text.split("\n").filter(Boolean);
+    if (lines.length > MAX_LINES) {
+      const tmp = `${file}.${process.pid}.tmp`;
+      fs.writeFileSync(tmp, `${lines.slice(-KEEP_LINES).join("\n")}\n`, {
+        mode: 0o600,
+      });
+      fs.renameSync(tmp, file);
+    }
+  } catch {
+    /* no history: the column says "—" */
+  }
+}
+
+/** A run began: its pillar, environment and the repos it tests. */
+export function recordRunStart(
+  stateDir: string,
+  run: { id: string; pillar: string; env: string; repos: string[] },
+  now = new Date(),
+): void {
+  append(stateDir, { t: "start", ...run, at: now.toISOString() });
+}
+
+/** A run ended with `exitCode`. */
+export function recordRunEnd(
+  stateDir: string,
+  id: string,
+  exitCode: number,
+  now = new Date(),
+): void {
+  append(stateDir, { t: "end", id, at: now.toISOString(), exitCode });
+}
+
+/** Every run in the file, oldest first. */
+export function readRuns(stateDir: string): RunEntry[] {
+  let text = "";
+  try {
+    text = fs.readFileSync(runHistoryFile(stateDir), "utf-8");
+  } catch {
+    return [];
+  }
+  const byId = new Map<string, RunEntry>();
+  for (const raw of text.split("\n")) {
+    if (!raw) continue;
+    let l: Partial<Line> & Record<string, unknown>;
+    try {
+      l = JSON.parse(raw) as typeof l;
+    } catch {
+      continue;
+    }
+    if (typeof l.id !== "string" || typeof l.at !== "string") continue;
+    if (l.t === "start") {
+      byId.set(l.id, {
+        id: l.id,
+        pillar: String(l.pillar ?? ""),
+        env: String(l.env ?? ""),
+        repos: Array.isArray(l.repos) ? l.repos.map(String) : [],
+        startedAt: l.at,
+      });
+    } else if (l.t === "end") {
+      const r = byId.get(l.id);
+      if (r) {
+        r.endedAt = l.at;
+        r.exitCode = typeof l.exitCode === "number" ? l.exitCode : 1;
+      }
+    }
+  }
+  return [...byId.values()];
+}
+
+/**
+ * Each repo's latest run. A run that never ended counts as running only
+ * while this server runs it (`live`); one a restart cut off has no end and
+ * is skipped for an earlier one.
+ */
+export function lastRunsByRepo(
+  stateDir: string,
+  live: ReadonlySet<string> = new Set(),
+): Record<string, RunEntry & { running: boolean }> {
+  const out: Record<string, RunEntry & { running: boolean }> = {};
+  for (const r of readRuns(stateDir)) {
+    const running = r.endedAt === undefined && live.has(r.id);
+    if (r.endedAt === undefined && !running) continue;
+    for (const repo of r.repos) {
+      const cur = out[repo];
+      if (!cur || cur.startedAt <= r.startedAt) out[repo] = { ...r, running };
+    }
+  }
+  return out;
+}

package/src/ui/server/session-routes.ts

@@ -362,18 +362,101 @@ const TEXT = (code: number) =>
         : "Service Unavailable";
 
 /**
- * A plain HTTP request to an io route: it is a WebSocket. 426 for a GET,
- * 404 for anything else under /api/sessions/.
+ * Whether a session is one the io route serves: this distribution's, in a
+ * workspace workspaces.yml names, active or not (0.4.17: an agent you can
+ * start and see, you can open). The person's and the agent's checks are
+ * the request guard's, before this.
  */
-export function sendSessionHttp(
+function servedSession(
+  s: SessionInfo,
+  target: string,
+  d: Resolved,
+  active: ReadonlySet<string>,
+): boolean {
+  const p = parseSessionName(s.name, d.dist());
+  return (
+    p !== null &&
+    (active.has(p.workspace) || d.workspaceExists(p.workspace)) &&
+    (s.ref.id === target || s.name === target)
+  );
+}
+
+/**
+ * Why the io route would refuse `target`, or null when it would open it:
+ * what a browser can't read from a refused upgrade (it sees only a close),
+ * so the page asks this with a plain GET (0.4.17).
+ */
+async function ioRefusal(
+  target: string,
+  d: Resolved,
+): Promise<{ status: number; error: string; code: string } | null> {
+  let c: HostClient | null;
+  try {
+    c = await d.connectExisting();
+  } catch (e) {
+    return {
+      status: 503,
+      error: `the session host: ${(e as Error).message}`,
+      code: "session_host",
+    };
+  }
+  if (!c)
+    return {
+      status: 404,
+      error: `no session "${target}" (no session host is running)`,
+      code: "not_found",
+    };
+  try {
+    const active = new Set(d.activeWorkspaces());
+    const found = (await c.list()).some((s) =>
+      servedSession(s, target, d, active),
+    );
+    return found
+      ? null
+      : {
+          status: 404,
+          error: `no session "${target}" here`,
+          code: "not_found",
+        };
+  } catch (e) {
+    return {
+      status: 503,
+      error: `the session host: ${(e as Error).message}`,
+      code: "session_host",
+    };
+  } finally {
+    c.close();
+  }
+}
+
+/**
+ * A plain HTTP request to an io route: it is a WebSocket. For a GET, the
+ * refusal its upgrade would get (404, 503), else 426; 404 for anything
+ * else under /api/sessions/.
+ */
+export async function sendSessionHttp(
   req: http.IncomingMessage,
   res: http.ServerResponse,
   pathname: string,
-): void {
-  if (
-    IO_PATH.test(pathname) &&
-    (req.method === "GET" || req.method === "HEAD")
-  ) {
+  deps: SessionRouteDeps = {},
+): Promise<void> {
+  const m = IO_PATH.exec(pathname);
+  if (m && (req.method === "GET" || req.method === "HEAD")) {
+    let target = m[1];
+    try {
+      target = decodeURIComponent(target);
+    } catch {
+      /* as given */
+    }
+    const why = await ioRefusal(target, resolve(deps));
+    if (why) {
+      sendJson(
+        res,
+        { ok: false, error: why.error, code: why.code },
+        why.status,
+      );
+      return;
+    }
     res.setHeader("Upgrade", "websocket");
     res.setHeader("Connection", "Upgrade");
     sendJson(
@@ -444,16 +527,10 @@ export async function handleSessionUpgrade(
   const client = c;
   let info: SessionInfo | undefined;
   try {
-    const dist = d.dist();
     const active = new Set(d.activeWorkspaces());
-    info = (await client.list()).find((s) => {
-      const p = parseSessionName(s.name, dist);
-      return (
-        p !== null &&
-        active.has(p.workspace) &&
-        (s.ref.id === target || s.name === target)
-      );
-    });
+    info = (await client.list()).find((s) =>
+      servedSession(s, target, d, active),
+    );
   } catch (e) {
     client.close();
     return refuse(

package/src/ui/server/ui-assets.ts

@@ -46,6 +46,12 @@ export const UI_MODULES: readonly string[] = [
   // The UI's catalogs other than English (R19; en is in shell.js).
   "/i18n/ja.js",
   "/i18n/es.js",
+  // 0.4.17: one org and workspace rule for Environments and Releases.
+  "/view-scope.js",
+  // 0.4.18: the service panel (rail pins, Graph ⋯, Services names).
+  "/svc-panel.js",
+  // 0.4.18: where a service's live log comes from (Logs page and panel).
+  "/log-source.js",
 ];
 
 /** URL path → file inside node_modules. */