@monster-orange/den 0.4.6 → 0.4.8

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

@@ -511,7 +511,35 @@
     "ag.cancel": "Cancel",
     "ag.started": "Started agent {id}",
     "ag.stopped": "Stopped agent {id}",
+    "ag.stillStopping": "{id} is still stopping",
+    "ag.resumedFresh": "{id}: nothing to resume yet; started fresh",
+    "ag.inactive": "Workspace {ws} isn't active",
+    "ag.switchWs": "Switch to {ws}",
+    "ag.unknownWs": "(no workspace has that name)",
     "ag.resumed": "Resumed agent {id}",
+    "ag.state.interrupted": "interrupted",
+    "ag.why.stopped": "Stopped by you {time}",
+    "ag.why.interrupted": "Interrupted: {name} restarted",
+    "ag.why.exited": "Exited",
+    "ag.why.exitedCode": "Exited (code {code})",
+    "ag.fresh": "Start fresh",
+    "ag.freshName": "Start {id} fresh",
+    "ag.startedFresh": "Started {id} fresh",
+    "ag.remove": "Remove",
+    "ag.removeName": "Remove {id}",
+    "ag.removed": "Removed {id}",
+    "ag.removedMany": "Removed {n} stopped agents",
+    "ag.removedMany.one": "Removed {n} stopped agent",
+    "ag.undo": "Undo",
+    "ag.restored": "Back in the list: {ids}",
+    "ag.clear": "Clear stopped",
+    "ag.noResume": "{runtime} can't resume a conversation",
+    "ag.interrupted": "{n} agents were interrupted when {name} restarted",
+    "ag.interrupted.one": "{n} agent was interrupted when {name} restarted",
+    "ag.resumeAll": "Resume all",
+    "ag.review": "Review",
+    "ag.resumedAll": "Resumed {n} agents",
+    "ag.resumedAll.one": "Resumed {n} agent",
     // The Agents tab (AG-4a-term, agents-page.js).
     "n.agents": "Agents",
     "kind.agent": "Agent",
@@ -1116,6 +1144,42 @@
       if (el.remove) el.remove();
     }, 2200);
   }
+  /**
+   * A toast with one action (AG-14.1b: Remove's Undo): the message and a
+   * small button, for `ms` (default 10 s). The action runs once, and the
+   * toast goes.
+   */
+  function toastAction(msg, label, onAction, ms) {
+    if (!document.body || !document.createElement) return null;
+    var old = document.querySelector && document.querySelector(".den-toast");
+    if (old && old.remove) old.remove();
+    var el = document.createElement("div");
+    el.className = "den-toast den-toast-act";
+    el.setAttribute("role", "status");
+    var text = document.createElement("span");
+    text.textContent = msg;
+    var b = document.createElement("button");
+    b.type = "button";
+    b.className = "den-tbtn";
+    b.textContent = label;
+    var done = false;
+    b.addEventListener("click", function () {
+      if (done) return;
+      done = true;
+      clearTimeout(toastTimer);
+      el.remove();
+      onAction();
+    });
+    el.appendChild(text);
+    el.appendChild(b);
+    document.body.appendChild(el);
+    clearTimeout(toastTimer);
+    toastTimer = setTimeout(function () {
+      done = true;
+      if (el.remove) el.remove();
+    }, ms || 10000);
+    return el;
+  }
 
   // ── menus (.pop, R18): the scope parts' popovers ─────────────────────
   // A menu is { label, items: [{ heading } | { hr: true } | { label, tag?,
@@ -3776,6 +3840,7 @@
     unpin: unpin,
     isPinned: isPinned,
     toast: toast,
+    toastAction: toastAction,
     /** R26c: a call that resolves with its data or throws a DenApiError. */
     api: api,
     /** R26c: the error toast for a DenApiError (what an uncaught one gets). */
@@ -4168,6 +4233,7 @@
     // the prototype's small buttons (.btn.sm).
     ".den-toast-err { display: flex; align-items: center; gap: 10px; max-width: min(640px, calc(100vw - 32px));",
     "  border-color: color-mix(in srgb, var(--bad) 45%, var(--border-strong)); }",
+    ".den-toast-act { display: flex; align-items: center; gap: 10px; max-width: min(640px, calc(100vw - 32px)); }",
     ".den-toast-err .den-te-ic { color: var(--bad); }",
     ".den-toast-err .den-te-msg { display: flex; flex-direction: column; min-width: 0; overflow-wrap: anywhere; }",
     ".den-toast-err .den-te-id { font: 11px var(--mono); color: var(--faint); }",

package/src/ui/server/request-guard.ts

@@ -17,7 +17,9 @@
  *    and sign-in (/api/web/*, /auth, /api/session/logout), the lock (R8:
  *    /api/sudo-password*), or a shell-grade route other than its own
  *    session's /api/sessions/<id>/*: agent start and resume mint tokens.
- *    403 `agent_forbidden`. WS-3a (0.4.2) adds the workspace check at
+ *    403 `agent_forbidden`. One exception (AG-14.4): MCP agent_resume,
+ *    when mcp.actions lists it, for another agent of its own workspace
+ *    or a granted one (agent-resume-grant.ts). WS-3a (0.4.2) adds the workspace check at
  *    agentRefusal's seam.
  *  - Sign-in (§4, route-classes.ts): beyond loopback (a LAN name, a peer
  *    that isn't loopback, or the edge hostname for a client on another
@@ -58,6 +60,8 @@
  */
 import { randomBytes, timingSafeEqual, createHash } from "crypto";
 import type * as http from "http";
+import { readMcpConfig } from "../../shared/den-config.js";
+import { agentResumeRefusal, agentResumeTarget } from "./agent-resume-grant.js";
 import * as net from "net";
 import * as os from "os";
 import {
@@ -707,11 +711,27 @@ export function agentRefusal(
     if (id === p.session.id || id === p.session.name) return null;
     return `${p.actor} can use its own session only, not ${id}.`;
   }
+  // AG-14.4: MCP agent_resume, opted in, inside the agent's scope.
+  const target = method === "POST" ? agentResumeTarget(pathname) : null;
+  if (target)
+    return (
+      agentResumeRefusal(p, target.ws, target.id, mcpActions()) ??
+      workspaceRefusal(p, pathname)
+    );
   if (cls === "shell-grade")
     return `${p.actor} can't ${method === "GET" ? "open" : "use"} ${pathname}: starting or resuming an agent, and the browser sessions, are a person's.`;
   return workspaceRefusal(p, pathname);
 }
 
+/** The org config's mcp.actions; none when it can't be read. */
+function mcpActions(): readonly string[] {
+  try {
+    return readMcpConfig().actions;
+  } catch {
+    return [];
+  }
+}
+
 /** WS-3a's seam (0.4.2): an agent's route outside its workspace. Not yet. */
 function workspaceRefusal(_p: AgentPrincipal, _pathname: string): null {
   return null;

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

@@ -302,6 +302,27 @@ export const ROUTES: readonly RouteEntry[] = [
   M(["POST", "DELETE"], "/api/workspaces/services"),
   M(["POST"], "/api/workspaces/settings"),
   M(["POST"], "/api/workspaces/:ws/agents/:id/stop", "TERM to its session"),
+  M(
+    ["POST"],
+    "/api/workspaces/:ws/agents/:id/remove",
+    "forgets a stopped agent (AG-14.1b); its record waits for Undo",
+  ),
+  M(
+    ["POST"],
+    "/api/agents/clear-stopped",
+    "forgets every stopped agent of the workspaces named (AG-14.1b)",
+  ),
+  M(["POST"], "/api/agents/restore", "Undo: brings removed agents back"),
+  S(
+    ["POST"],
+    "/api/workspaces/:ws/agents/:id/fresh",
+    "starts an agent afresh: a runtime in a PTY",
+  ),
+  S(
+    ["POST"],
+    "/api/agents/resume-interrupted",
+    "resumes interrupted agents: runtimes in PTYs (AG-14.3)",
+  ),
   S(
     ["POST"],
     "/api/workspaces/:ws/agents",
@@ -378,6 +399,8 @@ export const REGEX_ROUTES: Readonly<Record<string, readonly string[]>> = {
     "/api/workspaces/:ws/agents",
     "/api/workspaces/:ws/agents/:id/stop",
     "/api/workspaces/:ws/agents/:id/resume",
+    "/api/workspaces/:ws/agents/:id/fresh",
+    "/api/workspaces/:ws/agents/:id/remove",
   ],
   "agent-routes.ts:RUNTIME_PATH": ["/api/agents/runtimes/:id/path"],
   "session-routes.ts:IO_PATH": ["/api/sessions/:id/io"],

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

@@ -35,7 +35,10 @@
  */
 import type * as http from "http";
 import type { Duplex } from "stream";
-import { getActiveWorkspaces } from "../../shared/environment-manager/workspaces.js";
+import {
+  getActiveWorkspaces,
+  readWorkspacesFile,
+} from "../../shared/environment-manager/workspaces.js";
 import { getStateDir } from "../../shared/paths.js";
 import { product } from "../../shared/product.js";
 import { revokedAgentIds } from "../../shared/actor-token.js";
@@ -49,7 +52,7 @@ import { parseSessionName } from "../../shared/sessions/names.js";
 import { sessionPaths } from "../../shared/sessions/paths.js";
 import { loadPty, type PtyLoad } from "../../shared/sessions/pty.js";
 import type { SessionInfo } from "../../shared/sessions/types.js";
-import { agentRows } from "../cli/agent-ops.js";
+import { agentRows, noteEnded } from "../cli/agent-ops.js";
 import { state as sessionState } from "../cli/sessions-command.js";
 import { recordAction } from "./audit.js";
 import { sendJson } from "./http-helpers.js";
@@ -68,6 +71,8 @@ export interface SessionRouteDeps {
   /** A client of the running host, or null (never starts one). */
   connectExisting?: () => Promise<HostClient | null>;
   activeWorkspaces?: () => string[];
+  /** Whether workspaces.yml names `ws` (active or not). */
+  workspaceExists?: (ws: string) => boolean;
   pty?: () => PtyLoad;
 }
 
@@ -76,9 +81,13 @@ interface Resolved {
   dist: () => string;
   connectExisting: () => Promise<HostClient | null>;
   activeWorkspaces: () => string[];
+  workspaceExists: (ws: string) => boolean;
   pty: () => PtyLoad;
 }
 
+/** A workspace name as `?ws=` may give it. */
+const WS_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+
 function resolve(d: SessionRouteDeps = {}): Resolved {
   const stateDir = d.stateDir ?? (() => getStateDir());
   return {
@@ -95,6 +104,13 @@ function resolve(d: SessionRouteDeps = {}): Resolved {
         }
       }),
     activeWorkspaces: d.activeWorkspaces ?? (() => getActiveWorkspaces()),
+    workspaceExists:
+      d.workspaceExists ??
+      ((ws) =>
+        Object.prototype.hasOwnProperty.call(
+          readWorkspacesFile().workspaces ?? {},
+          ws,
+        )),
     pty: d.pty ?? (() => loadPty()),
   };
 }
@@ -119,7 +135,7 @@ export interface ListedSession {
   runtime?: string;
   model?: string;
   cwd?: string;
-  /** running, stopping, exited (<code>), stopped, ended. */
+  /** running, stopping, exited (<code>), stopped, interrupted (AG-14). */
   state: string;
   exited: boolean;
   exitCode?: number;
@@ -127,6 +143,12 @@ export interface ListedSession {
   /** The host has it (running, or ended with its scrollback): a pane can attach. */
   attachable: boolean;
   resumable?: boolean;
+  /** Why only Start fresh applies (AG-14.2): "<runtime> can't resume a conversation". */
+  noResume?: string;
+  /** When it was stopped, seen to end, or found interrupted (AG-14.1). */
+  stoppedAt?: string;
+  endedAt?: string;
+  interruptedAt?: string;
   /** Its actor token was revoked (`web logout --all`): restart or resume it. */
   tokenRevoked?: boolean;
   /** An approval is pending (AG-6a; only when the host knows). */
@@ -137,9 +159,12 @@ export interface ListedSession {
 export function listedSessions(
   sessions: SessionInfo[],
   d: Pick<Resolved, "stateDir" | "dist" | "activeWorkspaces">,
+  /** A workspace asked for by name (`?ws=`), listed even when inactive. */
+  also?: string,
 ): ListedSession[] {
   const dist = d.dist();
   const active = new Set(d.activeWorkspaces());
+  if (also) active.add(also);
   const mine = sessions.filter((s) => {
     const p = parseSessionName(s.name, dist);
     return p !== null && active.has(p.workspace);
@@ -150,6 +175,7 @@ export function listedSessions(
   const revoked = revokedAgentIds(d.stateDir());
   const out: ListedSession[] = [];
   const agentSessions = new Set<string>();
+  noteEnded(d.stateDir(), mine, records);
   for (const r of agentRows(mine, records)) {
     const rec = records.find((x) => x.id === r.agent)!;
     const s = r.session;
@@ -171,6 +197,10 @@ export function listedSessions(
       ...(r.startedAt ? { startedAt: r.startedAt } : {}),
       attachable: Boolean(s),
       resumable: r.resumable,
+      ...(r.noResume ? { noResume: r.noResume } : {}),
+      ...(r.stoppedAt ? { stoppedAt: r.stoppedAt } : {}),
+      ...(r.endedAt ? { endedAt: r.endedAt } : {}),
+      ...(r.interruptedAt ? { interruptedAt: r.interruptedAt } : {}),
       ...(revoked.has(rec.id) && s && !s.exited ? { tokenRevoked: true } : {}),
     });
   }
@@ -235,9 +265,27 @@ export async function handleSessionList(
   } catch (e) {
     hostError = (e as Error).message;
   }
+  // `?ws=<name>`: that workspace's too, active or not, and whether it is
+  // active and known (the page says so rather than show all of them).
+  const asked = new URL(req.url ?? "/", "http://localhost").searchParams.get(
+    "ws",
+  );
+  const wanted =
+    asked && WS_NAME.test(asked)
+      ? {
+          workspace: asked,
+          active: d.activeWorkspaces().includes(asked),
+          known: d.workspaceExists(asked),
+        }
+      : null;
   sendJson(res, {
-    sessions: listedSessions(sessions, d),
+    sessions: listedSessions(
+      sessions,
+      d,
+      wanted?.known ? wanted.workspace : undefined,
+    ),
     workspaces: d.activeWorkspaces(),
+    ...(wanted ? { requested: wanted } : {}),
     host,
     ...(hostError ? { hostError } : {}),
     backend: pty.available

package/src/ui/server/sudo-store.ts

@@ -32,7 +32,7 @@ import { AsyncLocalStorage } from "async_hooks";
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import { CLI_SPAWN_TIMEOUT_MS } from "../../shared/constants.js";
 
 import { product } from "../../shared/product.js";
@@ -62,11 +62,40 @@ function shimDirPrefix(): string {
   return path.join(os.tmpdir(), `${product().cli}-sudo-`);
 }
 
+/** The system's sudo: what Den runs whenever it is there. */
+export const SYSTEM_SUDO = "/usr/bin/sudo";
+
+/**
+ * Where the system's sudo is: /usr/bin/sudo, or DEN_SYSTEM_SUDO when set
+ * to an absolute path (a machine whose sudo lives elsewhere, and the
+ * tests' fake sudo). Never a name looked up on PATH.
+ */
+export function systemSudo(env: NodeJS.ProcessEnv = process.env): string {
+  const v = env.DEN_SYSTEM_SUDO;
+  return v && path.isAbsolute(v) ? v : SYSTEM_SUDO;
+}
+
+function isExecutableFile(file: string): boolean {
+  try {
+    fs.accessSync(file, fs.constants.X_OK);
+    return fs.statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+
 /**
- * The real sudo: the first `sudo` on PATH that isn't one of Den's shims,
- * else /usr/bin/sudo. Read when a shim is written.
+ * The real sudo: /usr/bin/sudo (systemSudo), pinned, so a `sudo` earlier
+ * on PATH (a directory a user or a tool can write to) never receives the
+ * admin password. Only where there is none there: the first `sudo` on
+ * PATH that isn't one of Den's shims. Read when a shim is written, and by
+ * every check Den runs itself.
  */
-export function realSudoPath(envPath: string = process.env.PATH ?? ""): string {
+export function realSudoPath(
+  envPath: string = process.env.PATH ?? "",
+  system: string = systemSudo(),
+): string {
+  if (isExecutableFile(system)) return system;
   const prefix = shimDirPrefix();
   for (const dir of envPath.split(path.delimiter)) {
     if (!dir || dir.startsWith(prefix)) continue;
@@ -78,7 +107,7 @@ export function realSudoPath(envPath: string = process.env.PATH ?? ""): string {
       /* not here */
     }
   }
-  return "/usr/bin/sudo";
+  return system;
 }
 
 /** A path inside single quotes, for a shim. */
@@ -254,7 +283,7 @@ export function watchSudo(
 export function prewarmSudo(): void {
   if (!_sudoPassword || lockClosedHere()) return;
   try {
-    execSync("sudo -S -v", {
+    execFileSync(realSudoPath(), ["-S", "-v"], {
       input: _sudoPassword + "\n",
       stdio: ["pipe", "pipe", "pipe"],
       timeout: CLI_SPAWN_TIMEOUT_MS,
@@ -288,7 +317,7 @@ export function hasPasswordlessSudo(): boolean {
   }
   let value = false;
   try {
-    execSync("sudo -n true", {
+    execFileSync(realSudoPath(), ["-n", "true"], {
       stdio: ["ignore", "ignore", "ignore"],
       timeout: CLI_SPAWN_TIMEOUT_MS,
     });