@monster-orange/den 0.1.0 → 0.2.1

package/src/ui/server/audit.ts

@@ -0,0 +1,137 @@
+/**
+ * The action audit trail: every service exec, test run and sync, with who
+ * asked (a person in the UI, or an agent through `<cli> mcp`). Each action
+ * becomes a lifecycle line in the server log, the stream the /logs page shows
+ * as the web-server log, so agent actions sit beside the UI's own; the
+ * structured entries are kept in a small in-memory ring.
+ */
+import {
+  actorLabel,
+  type Actor,
+  type AgentActor,
+} from "../../shared/agent-actor.js";
+
+export { actorFromHeaders } from "../../shared/agent-actor.js";
+
+export interface AuditEntry {
+  ts: string;
+  actor: "agent" | "user";
+  client?: string;
+  clientVersion?: string;
+  mcpPid?: number | null;
+  session?: string;
+  /** exec | run | sync, or the MCP tool name for a refused non-lifecycle call */
+  verb: string;
+  detail: string;
+  /** Set when the action never ran: a guard or the server refused it. */
+  outcome?: "refused";
+  /** Why it was refused (first line). */
+  reason?: string;
+}
+
+type Sink = (line: string, actor: AgentActor | null) => void;
+
+const RING_MAX = 200;
+const ring: AuditEntry[] = [];
+let sink: Sink | null = null;
+
+/** Where audit lines go (the server log); null to disconnect. */
+export function setAuditSink(fn: Sink | null): void {
+  sink = fn;
+}
+
+/** " · by agent …" for an agent, "" for a person. */
+export function actorSuffix(actor: Actor): string {
+  return actor ? ` · by ${actorLabel(actor)}` : "";
+}
+
+export function recordAction(
+  actor: Actor,
+  action: {
+    verb: string;
+    detail: string;
+    outcome?: "refused";
+    reason?: string;
+  },
+): AuditEntry {
+  const entry: AuditEntry = {
+    ts: new Date().toISOString(),
+    actor: actor ? "agent" : "user",
+    ...(actor
+      ? {
+          client: actor.client,
+          clientVersion: actor.clientVersion,
+          mcpPid: actor.mcpPid,
+          session: actor.session,
+        }
+      : {}),
+    verb: action.verb,
+    detail: action.detail,
+    ...(action.outcome ? { outcome: action.outcome } : {}),
+    ...(action.reason ? { reason: clean(action.reason, 300) } : {}),
+  };
+  ring.push(entry);
+  if (ring.length > RING_MAX) ring.shift();
+  const mark = entry.outcome === "refused" ? "✗" : "▶";
+  const why = entry.reason ? ` — refused: ${entry.reason}` : "";
+  sink?.(
+    `${mark} ${action.verb} ${action.detail}${why}${actorSuffix(actor)}`,
+    actor,
+  );
+  return entry;
+}
+
+/** One line, printable characters only, at most `max` long. */
+function clean(v: unknown, max: number): string {
+  const line = String(v ?? "").split(/[\r\n]/)[0];
+  return [...line]
+    .filter((c) => c.charCodeAt(0) >= 0x20 && c.charCodeAt(0) !== 0x7f)
+    .join("")
+    .slice(0, max);
+}
+
+const SAFE_PART = /^[A-Za-z0-9._-]{1,128}$/;
+const LIFECYCLE_TOOL = /^service_(up|down|restart)$/;
+
+/**
+ * An MCP guard refused an agent's call before it reached an action route.
+ * The agent's own report, so every field is sanitised: a lifecycle tool with
+ * a valid repo becomes an "exec" entry for that service (what the panel's
+ * activity list shows); anything else is recorded under the tool's name.
+ */
+export function recordAgentRefusal(
+  actor: Actor,
+  report: {
+    tool?: unknown;
+    repo?: unknown;
+    service?: unknown;
+    reason?: unknown;
+  },
+): AuditEntry {
+  const tool = clean(report.tool, 64).replace(/[^A-Za-z0-9_]/g, "") || "tool";
+  const repo = typeof report.repo === "string" ? report.repo : "";
+  const service = typeof report.service === "string" ? report.service : "";
+  const lifecycle = LIFECYCLE_TOOL.exec(tool);
+  const reason = clean(report.reason, 300) || "refused";
+  if (lifecycle && SAFE_PART.test(repo)) {
+    const address =
+      service && SAFE_PART.test(service) ? `${repo}/${service}` : repo;
+    return recordAction(actor, {
+      verb: "exec",
+      detail: `${address} ${lifecycle[1]} (local)`,
+      outcome: "refused",
+      reason,
+    });
+  }
+  return recordAction(actor, {
+    verb: tool,
+    detail: "",
+    outcome: "refused",
+    reason,
+  });
+}
+
+/** The most recent actions, oldest first. */
+export function recentActions(): AuditEntry[] {
+  return ring.slice();
+}

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

@@ -84,6 +84,17 @@ export function parseChangelog(raw: string): ChangelogEntry[] {
           line.replace(/^ {2}- /, "").trim(),
         );
       }
+    } else if (currentSection && /^ {2,}\S/.test(line)) {
+      // A wrapped continuation line: it belongs to the bullet (or sub-bullet)
+      // above it. Dropping it cut every multi-line bullet mid-sentence.
+      const bullets = current.sections[currentSection];
+      const last = bullets[bullets.length - 1];
+      if (last) {
+        const text = line.trim();
+        if (/^ {4,}/.test(line) && last.sub.length > 0)
+          last.sub[last.sub.length - 1] += " " + text;
+        else last.text += " " + text;
+      }
     }
   }
   if (current) {

package/src/ui/server/graph-prefs.ts

@@ -0,0 +1,89 @@
+/**
+ * Graph preferences: how the Local Dev graph is laid out for this engineer.
+ * Stored in the user config as `graph:` and served by /api/settings, so the
+ * layout is remembered between sessions (the page mirrors it to localStorage
+ * so the first paint does not wait on the server).
+ */
+
+export interface GraphPrefs {
+  /** Layout direction: top-down or left-right. */
+  direction: "down" | "right";
+  /** The outer frames: by org or by application. */
+  group: "org" | "app";
+  /** Card size: detailed (236×104) or compact (176×52). */
+  density: "detailed" | "compact";
+  /** Details panel width in px. */
+  panelWidth: number;
+}
+
+export const GRAPH_DEFAULTS: GraphPrefs = {
+  direction: "down",
+  group: "org",
+  density: "detailed",
+  panelWidth: 440,
+};
+
+const CHOICES = {
+  direction: ["down", "right"],
+  group: ["org", "app"],
+  density: ["detailed", "compact"],
+} as const;
+
+const PANEL_MIN = 360;
+const PANEL_MAX = 760;
+
+type Check = { ok: true; value: unknown } | { ok: false; error: string };
+
+function check(key: keyof GraphPrefs, v: unknown): Check {
+  if (key === "panelWidth") {
+    if (typeof v !== "number" || !Number.isFinite(v))
+      return { ok: false, error: panelError() };
+    const w = Math.round(v);
+    if (w < PANEL_MIN || w > PANEL_MAX)
+      return { ok: false, error: panelError() };
+    return { ok: true, value: w };
+  }
+  const allowed: readonly string[] = CHOICES[key];
+  if (typeof v !== "string" || !allowed.includes(v))
+    return {
+      ok: false,
+      error: `graph.${key} must be one of ${allowed.map((a) => `"${a}"`).join(", ")}`,
+    };
+  return { ok: true, value: v };
+}
+
+function panelError(): string {
+  return `graph.panelWidth must be a number from ${PANEL_MIN} to ${PANEL_MAX}`;
+}
+
+const isObject = (v: unknown): v is Record<string, unknown> =>
+  typeof v === "object" && v !== null && !Array.isArray(v);
+
+/** The stored block, normalised: a missing or hand-broken field is its default. */
+export function graphPrefs(stored: unknown): GraphPrefs {
+  const out: GraphPrefs = { ...GRAPH_DEFAULTS };
+  if (!isObject(stored)) return out;
+  for (const key of Object.keys(GRAPH_DEFAULTS) as (keyof GraphPrefs)[]) {
+    if (!(key in stored)) continue;
+    const c = check(key, stored[key]);
+    if (c.ok) (out as unknown as Record<string, unknown>)[key] = c.value;
+  }
+  return out;
+}
+
+/** Merge a POSTed (partial) block over the current prefs; any bad field fails it. */
+export function mergeGraphPrefs(
+  current: GraphPrefs,
+  patch: unknown,
+): { ok: true; value: GraphPrefs } | { ok: false; error: string } {
+  if (!isObject(patch)) return { ok: false, error: "graph must be an object" };
+  const out: GraphPrefs = { ...current };
+  for (const [key, v] of Object.entries(patch)) {
+    if (!(key in GRAPH_DEFAULTS))
+      return { ok: false, error: `unknown graph setting "${key}"` };
+    const c = check(key as keyof GraphPrefs, v);
+    if (!c.ok) return c;
+    (out as unknown as Record<string, unknown>)[key] = c.value;
+  }
+  return { ok: true, value: out };
+}

package/src/ui/server/health-row.ts

@@ -0,0 +1,15 @@
+/**
+ * The fields of a /api/health row that say what was checked. `url` is only
+ * ever a URL (or null): a shell check's command (a compose stack's
+ * `<cli> stack health …`, or any declared shell check) goes in `check`.
+ */
+export type HealthCheckType = "shell" | "http" | "none";
+
+export function healthCheckFields(
+  checkType: HealthCheckType,
+  target: string,
+): { url: string | null; check?: string } {
+  if (checkType === "shell") return { url: null, check: target };
+  if (checkType === "http") return { url: target };
+  return { url: null };
+}