@monster-orange/den 0.4.3 → 0.4.4

package/src/shared/process/spawn-streaming.ts

@@ -86,6 +86,10 @@ export function spawnDaemon(
   // Stamp the log so the tail starts reading from a clean boundary.
   const ts = new Date().toISOString();
   fs.appendFileSync(logPath, `\n\n─── ${product().cli} start ${ts} ───\n`);
+  // Where this run's output starts. The tail reads from here, not from "the
+  // end when tail opened": a fast command (a refused sudo, a typo) can write
+  // and exit before tail starts, and `-n 0` would drop those lines.
+  const startOffset = fs.statSync(logPath).size;
 
   // Open the log fd in the parent so we can hand it to the child.
   // MUST stay "a" (O_APPEND): rotation truncates this file in place, and only
@@ -120,9 +124,10 @@ export function spawnDaemon(
   fs.closeSync(logFd); // parent closes its copy; child keeps its own fd
 
   // Tail the log for streaming back to the caller.
-  // -F follows by name (handles log rotation). -n 0 shows only new lines written
-  // after tail started (we already stamped the marker above).
-  const tailProc = spawn("tail", ["-F", "-n", "0", logPath], {
+  // -F follows by name (handles log rotation). -c +N starts at this run's
+  // first byte (just after the stamp), so nothing the service wrote before
+  // tail opened the file is lost.
+  const tailProc = spawn("tail", ["-F", "-c", `+${startOffset + 1}`, logPath], {
     stdio: ["ignore", "pipe", "ignore"],
   });
 

package/src/shared/sessions/client.ts

@@ -76,7 +76,8 @@ export class HostClient extends EventEmitter {
       const h = this.attachments.get(ev.aid);
       if (!h) return;
       if (ev.ev === "data") h.onData(Buffer.from(ev.data, "base64"));
-      else {
+      else if (ev.ev === "size") h.onSize?.(ev.cols, ev.rows);
+      else if (ev.ev === "exit") {
         this.attachments.delete(ev.aid);
         h.onExit?.(ev.exitCode);
       }
@@ -174,6 +175,9 @@ export class HostClient extends EventEmitter {
       ref: id,
       aid,
       ...(opts.replay !== undefined ? { replay: opts.replay } : {}),
+      // Only a client that handles them is sent size events: an older
+      // client would read an unknown event as the session's exit.
+      ...(handlers.onSize ? { sizes: true } : {}),
     }).then(
       (r) => r.info as SessionInfo,
       (e: Error) => {

package/src/shared/sessions/host.ts

@@ -63,6 +63,10 @@ interface Session {
   log: ScrollbackLog;
   /** aid → its connection. */
   attachments: Map<string, Conn>;
+  /** The attachments that asked for size events (attach `sizes: true`). */
+  sizeAids?: Set<string>;
+  /** The PTY's size: the start's, then the last resize's (any client's). */
+  size?: { cols: number; rows: number };
   /** The cap it counts against (start's `pool`), when one was named. */
   pool?: SessionPool;
 }
@@ -453,7 +457,15 @@ export class SessionHost {
         const s = this.session(req.ref);
         if (!isInt(req.cols, 1, 10_000) || !isInt(req.rows, 1, 10_000))
           throw new Refusal("bad-request", "resize needs whole cols and rows");
-        if (s.pty && !s.info.exited) s.pty.resize(req.cols, req.rows);
+        if (s.pty && !s.info.exited) {
+          s.pty.resize(req.cols, req.rows);
+          // Last writer wins: every viewer that asked hears the new size,
+          // so one out of step knows to say its own again.
+          if (s.size?.cols !== req.cols || s.size?.rows !== req.rows) {
+            s.size = { cols: req.cols, rows: req.rows };
+            this.sendSize(s);
+          }
+        }
         return {};
       }
       case "signal": {
@@ -606,6 +618,7 @@ export class SessionHost {
         },
       ),
       attachments: new Map(),
+      size: { cols, rows },
       ...(pool !== undefined ? { pool: pool as SessionPool } : {}),
     };
     this.sessions.set(id, s);
@@ -626,6 +639,7 @@ export class SessionHost {
         for (const [aid, c] of s.attachments)
           c.send({ ev: "exit", aid, exitCode: s.info.exitCode });
         s.attachments.clear();
+        s.sizeAids?.clear();
         this.log(`session ${id} (${name}) exited (${s.info.exitCode})`);
       }, EXIT_SETTLE_MS);
     });
@@ -654,10 +668,24 @@ export class SessionHost {
     } else {
       conn.aids.add(aid);
       s.attachments.set(aid, conn);
+      if (req.sizes === true) {
+        (s.sizeAids ??= new Set()).add(aid);
+        if (s.size) conn.send({ ev: "size", aid, ...s.size });
+      }
     }
     return s.info;
   }
 
+  /** Tell each attachment that asked the session's current size. */
+  private sendSize(s: Session): void {
+    if (!s.size || !s.sizeAids?.size) return;
+    for (const aid of s.sizeAids) {
+      const c = s.attachments.get(aid);
+      if (c) c.send({ ev: "size", aid, ...s.size });
+      else s.sizeAids.delete(aid);
+    }
+  }
+
   /** Stop serving: running sessions get SIGHUP, scrollback is flushed. */
   async close(): Promise<void> {
     if (this.closed) return;

package/src/shared/sessions/protocol.ts

@@ -7,6 +7,10 @@
  *             {id, ok: false, code, error}
  *   event     {ev: "data", aid, data}     host → client, per attachment
  *             {ev: "exit", aid, exitCode}
+ *             {ev: "size", aid, cols, rows} only to an attachment that
+ *                                           asked (attach `sizes: true`):
+ *                                           the PTY's size on attach, and
+ *                                           each time it changes
  *
  * ops: hello, start, list, attach, detach, write, resize, signal,
  * scrollback, forget, shutdown. A request whose `v` is not the host's is
@@ -47,7 +51,8 @@ export type Reply =
 
 export type HostEvent =
   | { ev: "data"; aid: string; data: string }
-  | { ev: "exit"; aid: string; exitCode?: number };
+  | { ev: "exit"; aid: string; exitCode?: number }
+  | { ev: "size"; aid: string; cols: number; rows: number };
 
 /** Splits a byte stream into lines; refuses one that grows too long. */
 export class LineReader {

package/src/shared/sessions/types.ts

@@ -55,6 +55,12 @@ export interface AttachHandlers {
   onData(data: Buffer): void;
   /** The session ended (at once, after the replay, when it already had). */
   onExit?(exitCode: number | undefined): void;
+  /**
+   * The PTY's size: once on attach (after the replay), then each time any
+   * client resizes it. The size is last-writer-wins across every viewer,
+   * so a viewer learns here that another one changed it.
+   */
+  onSize?(cols: number, rows: number): void;
 }
 
 /** One attachment; a session has any number, each gets all the output. */

package/src/shared/stacks/status.ts

@@ -3,6 +3,7 @@
  * The CLI prints it; the web server serves it at /api/stacks (and through it
  * the MCP `stacks` tool).
  */
+import { product } from "../product.js";
 import { spawnSync } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
@@ -125,6 +126,29 @@ export function rejoinRunningStacks(
   return rejoinEdgeNetworks(contexts, onLine);
 }
 
+/**
+ * Why a workspace has no stacks (MCP-2.4): an empty list with no reason
+ * reads as "docker is broken". A stack is a `stacks:` entry in the org
+ * config, or a repo of the workspace whose manifest has a `compose:` block.
+ */
+export function emptyStacksReason(o: {
+  workspace: string;
+  workspaceExists: boolean;
+  /** How many stacks the org config itself declares. */
+  configStacks: number;
+}): string {
+  const cfg = `the org config (${product().configFile}) declares no stacks:`;
+  if (!o.workspaceExists)
+    return (
+      `no stacks: workspace "${o.workspace}" does not exist here, so no ` +
+      `repo manifest was read, and ${cfg}`
+    );
+  return (
+    `no stacks: ${cfg}, and no repo of workspace "${o.workspace}" has a ` +
+    `compose: block in its ${product().manifestYml}`
+  );
+}
+
 /** Each stack's name, project, routes and (optionally) container health. */
 export function stackStatuses(
   ctx: StackContext,

package/src/shared/strategies/registry.ts

@@ -44,6 +44,11 @@ export function registerStrategy<K extends string, C>(
   byId.set(entry.id, entry as StrategyEntry);
 }
 
+/** Remove strategy `id` of `kind` (no-op when it isn't there). */
+export function unregisterStrategy(kind: string, id: string): void {
+  registries.get(kind)?.delete(id);
+}
+
 /** The strategy `id` of `kind`, or undefined. */
 export function getStrategy<K extends string, C>(
   kind: K,

package/src/shared/types/index.ts

@@ -667,6 +667,12 @@ export interface WorkspaceServiceEntry {
 }
 
 export interface WorkspaceConfig {
+  /**
+   * Agents in this workspace, on this machine (AG-0.5):
+   * `agents.runtimes.<id>.bin`, a runtime's CLI for this workspace's
+   * agents, which wins over user.yml's and the search.
+   */
+  agents?: { runtimes?: Record<string, { bin?: unknown } | null> };
   /**
    * Service entries keyed by service address.
    * Single-service repos: "tasks-runner"

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

@@ -42,10 +42,22 @@ import * as path from "path";
 import {
   AGENTS_RESERVED_KEYS,
   configuredRuntimeBin,
+  configuredRuntimeCatalog,
   readAgentsConfig,
+  setUserRuntimeBin,
   userConfigPath,
   type ResolvedAgentsConfig,
 } from "../../shared/den-config.js";
+import {
+  setWorkspaceRuntimeBin,
+  workspaceBinKey,
+  workspaceRuntimeBin,
+} from "../../shared/environment-manager/workspaces.js";
+import {
+  BUILTIN_CATALOG,
+  type CatalogEntry,
+} from "../../shared/agents/catalog.js";
+import { checkRuntimeBin } from "../../shared/agents/catalog-runtime.js";
 import { cliEntrypoint } from "../../shared/engine.js";
 import { getDistRoot } from "../../shared/paths.js";
 import { envKey } from "../../shared/product.js";
@@ -70,6 +82,7 @@ import {
   getRuntime,
   LaunchError,
   runtimeIds,
+  syncConfiguredRuntimes,
   type AgentMcp,
   type LaunchInput,
   type Runtime,
@@ -77,7 +90,10 @@ import {
 import type { RuntimeDetect } from "../../shared/agents/runtime.js";
 import {
   binSettingKey,
+  ensureInteractivePath,
+  interactivePathAsked,
   runtimeVersion,
+  type BinSetting,
   type BinSource,
 } from "../../shared/agents/runtime-search.js";
 import { WORKSPACE_NAME_RE } from "../../shared/agent-actor.js";
@@ -116,6 +132,20 @@ export interface AgentsDeps extends SessionsDeps {
   exitWatchMs?: number;
   /** `agents.runtimes.<id>.bin` (default: user.yml's; undefined: unset). */
   runtimeBin?: (id: string) => unknown;
+  /**
+   * Workspace `ws`'s `agents.runtimes.<id>.bin` (default: workspaces.yml's;
+   * undefined: unset). It wins over runtimeBin (AG-0.5).
+   */
+  workspaceRuntimeBin?: (ws: string, id: string) => unknown;
+  /** user.yml's runtime catalog entries, checked (default: user.yml's). */
+  userCatalog?: (taken: readonly string[]) => CatalogEntry[];
+  /** Save a checked path (null clears it): global or the workspace's. */
+  saveRuntimeBin?: (
+    scope: "global" | "workspace",
+    ws: string | undefined,
+    id: string,
+    bin: string | null,
+  ) => void;
   /** The user.yml a person edits to set it (default: config/local/user.yml). */
   userConfigFile?: () => string;
 }
@@ -127,6 +157,9 @@ export interface AgentsResolved extends Resolved {
   mcpServer: () => { command: string[] | string; env: Record<string, string> };
   exitWatchMs: number;
   runtimeBin: (id: string) => unknown;
+  workspaceRuntimeBin: (ws: string, id: string) => unknown;
+  userCatalog: (taken: readonly string[]) => CatalogEntry[];
+  saveRuntimeBin: NonNullable<AgentsDeps["saveRuntimeBin"]>;
   userConfigFile: () => string;
 }
 
@@ -217,6 +250,15 @@ export function resolveAgentsDeps(d: AgentsDeps): AgentsResolved {
     mcpServer: d.mcpServer ?? (() => defaultMcpServer(base.cli)),
     exitWatchMs: d.exitWatchMs ?? EXIT_WATCH_MS,
     runtimeBin: d.runtimeBin ?? ((id) => configuredRuntimeBin(id)),
+    workspaceRuntimeBin:
+      d.workspaceRuntimeBin ?? ((ws, id) => workspaceRuntimeBin(ws, id)),
+    userCatalog: d.userCatalog ?? ((taken) => configuredRuntimeCatalog(taken)),
+    saveRuntimeBin:
+      d.saveRuntimeBin ??
+      ((scope, ws, id, bin) =>
+        scope === "workspace" && ws
+          ? setWorkspaceRuntimeBin(ws, id, bin)
+          : setUserRuntimeBin(id, bin)),
     userConfigFile: d.userConfigFile ?? userConfigPath,
   };
 }
@@ -415,44 +457,137 @@ export interface RuntimeChoice {
   id: string;
   /** Its name for people ("Claude Code"). */
   label?: string;
+  /** Who makes it ("Anthropic"): a catalog runtime (AG-0.5). */
+  vendor?: string;
+  /**
+   * false: it runs as its own CLI, without Den's tools yet ("Den tools:
+   * coming"). Absent for a runtime that isn't from the catalog.
+   */
+  denTools?: boolean;
   available: boolean;
   /** Why it is unavailable. */
   why?: string;
   version?: string;
   /** The CLI it runs (AG-0.2). */
   path?: string;
-  /** Where that path came from: setting, login-shell, well-known or PATH. */
+  /**
+   * Where that path came from: workspace (its workspaces.yml entry),
+   * setting (user.yml), login-shell, PATH, well-known, interactive-shell.
+   */
   source?: BinSource;
   /** The directories searched, in order (a runtime with a CLI to find). */
   searched?: string[];
   /** The user.yml key that sets its path (a runtime with a CLI to find). */
   setting?: string;
+  /** The workspace's key for it, when listed for a workspace. */
+  workspaceSetting?: string;
   /** It declares resume. */
   resume: boolean;
   default: boolean;
 }
 
 /**
- * Whether runtime `rt` can run here (AG-0.1): its setting
- * (`agents.runtimes.<id>.bin`, from d.runtimeBin), else the search. Runs
- * nothing.
+ * The path set for runtime `id` (AG-0.5): the workspace's (when `ws` is
+ * given and it sets one), else user.yml's; null when neither does.
+ */
+export function runtimeSetting(
+  d: AgentsResolved,
+  id: string,
+  ws?: string,
+): BinSetting | null {
+  if (ws) {
+    const v = d.workspaceRuntimeBin(ws, id);
+    if (v !== undefined && v !== null)
+      return { value: v, source: "workspace", key: workspaceBinKey(ws, id) };
+  }
+  const g = d.runtimeBin(id);
+  return g === undefined || g === null ? null : { value: g, source: "setting" };
+}
+
+/**
+ * Whether runtime `rt` can run here (AG-0.1, AG-0.5): a path set for the
+ * workspace, else user.yml's (`agents.runtimes.<id>.bin`), else the
+ * search. Runs nothing.
+ */
+export function detectRuntime(
+  d: AgentsResolved,
+  rt: Runtime,
+  ws?: string,
+): RuntimeDetect {
+  return rt.detect(d.env, { bin: runtimeSetting(d, rt.id, ws) });
+}
+
+/**
+ * The catalog entries the distribution and user.yml add, registered as
+ * runtimes (AG-0.5). A malformed entry is a refusal naming its key.
+ */
+export function syncCatalog(d: AgentsResolved): void {
+  const cfg = agentsConfig(d);
+  let extra: CatalogEntry[];
+  try {
+    extra = [
+      ...cfg.runtimeCatalog,
+      ...d.userCatalog([
+        ...BUILTIN_CATALOG.map((e) => e.id),
+        ...cfg.runtimeCatalog.map((e) => e.id),
+      ]),
+    ];
+  } catch (e) {
+    throw refused((e as Error).message, [], 422);
+  }
+  syncConfiguredRuntimes(extra);
+}
+
+/**
+ * When a catalog runtime is still missing (nothing set, not found on the
+ * login PATH, PATH or its install directories), ask the interactive shell
+ * for its PATH: once per process, then kept (AG-0.5).
+ */
+async function fallbackSearch(
+  d: AgentsResolved,
+  rts: Runtime[],
+  ws?: string,
+): Promise<void> {
+  if (interactivePathAsked()) return;
+  const missing = rts.some(
+    (rt) =>
+      rt.catalog &&
+      !runtimeSetting(d, rt.id, ws) &&
+      !detectRuntime(d, rt, ws).available,
+  );
+  if (missing) await ensureInteractivePath({ env: d.env });
+}
+
+/**
+ * The catalog's installed runtimes first, then the ones not found, then
+ * the rest (generic: no CLI of its own to find).
  */
-export function detectRuntime(d: AgentsResolved, rt: Runtime): RuntimeDetect {
-  return rt.detect(d.env, { bin: d.runtimeBin(rt.id) ?? null });
+function rank(r: RuntimeChoice): number {
+  if (r.denTools === undefined) return 2;
+  return r.available ? 0 : 1;
 }
 
 /**
- * Every registered runtime, and whether it can run here, with the path it
- * runs and its version: its version command (`claude --version`), run once
- * under a timeout and kept, else what its install says.
+ * Every registered runtime, and whether it can run here (for an agent of
+ * `ws`, when given: its workspace's path wins), with the path it runs and
+ * its version: its version command (`claude --version`), run once under a
+ * timeout and kept, else what its install says. Installed ones first.
  */
 export async function listRuntimes(
   d: AgentsResolved,
+  ws?: string,
 ): Promise<RuntimeChoice[]> {
-  return Promise.all(
-    runtimeIds().map(async (id) => {
+  syncCatalog(d);
+  const ids = runtimeIds();
+  await fallbackSearch(
+    d,
+    ids.map((id) => getRuntime(id)!),
+    ws,
+  );
+  const rows = await Promise.all(
+    ids.map(async (id) => {
       const rt = getRuntime(id)!;
-      const det = detectRuntime(d, rt);
+      const det = detectRuntime(d, rt, ws);
       const asked =
         det.available && det.path && rt.find?.versionArgs
           ? await runtimeVersion(det.path, rt.find.versionArgs, d.env)
@@ -461,24 +596,72 @@ export async function listRuntimes(
       return {
         id,
         ...(rt.label ? { label: rt.label } : {}),
+        ...(rt.vendor ? { vendor: rt.vendor } : {}),
+        ...(rt.catalog ? { denTools: rt.denTools === true } : {}),
         available: det.available,
         ...(det.available ? {} : { why: det.why ?? "unavailable" }),
         ...(version ? { version } : {}),
         ...(det.path ? { path: det.path } : {}),
         ...(det.source ? { source: det.source } : {}),
         ...(rt.find
-          ? { searched: det.searched ?? [], setting: binSettingKey(id) }
+          ? {
+              searched: det.searched ?? [],
+              setting: binSettingKey(id),
+              ...(ws ? { workspaceSetting: workspaceBinKey(ws, id) } : {}),
+            }
           : {}),
         resume: Boolean(rt.resume),
         default: id === DEFAULT_RUNTIME_ID,
       };
     }),
   );
+  return rows
+    .map((r, i) => ({ r, i }))
+    .sort((a, b) => rank(a.r) - rank(b.r) || a.i - b.i)
+    .map((x) => x.r);
+}
+
+/**
+ * Set (or, with null, clear) runtime `id`'s path, global or for workspace
+ * `ws` (AG-0.5): its version command runs first, and a path that isn't
+ * that runtime is refused. Returns its row as listed after.
+ */
+export async function setRuntimePath(
+  d: AgentsResolved,
+  req: {
+    id: string;
+    scope: "global" | "workspace";
+    workspace?: string;
+    bin: string | null;
+  },
+): Promise<RuntimeChoice> {
+  syncCatalog(d);
+  const rt = runtimeFor(req.id);
+  if (!rt.catalog)
+    throw usage(`${req.id} has no CLI to find: its path can't be set`);
+  let ws: string | undefined;
+  if (req.scope === "workspace") {
+    ws = checkWorkspaceName("runtime path", req.workspace);
+    if (!d.workspaceExists(ws))
+      throw usage(`workspace "${ws}" does not exist`, 404);
+  }
+  if (req.bin !== null) {
+    const c = await checkRuntimeBin(rt.catalog, req.bin, d.env);
+    if (!c.ok) throw refused(c.why, [], 422);
+    d.saveRuntimeBin(req.scope, ws, rt.id, c.path);
+  } else d.saveRuntimeBin(req.scope, ws, rt.id, null);
+  const rows = await listRuntimes(d, ws);
+  return rows.find((r) => r.id === rt.id)!;
 }
 
 /** Refused unless `rt` can run here; its detect result when it can. */
-function availableOrRefuse(d: AgentsResolved, rt: Runtime): RuntimeDetect {
-  const det = detectRuntime(d, rt);
+async function availableOrRefuse(
+  d: AgentsResolved,
+  rt: Runtime,
+  ws?: string,
+): Promise<RuntimeDetect> {
+  await fallbackSearch(d, [rt], ws);
+  const det = detectRuntime(d, rt, ws);
   if (!det.available)
     throw refused(
       `${rt.id} is unavailable: ${det.why ?? "unknown"}`,
@@ -538,9 +721,15 @@ interface Launch {
   binDir?: string;
 }
 
-/** A configured CLI's directory, for its session's PATH (its own tools). */
+/**
+ * A CLI's directory when the session's PATH wouldn't have it (a path set
+ * for it, or found by the interactive shell), for its own tools.
+ */
 function binDirOf(det: RuntimeDetect): { binDir?: string } {
-  return det.source === "setting" && det.path
+  return (det.source === "setting" ||
+    det.source === "workspace" ||
+    det.source === "interactive-shell") &&
+    det.path
     ? { binDir: path.dirname(det.path) }
     : {};
 }
@@ -766,8 +955,9 @@ export async function startAgent(
     );
   const id = req.id ?? defaultId(d.stateDir(), persona.id, ws);
   checkId(where, id);
+  syncCatalog(d);
   const rt = runtimeFor(req.runtime ?? persona.runtime ?? DEFAULT_RUNTIME_ID);
-  const det = availableOrRefuse(d, rt);
+  const det = await availableOrRefuse(d, rt, ws);
   const model = req.model ?? persona.model;
 
   const prev = readRecord(d.stateDir(), id);
@@ -871,6 +1061,7 @@ export async function resumeAgent(
   ws?: string,
 ): Promise<Resumed> {
   const rec = agentRecord(d, id, ws);
+  syncCatalog(d);
   const rt = runtimeFor(rec.runtime);
   if (!rt.resume)
     throw refused(`runtime ${rt.id} does not declare resume`, [
@@ -880,7 +1071,7 @@ export async function resumeAgent(
   const persona = personas(d, cfg).get(rec.persona);
   if (!persona)
     throw refused(`agent ${rec.id}'s persona "${rec.persona}" is gone`);
-  const det = availableOrRefuse(d, rt);
+  const det = await availableOrRefuse(d, rt, rec.workspace);
   ptyOrRefuse(d);
   return withClient(d, async (c) => {
     const old = sessionOf(await c.list(), rec);