@monster-orange/den 0.4.17 → 0.4.19

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

@@ -885,6 +885,8 @@ function paletteItems() {
     });
   }
   for (const x of palSessions) {
+    // ON-6: the server agent is "Ask <name>" below, not a workspace's.
+    if (x.server) continue;
     // AG-4b: the name a person gave the agent, else its persona.
     const base =
       x.kind === "agent" ? x.displayName || (x.persona ?? x.label) : x.label;
@@ -923,7 +925,7 @@ function paletteItems() {
   for (const ws of s?.workspaceNames?.() ?? [])
     if (!byWs.has(ws)) byWs.set(ws, []);
   for (const x of palSessions) {
-    if (!x.workspace) continue;
+    if (!x.workspace || x.server) continue;
     const names = byWs.get(x.workspace) ?? [];
     names.push(x.label, x.displayName ?? "", x.persona ?? "");
     byWs.set(x.workspace, names);
@@ -947,6 +949,16 @@ function paletteItems() {
       keywords: ["agents", "start", "persona"],
       run: () => go("/agents?start=1"),
     });
+  // ON-6: Ask <name>, the server agent's page.
+  const ask = s?.nav?.().find((n) => n.id === "server-agent");
+  if (ask)
+    items.push({
+      key: "agent:ask-server",
+      kind: "action",
+      label: t("pal.askServer"),
+      keywords: ["ask", "server agent", "agent", "help", "setup"],
+      run: () => go(ask.href),
+    });
   for (const c of s?.commands?.() ?? [])
     items.push({
       key: `cmd:${c.id}`,

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

@@ -73,6 +73,8 @@ export const ROUTES: readonly RouteEntry[] = [
     "/graph.html",
     "/agents",
     "/agents.html",
+    "/server-agent",
+    "/server-agent.html",
     "/tests",
     "/index.html",
     "/services",
@@ -174,6 +176,10 @@ export const ROUTES: readonly RouteEntry[] = [
     "/api/sessions",
     "lists the sessions and agents (names and states, never their output)",
   ),
+  R(
+    "/api/server-agent",
+    "the server agent's name, runtime and state (ON-6): reads only",
+  ),
   R("/api/health", "runs the manifests' health probes: read-only checks"),
   R("/api/test-sources", "git rev-parse in each repo: read-only"),
   R("/api/manifest/validate", "GET validates a file at a path: read-only"),
@@ -389,6 +395,21 @@ export const ROUTES: readonly RouteEntry[] = [
     "/api/workspaces/:ws/agents",
     "starts an agent: a runtime in a PTY",
   ),
+  S(
+    ["POST"],
+    "/api/server-agent/start",
+    "starts the server agent (ON-6): a runtime in a PTY; never an agent's token",
+  ),
+  M(
+    ["POST"],
+    "/api/server-agent/runtime",
+    "the person's choice of the server agent's runtime (user.yml); never an agent's token",
+  ),
+  M(
+    ["POST"],
+    "/api/server-agent/model",
+    "the person's choice of the server agent's model (user.yml); never an agent's token",
+  ),
   S(
     ["POST"],
     "/api/workspaces/:ws/conversations/:id/import",

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

@@ -0,0 +1,176 @@
+/**
+ * The server agent's routes (ON-6):
+ *
+ *   GET  /api/server-agent          what it is, its runtime (or why none),
+ *                                   whether it runs, whether this Den is
+ *                                   fresh, and the manual path
+ *   POST /api/server-agent/start    { runtime? }: start it, or bring it
+ *                                   back (resume, relaunch); a person only
+ *   POST /api/server-agent/runtime  { runtime: id | null }: the person's
+ *                                   choice (user.yml agents.server_runtime)
+ *   POST /api/server-agent/model    { model: id | null }: the person's
+ *                                   model, one of the runtime's own
+ *                                   (user.yml agents.server_model)
+ *
+ * An agent never starts the server agent or picks its runtime: any agent
+ * credential or claim is refused (403).
+ */
+import type * as http from "http";
+import { HostError } from "../../shared/sessions/client.js";
+import { AgentError, type AgentsDeps } from "../cli/agent-ops.js";
+import {
+  serverAgentStatus,
+  setServerModel,
+  setServerRuntime,
+  startServerAgent,
+  type ServerAgentDeps,
+} from "../cli/server-agent-ops.js";
+import { webDeps } from "./agent-routes.js";
+import { recordAction } from "./audit.js";
+import { readBody, sendJson } from "./http-helpers.js";
+import {
+  agentPrincipalOf,
+  auditActorOf,
+  principalOf,
+} from "./request-guard.js";
+
+export interface ServerAgentRouteDeps {
+  agents?: AgentsDeps;
+  server?: ServerAgentDeps;
+}
+
+const MAX_BODY = 4 * 1024;
+
+function sendError(res: http.ServerResponse, e: unknown): void {
+  if (e instanceof AgentError) {
+    sendJson(
+      res,
+      {
+        ok: false,
+        error: e.message,
+        ...(e.code ? { code: e.code } : {}),
+        ...(e.hints.length ? { hints: e.hints } : {}),
+      },
+      e.status,
+    );
+    return;
+  }
+  if (e instanceof HostError) {
+    sendJson(res, { ok: false, error: e.message, code: "session_host" }, 503);
+    return;
+  }
+  sendJson(res, { ok: false, error: (e as Error).message }, 500);
+}
+
+async function body(
+  req: http.IncomingMessage,
+): Promise<{ runtime?: unknown; model?: unknown }> {
+  const raw = await readBody(req);
+  if (raw.length > MAX_BODY)
+    throw new AgentError("body too large", { status: 413 });
+  if (!raw.trim()) return {};
+  let b: unknown;
+  try {
+    b = JSON.parse(raw);
+  } catch {
+    throw new AgentError("body must be JSON", { usage: true });
+  }
+  if (!b || typeof b !== "object" || Array.isArray(b))
+    throw new AgentError("body must be an object", { usage: true });
+  return b as { runtime?: unknown; model?: unknown };
+}
+
+export async function handleServerAgentRoutes(
+  req: http.IncomingMessage,
+  res: http.ServerResponse,
+  pathname: string,
+  deps: ServerAgentRouteDeps = {},
+): Promise<boolean> {
+  if (
+    pathname !== "/api/server-agent" &&
+    pathname !== "/api/server-agent/start" &&
+    pathname !== "/api/server-agent/runtime" &&
+    pathname !== "/api/server-agent/model"
+  )
+    return false;
+  const method = req.method ?? "GET";
+  const d = webDeps(deps.agents);
+  if (pathname === "/api/server-agent") {
+    if (method !== "GET" && method !== "HEAD") {
+      res.setHeader("Allow", "GET");
+      sendJson(res, { ok: false, error: "method not allowed" }, 405);
+      return true;
+    }
+    try {
+      sendJson(res, await serverAgentStatus(d, deps.server));
+    } catch (e) {
+      sendError(res, e);
+    }
+    return true;
+  }
+  if (method !== "POST") {
+    res.setHeader("Allow", "POST");
+    sendJson(res, { ok: false, error: "method not allowed" }, 405);
+    return true;
+  }
+  const actor = auditActorOf(req);
+  const verb = pathname.endsWith("/start")
+    ? "start"
+    : pathname.endsWith("/model")
+      ? "model"
+      : "runtime";
+  const audit = (detail: string, reason?: string) =>
+    recordAction(
+      actor,
+      {
+        verb: "server-agent",
+        detail,
+        ...(reason ? { outcome: "refused" as const, reason } : {}),
+      },
+      principalOf(req),
+    );
+  try {
+    // The person's: an agent's credential, or a claim to be one, never.
+    if (agentPrincipalOf(req) || actor)
+      throw new AgentError(
+        "only a person can start the server agent or pick its runtime or model",
+        { status: 403 },
+      );
+    const b = await body(req);
+    if (
+      b.runtime !== undefined &&
+      b.runtime !== null &&
+      typeof b.runtime !== "string"
+    )
+      throw new AgentError("runtime must be a runtime id", { usage: true });
+    if (verb === "model") {
+      if (b.model !== null && typeof b.model !== "string")
+        throw new AgentError("model must be a model id or null", {
+          usage: true,
+        });
+      const id = (b.model as string | null) ?? null;
+      await setServerModel(d, id, deps.server);
+      audit(id ? `model ${id}` : "model cleared");
+      sendJson(res, { ok: true, ...(await serverAgentStatus(d, deps.server)) });
+      return true;
+    }
+    if (verb === "runtime") {
+      const id = (b.runtime as string | null | undefined) ?? null;
+      setServerRuntime(id, deps.server);
+      audit(id ? `runtime ${id}` : "runtime cleared");
+      sendJson(res, { ok: true, ...(await serverAgentStatus(d, deps.server)) });
+      return true;
+    }
+    const s = await startServerAgent(
+      d,
+      typeof b.runtime === "string" ? { runtime: b.runtime } : {},
+      deps.server,
+    );
+    audit(`${s.how} on ${s.runtime}`);
+    sendJson(res, { ok: true, ...s });
+  } catch (e) {
+    audit(verb, (e as Error).message);
+    sendError(res, e);
+  }
+  return true;
+}

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

@@ -35,6 +35,10 @@
  * with the actor from the credential.
  */
 import type * as http from "http";
+import {
+  SERVER_SCOPE,
+  isServerScope,
+} from "../../shared/agents/server-agent.js";
 import type { Duplex } from "stream";
 import {
   getActiveWorkspaces,
@@ -136,6 +140,8 @@ export interface ListedSession {
   /** `<dist>-<ws>:<name>`. */
   name: string;
   workspace: string;
+  /** ON-6: the server agent's row (its workspace is the server scope). */
+  server?: boolean;
   kind: "agent" | "session";
   /** The `<name>` part: an agent's id, a plain session's name. */
   label: string;
@@ -204,6 +210,8 @@ export function listedSessions(
   const dist = d.dist();
   const active = new Set(d.activeWorkspaces());
   if (also) active.add(also);
+  // ON-6: the server agent belongs to no workspace, and is always listed.
+  active.add(SERVER_SCOPE);
   const mine = sessions.filter((s) => {
     const p = parseSessionName(s.name, dist);
     return p !== null && active.has(p.workspace);
@@ -224,6 +232,7 @@ export function listedSessions(
       id: s?.ref.id ?? rec.session.id,
       name: s?.name ?? rec.sessionName,
       workspace: rec.workspace,
+      ...(isServerScope(rec.workspace) ? { server: true } : {}),
       kind: "agent",
       label: rec.id,
       agent: rec.id,
@@ -376,7 +385,9 @@ function servedSession(
   const p = parseSessionName(s.name, d.dist());
   return (
     p !== null &&
-    (active.has(p.workspace) || d.workspaceExists(p.workspace)) &&
+    (active.has(p.workspace) ||
+      isServerScope(p.workspace) ||
+      d.workspaceExists(p.workspace)) &&
     (s.ref.id === target || s.name === target)
   );
 }

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

@@ -48,6 +48,12 @@ export const UI_MODULES: readonly string[] = [
   "/i18n/es.js",
   // 0.4.17: one org and workspace rule for Environments and Releases.
   "/view-scope.js",
+  // ON-6: the server agent's page.
+  "/server-agent-page.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. */

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

@@ -7,6 +7,7 @@
  */
 
 import { hasRuntime, repoKind } from "../../shared/repo-kind.js";
+import { reservedWorkspaceError } from "../../shared/agents/server-agent.js";
 import { loadApplicationTree } from "../../shared/environment-manager/load-applications.js";
 import { localCommandsFor } from "../../shared/stacks/manifest-commands.js";
 import * as http from "http";
@@ -358,6 +359,8 @@ export function workspaceCreateRefusal(
   if (/["'\\/<>\x00-\x1f]/.test(name))
     return "name must not contain quotes, slashes, or control characters";
   if (name.length > 64) return "name must be 64 characters or fewer";
+  const reserved = reservedWorkspaceError(name);
+  if (reserved) return reserved;
   if (readWorkspacesFile().workspaces[name])
     return `workspace "${name}" already exists`;
   return null;