@monster-orange/den 0.4.2 → 0.4.4

package/src/shared/health/not-checked.ts

@@ -0,0 +1,42 @@
+/**
+ * MCP-2.4: why a service has no health verdict, in words. A row with `ok:
+ * null` and no reason reads as "broken" to an agent (it fell back to
+ * `docker ps`); every unchecked row says which of these it is. One rule for
+ * the web health row (/api/health) and the MCP `status` tool, which derives
+ * it from a row an older web server served without one.
+ */
+import { product } from "../product.js";
+import type { Runs } from "../manifest/placement.js";
+
+export interface NotCheckedInput {
+  /** The env being viewed. */
+  env: string;
+  runs: Runs | undefined;
+  /** A remote service's target (its env), when it has one. */
+  target?: { env?: string } | null;
+  /** false when the repo has no manifest at all. */
+  manifest?: boolean;
+  /** The conventional probe tried (and not answered 2xx), if any. */
+  conventional?: string | null;
+}
+
+export function notCheckedReason(o: NotCheckedInput): string {
+  if (o.manifest === false)
+    return `not checked: the repo has no ${product().manifestYml}`;
+  if (o.runs === "remote") {
+    const where = o.target?.env ?? o.env;
+    return (
+      `not checked: remote (runs in ${where}), and the manifest declares ` +
+      `no health check or target.url for ${where}`
+    );
+  }
+  if (o.runs === "none" || o.runs === undefined)
+    return (
+      `not checked: not deployed in ${o.env} (the manifest has no ` +
+      `commands and no health check for ${o.env})`
+    );
+  return (
+    `not checked: no health check in the manifest for ${o.env}` +
+    (o.conventional ? `, and ${o.conventional} did not answer 2xx` : "")
+  );
+}

package/src/shared/health/rollup.ts

@@ -17,6 +17,8 @@ export interface HealthSignal {
   isEntrypoint?: boolean;
   /** Not answered yet this cycle: the repo stays unknown until it has. */
   awaiting?: boolean;
+  /** The check answered with a redirect (ok null): counted as a redirect. */
+  redirect?: boolean;
 }
 
 export interface RepoRollup {
@@ -29,6 +31,8 @@ export interface RepoRollup {
   unchecked: number;
   /** Checks that haven't answered yet; any holds the state at unknown. */
   awaiting: number;
+  /** Checks that answered with a redirect (not in `unchecked`); absent at 0. */
+  redirected?: number;
 }
 
 export const STATE_RANK: Record<RepoState, number> = rollup.STATE_RANK;

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"