@monster-orange/den 0.4.23 → 0.4.25

package/src/ui/cli/agent-ops.ts

@@ -256,6 +256,18 @@ export interface AgentsDeps extends SessionsDeps {
   userConfigFile?: () => string;
   /** D28: workspace `ws`'s services and their folders (the service scope). */
   workspaceServices?: (ws: string) => { address: string; path: string }[];
+  /**
+   * HUB-1.5: Den Hub's URL and this install's token (from its own store),
+   * or null when hub.url isn't set or the token can't be read (default:
+   * hub.* and the install's secrets backend).
+   */
+  hub?: () => Promise<{
+    url: string;
+    token: string;
+    allowTools?: boolean;
+  } | null>;
+  /** HUB-1.5: workspace `ws`'s repos as owner/repo (X-Den-Repos). */
+  workspaceRepos?: (ws: string) => string[];
 }
 
 export interface AgentsResolved extends Resolved {
@@ -272,6 +284,12 @@ export interface AgentsResolved extends Resolved {
   saveRuntimeBin: NonNullable<AgentsDeps["saveRuntimeBin"]>;
   userConfigFile: () => string;
   workspaceServices: (ws: string) => { address: string; path: string }[];
+  hub: () => Promise<{
+    url: string;
+    token: string;
+    allowTools?: boolean;
+  } | null>;
+  workspaceRepos: (ws: string) => string[];
 }
 
 /** The early-exit watch: at most this long, polling the host. */
@@ -327,6 +345,7 @@ let servicesFn: ((ws: string) => { address: string; path: string }[]) | null =
   null;
 let foldersFn: ((ws: string) => { under: string[]; exact?: string[] }) | null =
   null;
+let reposFn: ((ws: string) => string[]) | null = null;
 /** The workspaces config, for start and resume (loaded on first use). */
 export async function loadAgentWorkspaces(d: AgentsDeps): Promise<void> {
   await loadWorkspaces(d);
@@ -353,6 +372,50 @@ export async function loadAgentWorkspaces(d: AgentsDeps): Promise<void> {
       .listWorkspaceServices(cfg, readCatalog(), name)
       .map((r) => ({ address: r.address, path: r.repoPath }));
   };
+  const { ownerRepo } = await import("../../shared/hub.js");
+  reposFn = (name) => {
+    const cfg = ws.readWorkspacesFile().workspaces[name];
+    if (!cfg) return [];
+    const cat = readCatalog();
+    const out: string[] = [];
+    for (const r of ws.listWorkspaceServices(cfg, cat, name)) {
+      const slug = ownerRepo(cat[r.repoName]);
+      if (slug && !out.includes(slug)) out.push(slug);
+    }
+    return out;
+  };
+}
+
+/**
+ * HUB-1.5: Den Hub's MCP server for this agent, when hub.url is set and
+ * its token is readable: who calls (its name, a session id, the workspace
+ * and its repos), as headers. Hub sets the team and project from them.
+ */
+export async function agentHub(
+  d: AgentsResolved,
+  ws: string,
+  name: string,
+): Promise<AgentMcp["hub"] | undefined> {
+  const h = await d.hub().catch(() => null);
+  if (!h) return undefined;
+  const { HUB_SERVER, hubHeaders } = await import("../../shared/hub.js");
+  let repos: string[] = [];
+  try {
+    repos = d.workspaceRepos(ws);
+  } catch {
+    repos = [];
+  }
+  return {
+    name: HUB_SERVER,
+    url: h.url,
+    allowTools: h.allowTools !== false,
+    headers: hubHeaders(h.token, {
+      agent: name,
+      session: crypto.randomUUID(),
+      workspace: ws,
+      repos,
+    }),
+  };
 }
 
 /** The distribution's bin shim (as `mcp connect` registers), else Den's CLI. */
@@ -407,9 +470,29 @@ export function resolveAgentsDeps(d: AgentsDeps): AgentsResolved {
     userConfigFile: d.userConfigFile ?? userConfigPath,
     workspaceServices:
       d.workspaceServices ?? ((ws) => (servicesFn ? servicesFn(ws) : [])),
+    hub: d.hub ?? defaultHub,
+    workspaceRepos: d.workspaceRepos ?? ((ws) => (reposFn ? reposFn(ws) : [])),
   });
 }
 
+/** HUB-1.5: hub.* and the token from this install's store; null without. */
+async function defaultHub(): Promise<{
+  url: string;
+  token: string;
+  allowTools: boolean;
+} | null> {
+  const { readHubConfig, readHubToken } = await import("../../shared/hub.js");
+  let cfg;
+  try {
+    cfg = readHubConfig();
+  } catch {
+    return null; // a bad hub.* is doctor's and Settings' to say
+  }
+  if (!cfg) return null;
+  const token = await readHubToken(cfg);
+  return token ? { url: cfg.url, token, allowTools: cfg.allowTools } : null;
+}
+
 /**
  * ON-6: the server agent's scope is no workspace, but its agent is a
  * normal one: it "exists", and its folder is an empty one under the state
@@ -1799,11 +1882,29 @@ export async function startAgent(
     id,
     displayName: given ?? prev?.displayName ?? persona.displayName,
   });
-  const input = {
-    ...launchInput(d, cfg, persona, ws, id, model, det.path, undefined, {
+  const base = launchInput(
+    d,
+    cfg,
+    persona,
+    ws,
+    id,
+    model,
+    det.path,
+    undefined,
+    {
       ...(ch.permission ? { permission: ch.permission } : {}),
       ...(rt.permissions ? { allow } : {}),
-    }),
+    },
+  );
+  // HUB-1.5: Den Hub's MCP server, when hub.url is set.
+  const hub = await agentHub(
+    d,
+    ws,
+    given ?? prev?.displayName ?? persona.displayName ?? id,
+  );
+  const input = {
+    ...base,
+    ...(hub ? { mcp: { ...base.mcp, hub } } : {}),
     sessionLabel: peerName,
     ...(more.firstPrompt ? { firstPrompt: more.firstPrompt } : {}),
     // 0.4.18: Start agent here: in a folder of the workspace's.
@@ -2342,8 +2443,10 @@ export async function resumeAgent(
     // Resume in the cwd the agent had, wherever the workspace points now.
     // D24 (and D25: a rename since) the name peers see it by.
     const peerName = peerSessionName(d.cli, rec.workspace, rec);
+    const hub = await agentHub(d, rec.workspace, rec.displayName ?? rec.id);
     const at = {
       ...input,
+      ...(hub ? { mcp: { ...input.mcp, hub } } : {}),
       sessionLabel: peerName,
       worktree: rec.cwd,
       ...(rec.resumeToken ? { resumeToken: rec.resumeToken } : {}),
@@ -3369,6 +3472,71 @@ export async function resumeOrRelaunch(
 }
 
 /** D28: the rotation settings, and agent `agent`'s effective values. */
+/** D30: what the rotation overrides can name, with names to show. */
+export interface RotationChoices {
+  agents: { id: string; name: string; workspace?: string; state: string }[];
+  personas: { id: string; name: string; category: string }[];
+  workspaces: { id: string; name: string }[];
+  services: { id: string; name: string; workspace: string }[];
+}
+
+/**
+ * D30: the overrides form's pickers: every agent (its name, workspace and
+ * state), persona (name and category), workspace and workspace service.
+ * Never starts a session host to ask (a stopped one: agents from their
+ * records). A part that can't be read is empty, not an error.
+ */
+export async function rotationChoices(
+  d: AgentsResolved,
+  workspaces: string[],
+): Promise<RotationChoices> {
+  let sessions: SessionInfo[] = [];
+  try {
+    const c = await d.connectExisting();
+    try {
+      sessions = c ? await c.list() : [];
+    } finally {
+      c?.close();
+    }
+  } catch {
+    sessions = [];
+  }
+  const records = listRecords(d.stateDir());
+  const agents = agentRows(sessions, records, d.stateDir())
+    .filter((r) => r.agent)
+    .map((r) => ({
+      id: r.agent,
+      name: r.displayName || r.sessionTitle || r.agent,
+      ...(r.workspace ? { workspace: r.workspace } : {}),
+      state: r.state,
+    }));
+  let personaList: RotationChoices["personas"] = [];
+  try {
+    personaList = listPersonas(d).map((p) => ({
+      id: p.id,
+      name: p.displayName ? `${p.displayName} (${p.id})` : p.id,
+      category: p.category,
+    }));
+  } catch {
+    personaList = [];
+  }
+  const services: RotationChoices["services"] = [];
+  for (const ws of workspaces)
+    try {
+      for (const sv of d.workspaceServices(ws))
+        if (!services.some((x) => x.id === sv.address))
+          services.push({ id: sv.address, name: sv.address, workspace: ws });
+    } catch {
+      /* a workspace whose services can't be read: none */
+    }
+  return {
+    agents,
+    personas: personaList,
+    workspaces: workspaces.map((w) => ({ id: w, name: w })),
+    services,
+  };
+}
+
 export function rotationSettings(
   d: AgentsResolved,
   agent?: string,

package/src/ui/cli/doctor-command.ts

@@ -69,11 +69,13 @@ import { printJson } from "./json-out.js";
 import { ownerCheck, ownerLine } from "./doctor-owner.js";
 import {
   formatWhere,
+  launchdJobPid,
   serviceJobState,
   whereRows,
   type WhereDeps,
   type WhereRow,
 } from "./doctor-where.js";
+import { hostLabel } from "./service-command.js";
 
 export interface DoctorRow {
   kind: string;
@@ -420,6 +422,8 @@ export async function defaultWhereDeps(): Promise<WhereDeps> {
       try {
         return {
           launchd: c.hostLaunchd,
+          pid: c.hostPid,
+          startedAt: c.hostStartedAt || undefined,
           access: await c.access().catch(() => null),
         };
       } finally {
@@ -438,6 +442,24 @@ export async function defaultWhereDeps(): Promise<WhereDeps> {
         return null;
       }
     },
+    hostJob: () => {
+      try {
+        const { label } = readWebServiceConfig(
+          cfg(),
+          getDistRoot(),
+          os.homedir(),
+        );
+        const host = hostLabel(label);
+        const job = serviceJobState(
+          host,
+          os.homedir(),
+          process.getuid?.() ?? 0,
+        );
+        return job?.state === "loaded" ? launchdJobPid(job.domain, host) : null;
+      } catch {
+        return null;
+      }
+    },
   };
 }
 
@@ -445,11 +467,39 @@ export async function defaultWhereDeps(): Promise<WhereDeps> {
 export function whereCheck(r: WhereRow): OnboardCheck {
   return {
     id: `where:${r.what.replace(" ", "-")}`,
-    status: r.status,
+    // info is as chosen: not a problem.
+    status: r.status === "info" ? "ok" : r.status,
     detail: `${r.session}${r.detail ? `: ${r.detail}` : ""}`,
   };
 }
 
+/**
+ * HUB-1.5: doctor's Hub row, or none when hub.url isn't set. Never the
+ * token: hubStatus doesn't have it to give.
+ */
+export function hubLines(
+  st: import("../../shared/hub.js").HubStatus,
+  title: string,
+): { lines: string[]; problem: boolean; check?: OnboardCheck } {
+  if (!st.configured) return { lines: [], problem: false };
+  const who = [st.team && `team ${st.team}`, st.label && `install ${st.label}`]
+    .filter(Boolean)
+    .join(", ");
+  const detail = st.connected
+    ? `${st.url}: connected${who ? ` (${who})` : ""}`
+    : `${st.url || "hub.url"}: not connected: ${st.problem ?? "no answer"}`;
+  return {
+    lines: [
+      "",
+      `${title} doctor: Hub`,
+      "",
+      `  hub  ${st.connected ? "✓" : "⚠"}  ${detail}`,
+    ],
+    problem: false, // a Hub that is down never fails doctor: agents still run
+    check: { id: "hub", status: st.connected ? "ok" : "warn", detail },
+  };
+}
+
 export async function cmdDoctor(args: string[]): Promise<number> {
   const probe = args.includes("--probe");
   const json = args.includes("--json");
@@ -481,6 +531,11 @@ export async function cmdDoctor(args: string[]): Promise<number> {
     r.checks.push(
       ...(await whereRows(await defaultWhereDeps())).map(whereCheck),
     );
+    {
+      const { hubStatus } = await import("../../shared/hub.js");
+      const h = hubLines(await hubStatus(), readBrand().name);
+      if (h.check) r.checks.push(h.check);
+    }
     printJson(r);
     return r.ok ? 0 : 1;
   }
@@ -499,6 +554,12 @@ export async function cmdDoctor(args: string[]): Promise<number> {
     readBrand().name,
   ))
     console.log(l);
+  {
+    // HUB-1.5: only when hub.url is set.
+    const { hubStatus } = await import("../../shared/hub.js");
+    for (const l of hubLines(await hubStatus(), readBrand().name).lines)
+      console.log(l);
+  }
   for (const l of pollingLines(eventsFile(), readBrand().name)) console.log(l);
   const cli = product().cli;
   if (!probe) {

package/src/ui/cli/doctor-where.ts

@@ -41,15 +41,22 @@ export interface WhereDeps {
   /** The running session host's; null when none runs. */
   host: () => Promise<{
     launchd: string | null;
+    /** The pid that answers on the socket. */
+    pid?: number;
+    /** When it started (ISO). */
+    startedAt?: string;
     access?: { exe: string; fullDiskAccess: boolean | null } | null;
   } | null>;
   service: () => ServiceJob | null;
+  /** The service's own host job's pid (it may stand by), or null. */
+  hostJob?: () => number | null;
 }
 
 export interface WhereRow {
   what: "server" | "session host" | "full disk access" | "service";
   session: string;
-  status: "ok" | "warn";
+  /** info: as chosen, worth knowing (login mode ends at logout). */
+  status: "ok" | "info" | "warn";
   detail?: string;
 }
 
@@ -57,12 +64,15 @@ function sessionRow(
   what: "server" | "session host",
   launchd: string | null | undefined,
   cli: string,
+  loginChosen = false,
 ): WhereRow {
   const session = launchd || "unknown";
   return {
     what,
     session,
-    status: endsAtLogout(launchd) ? "warn" : "ok",
+    // The service installed in login mode: ending at logout is what was
+    // chosen (the default), so it is said, not warned about.
+    status: endsAtLogout(launchd) ? (loginChosen ? "info" : "warn") : "ok",
     ...(sessionWarning(launchd, cli, what)
       ? { detail: sessionWarning(launchd, cli, what)! }
       : {}),
@@ -72,10 +82,12 @@ function sessionRow(
 export async function whereRows(d: WhereDeps): Promise<WhereRow[]> {
   if (d.platform !== "darwin") return [];
   const rows: WhereRow[] = [];
+  const svc = d.service();
+  const loginChosen = svc?.mode === "login" && svc.state !== "not-loaded";
   const server = await d.server().catch(() => null);
   rows.push(
     server
-      ? sessionRow("server", server.launchd, d.cli)
+      ? sessionRow("server", server.launchd, d.cli, loginChosen)
       : {
           // Not started yet is not a problem (a fresh install).
           what: "server",
@@ -85,15 +97,39 @@ export async function whereRows(d: WhereDeps): Promise<WhereRow[]> {
         },
   );
   const host = await d.host().catch(() => null);
+  const jobPid = host ? (d.hostJob?.() ?? null) : null;
+  // The service's host stands by while another host holds the socket, and
+  // takes over when that one exits: nothing to do.
+  const standsBy =
+    jobPid !== null && host?.pid !== undefined && jobPid !== host.pid;
+  const since = host?.startedAt ? `, since ${host.startedAt.slice(0, 10)}` : "";
+  const older = `an older session host (pid ${host?.pid ?? "?"}${since})`;
+  const switchNow = `To switch now (ends running terminals and agents): ${d.cli} sessions host --stop`;
   rows.push(
-    host
-      ? sessionRow("session host", host.launchd, d.cli)
-      : {
+    host && standsBy
+      ? {
           what: "session host",
-          session: "not running",
-          status: "ok",
-          detail: "it starts when the first terminal or agent does",
-        },
+          session: host.launchd || `older host (pid ${host.pid})`,
+          status: "info",
+          detail: `${older} is serving; the service's host (pid ${jobPid}) takes over when it exits. Nothing to do. ${switchNow}`,
+        }
+      : host && !host.launchd
+        ? {
+            // An older host and no service host behind it: from an earlier
+            // version, so it can't say where it runs. Nothing is wrong.
+            what: "session host",
+            session: `older host${host.pid ? ` (pid ${host.pid})` : ""}`,
+            status: "info",
+            detail: `${older} is serving, from before this version, so it can't say whether its terminals and agents stop at logout. It picks up this version the next time it exits. Nothing to do. ${switchNow}`,
+          }
+        : host
+          ? sessionRow("session host", host.launchd, d.cli, loginChosen)
+          : {
+              what: "session host",
+              session: "not running",
+              status: "ok",
+              detail: "it starts when the first terminal or agent does",
+            },
   );
   const fda = host?.access;
   if (fda && fda.fullDiskAccess !== null) {
@@ -116,7 +152,6 @@ export async function whereRows(d: WhereDeps): Promise<WhereRow[]> {
           },
     );
   }
-  const svc = d.service();
   if (!svc)
     rows.push({
       what: "service",
@@ -145,6 +180,17 @@ export async function whereRows(d: WhereDeps): Promise<WhereRow[]> {
   return rows;
 }
 
+/** The pid launchd runs `<domain>/<label>` as, or null (launchctl print). */
+export function launchdJobPid(domain: string, label: string): number | null {
+  const r = spawnSync("launchctl", ["print", `${domain}/${label}`], {
+    encoding: "utf-8",
+    timeout: 3000,
+  });
+  if (r.status !== 0) return null;
+  const m = /^\s*pid = (\d+)/m.exec(r.stdout ?? "");
+  return m ? Number(m[1]) : null;
+}
+
 export interface JobProbe {
   exists: (p: string) => boolean;
   /** `launchctl print <domain>/<label>`'s exit status (127: no launchctl). */
@@ -195,9 +241,10 @@ export function formatWhere(rows: WhereRow[], title: string): string[] {
   const lines = ["", `${title} doctor: where it runs`, ""];
   const w = Math.max(...rows.map((r) => r.session.length));
   for (const r of rows) {
-    const mark = r.status === "ok" ? "✓" : "⚠";
+    const mark = r.status === "ok" ? "✓" : r.status === "info" ? "ℹ" : "⚠";
     lines.push(`  ${r.what.padEnd(16)}  ${r.session.padEnd(w)}  ${mark}`);
-    if (r.detail) lines.push(`    ${r.status === "ok" ? "" : "⚠ "}${r.detail}`);
+    if (r.detail)
+      lines.push(`    ${r.status === "warn" ? "⚠ " : ""}${r.detail}`);
   }
   return lines;
 }

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

@@ -138,6 +138,7 @@ import {
   resumeOrRelaunch,
   keepAgentConversation,
   askForHandoff,
+  rotationChoices,
   rotationSettings,
   setRotationSetting,
   rotationTick,
@@ -172,6 +173,8 @@ export interface AgentRouteDeps {
   instruction?: { quietMs?: number; maxMs?: number };
   /** AG-18: how "after this turn" polls (tests: shorter). */
   personaWait?: { pollMs?: number; maxMs?: number };
+  /** HUB-1.5: GET /api/hub's answer (tests: a fake Hub). */
+  hubStatus?: () => Promise<import("../../shared/hub.js").HubStatus>;
 }
 
 const AGENTS_PATH =
@@ -425,6 +428,15 @@ export async function handleAgentRoutes(
     pathname === "/api/agents/resume-interrupted";
   if (pathname === "/api/agents/rotation")
     return rotationRoute(req, res, webDeps(deps.agents));
+  // HUB-1.5: Settings › Hub. Never the token: hubStatus doesn't return it.
+  if (pathname === "/api/hub") {
+    const method = req.method ?? "GET";
+    if (method !== "GET" && method !== "HEAD")
+      return methodNotAllowed(res, "GET");
+    const { hubStatus } = await import("../../shared/hub.js");
+    sendJson(res, await (deps.hubStatus ?? (() => hubStatus()))());
+    return true;
+  }
   if (
     pathname !== "/api/personas" &&
     pathname !== "/api/agents/runtimes" &&
@@ -1328,7 +1340,18 @@ async function rotationRoute(
       const agent = q.get("agent") ?? undefined;
       if ((ws && !NAME_RE.test(ws)) || (agent && !NAME_RE.test(agent)))
         throw new AgentError("not a name", { usage: true });
-      sendJson(res, rotationSettings(d, agent, ws));
+      // D30: ?choices=1 adds what the overrides form can pick, by name.
+      sendJson(res, {
+        ...rotationSettings(d, agent, ws),
+        ...(q.get("choices") === "1"
+          ? {
+              choices: await rotationChoices(
+                d,
+                Object.keys(readWorkspacesFile().workspaces ?? {}),
+              ),
+            }
+          : {}),
+      });
       return true;
     }
     if (method !== "PUT") return methodNotAllowed(res, "GET, PUT");

package/src/ui/server/index.ts

@@ -283,6 +283,7 @@ import {
 } from "../../shared/cli-command.js";
 import { graphPrefs, patchStoredGraph } from "./graph-prefs.js";
 import { agentsLayout, patchAgentsLayout } from "./agents-layout-pref.js";
+import { patchHubAllowTools } from "../../shared/hub.js";
 import { editorOpen, patchEditorOpen } from "./editor-open-pref.js";
 import { graphPageHtml } from "./graph-page.js";
 import { mergeShellPrefs, shellPrefs, storedShell } from "./shell-prefs.js";
@@ -5017,6 +5018,8 @@ async function handleRequest(
   //     pane opens (AG-4b, editor-open-pref.ts); null clears it (none)
   //   language: the UI's language, en | ja | es (ui-language.ts); null or
   //     "en" clears it (English is the default)
+  //   hub_allow_tools: true | false, hub.allow_tools (HUB-1.5: agents use
+  //     Hub's tools without asking); null clears it (on)
   // It writes config/local/user.yml only. `distribution` is read-only: what
   // the org config (tracked) sets, for the Settings page's Distribution rows.
   // Every key POST accepts has a row in the Settings page's registry
@@ -5091,8 +5094,18 @@ async function handleRequest(
           machine_name?: unknown;
           agents_layout?: unknown;
           editor_open?: unknown;
+          hub_allow_tools?: unknown;
         };
         const user = readUserConfig();
+        // HUB-1.5: hub.allow_tools, Hub's tools without asking (Settings ›
+        // Agents › Hub); null clears it (the default, on).
+        if (body.hub_allow_tools !== undefined) {
+          const h = patchHubAllowTools(
+            user as Record<string, unknown>,
+            body.hub_allow_tools,
+          );
+          if (!h.ok) return send400(res, h.error);
+        }
         // AG-4b: the Agents tab's layout, a view preference only.
         if (body.agents_layout !== undefined) {
           const l = patchAgentsLayout(user, body.agents_layout);