@schlessera/brain-ui-server 0.31.0 → 0.32.0

package/src/routes/skills.ts

@@ -29,6 +29,8 @@ import {
   type Fetcher,
 } from "../skills/install.js";
 import { resolveGitHubToken } from "../config/env.js";
+import { readJsonBody } from "../middleware/body-limit.js";
+import { requireJson } from "../middleware/origin.js";
 
 export interface SkillRoutesDeps {
   brainPath: string;
@@ -101,8 +103,10 @@ export function createSkillRoutes(deps: SkillRoutesDeps): Hono {
         return c.json({ error: message }, status);
       }
     })
-    .post("/skills/install/github", async (c) => {
-      const body = (await c.req.json().catch(() => null)) as {
+    .post("/skills/install/github", requireJson(), async (c) => {
+      const result = await readJsonBody(c).catch(() => null);
+      if (result instanceof Response) return result;
+      const body = result as {
         source?: unknown;
         ref?: unknown;
         overwrite?: unknown;
@@ -145,8 +149,10 @@ export function createSkillRoutes(deps: SkillRoutesDeps): Hono {
         return c.json({ error: message }, status);
       }
     })
-    .post("/skills", async (c) => {
-      const body = (await c.req.json().catch(() => null)) as {
+    .post("/skills", requireJson(), async (c) => {
+      const result = await readJsonBody(c).catch(() => null);
+      if (result instanceof Response) return result;
+      const body = result as {
         name?: unknown;
         content?: unknown;
       } | null;
@@ -162,8 +168,10 @@ export function createSkillRoutes(deps: SkillRoutesDeps): Hono {
         return c.json({ error: message }, status);
       }
     })
-    .put("/skills/:name", async (c) => {
-      const body = (await c.req.json().catch(() => null)) as { content?: unknown } | null;
+    .put("/skills/:name", requireJson(), async (c) => {
+      const result = await readJsonBody(c).catch(() => null);
+      if (result instanceof Response) return result;
+      const body = result as { content?: unknown } | null;
       if (typeof body?.content !== "string") {
         return c.json({ error: "Body needs string `content`." }, 400);
       }
@@ -176,8 +184,10 @@ export function createSkillRoutes(deps: SkillRoutesDeps): Hono {
         return c.json({ error: message }, status);
       }
     })
-    .post("/skills/:name/enabled", async (c) => {
-      const body = (await c.req.json().catch(() => null)) as { enabled?: unknown } | null;
+    .post("/skills/:name/enabled", requireJson(), async (c) => {
+      const result = await readJsonBody(c).catch(() => null);
+      if (result instanceof Response) return result;
+      const body = result as { enabled?: unknown } | null;
       if (typeof body?.enabled !== "boolean") {
         return c.json({ error: "Body needs boolean `enabled`." }, 400);
       }

package/src/routes/web-search.ts

@@ -30,6 +30,8 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
 import { dirname } from "path";
 import { Hono } from "hono";
+import { readJsonBody } from "../middleware/body-limit.js";
+import { requireJson } from "../middleware/origin.js";
 import {
   WEB_SEARCH_FALLBACK_ON,
   WEB_SEARCH_PROVIDER_KEYS,
@@ -186,11 +188,13 @@ export function createWebSearchRoutes(deps: WebSearchRoutesDeps): Hono {
       }
       return c.json(view());
     })
-    .put("/web-search", async (c) => {
+    .put("/web-search", requireJson(), async (c) => {
       if (!piConfigured()) {
         return c.json({ error: "The pi backend is not configured." }, 409);
       }
-      const body = (await c.req.json().catch(() => null)) as {
+      const result = await readJsonBody(c).catch(() => null);
+      if (result instanceof Response) return result;
+      const body = result as {
         enabled?: unknown;
         apiKeys?: unknown;
         clearOverride?: unknown;

package/src/share/staging.ts

@@ -13,6 +13,7 @@ import {
   type ShareIntakeResult,
   type ShareStagingManifest,
 } from "@schlessera/brain-ui-sdk/protocol";
+import { safeResolve } from "../files/walker.js";
 
 /**
  * Staging for an incoming system share.
@@ -301,7 +302,7 @@ export async function stageShare(
     throw new ShareTooLargeError("share_too_large", SHARE_MAX_TOTAL_BYTES);
   }
 
-  const root = shareStagingRoot(brainPath);
+  const root = await safeResolve(SHARE_STAGING_DIR, brainPath);
   if ((await countStaged(root)) >= SHARE_MAX_STAGED) {
     throw new ShareTooLargeError("inbox_full", SHARE_MAX_STAGED);
   }

package/src/ws/clients.ts

@@ -8,9 +8,16 @@ import { shrinkForReplication } from "./shrink.js";
  */
 export type WSContext = {
   send: (data: string) => void;
-  raw?: { send?: (data: string) => number } | undefined;
+  close?: (code?: number, reason?: string) => void;
+  raw?: unknown;
 };
 
+function canSendRaw(raw: unknown): raw is { send: (data: string) => unknown } {
+  return (
+    typeof raw === "object" && raw !== null && "send" in raw && typeof raw.send === "function"
+  );
+}
+
 /** Serialize + size-bound a frame, then send it to one specific socket. */
 export function sendTo(ws: WSContext, msg: ServerMessage): void {
   ws.send(JSON.stringify(shrinkForReplication(msg)));
@@ -24,24 +31,55 @@ export function sendTo(ws: WSContext, msg: ServerMessage): void {
  * which would have cross-wired two coexisting app instances.)
  */
 export class ClientSet {
-  private readonly clients = new Set<WSContext>();
+  // Hono creates a new WSContext for every Bun open/message/close callback.
+  // The raw socket remains stable across those wrappers, so it is the identity
+  // that admission and removal must share.
+  private readonly clients = new Map<unknown, WSContext>();
+
+  constructor(readonly maxConnections = 32) {}
 
-  add(ws: WSContext): void {
-    this.clients.add(ws);
+  add(ws: WSContext): boolean {
+    const identity = ws.raw ?? ws;
+    if (!this.clients.has(identity) && this.clients.size >= this.maxConnections) return false;
+    this.clients.set(identity, ws);
+    return true;
   }
 
   remove(ws: WSContext): void {
-    this.clients.delete(ws);
+    this.clients.delete(ws.raw ?? ws);
   }
 
   count(): number {
     return this.clients.size;
   }
 
+  /** Whether another distinct socket can be admitted without exceeding the cap. */
+  hasCapacity(): boolean {
+    return this.clients.size < this.maxConnections;
+  }
+
   hasClients(): boolean {
     return this.clients.size > 0;
   }
 
+  /**
+   * Close and forget every attached socket. The set is cleared before close
+   * callbacks can run, and one broken socket cannot prevent the others from
+   * being invalidated.
+   */
+  closeAll(code: number, reason: string): void {
+    const clients = [...this.clients.values()];
+    this.clients.clear();
+    for (const ws of clients) {
+      try {
+        ws.close?.(code, reason);
+      } catch {
+        // Best effort per socket; revocation of the remaining clients must
+        // continue even when one adapter throws during close.
+      }
+    }
+  }
+
   /**
    * Broadcast a frame to every attached client. Serializes once. A failing
    * socket is skipped (its `onClose` will prune it) so one dead peer can't
@@ -50,13 +88,13 @@ export class ClientSet {
   broadcast(msg: ServerMessage, onSendError?: (err: unknown) => void): void {
     if (this.clients.size === 0) return;
     const payload = JSON.stringify(shrinkForReplication(msg));
-    for (const ws of this.clients) {
+    for (const ws of this.clients.values()) {
       try {
         // Bun's ServerWebSocket reports a dropped write by RETURNING 0 (closed
         // connection) rather than throwing, and hono's WSContext.send discards
         // that status — so write through the raw socket where one exists. -1
         // is backpressure: the frame is queued, not lost.
-        if (typeof ws.raw?.send === "function") {
+        if (canSendRaw(ws.raw)) {
           if (ws.raw.send(payload) === 0) {
             onSendError?.(new Error("send dropped: connection closed"));
           }

package/src/ws/connection.ts

@@ -49,6 +49,9 @@ import type { WSContext } from "./clients.js";
 
 export { websocket };
 
+const CONNECTION_LIMIT_CLOSE_CODE = 4008;
+const CONNECTION_LIMIT_CLOSE_REASON = "Connection limit reached";
+
 /**
  * The socket lifecycle handlers for one host, separate from the Hono upgrade
  * that wraps them.
@@ -68,6 +71,14 @@ export function createWsHandlers(host: WsHost) {
 
   return {
     async onOpen(_evt: Event, ws: WSContext) {
+      if (!host.clients.add(ws)) {
+        host.reportRefusedConnection();
+        // Hono's WSContext always exposes close(); the local structural socket
+        // type keeps it optional because send-only test/dispatch fakes never
+        // exercise connection admission.
+        ws.close!(CONNECTION_LIMIT_CLOSE_CODE, CONNECTION_LIMIT_CLOSE_REASON);
+        return;
+      }
       host.log.emit({ severityText: "INFO", body: "client connected" });
       const { coordinator, catalog } = host;
 
@@ -123,7 +134,6 @@ export function createWsHandlers(host: WsHost) {
             attributes: { error: err instanceof Error ? err.message : String(err) },
           });
         } finally {
-          host.clients.add(ws);
           host.sendMessage(
             ws,
             withTurnScope(
@@ -141,7 +151,6 @@ export function createWsHandlers(host: WsHost) {
         return;
       }
 
-      host.clients.add(ws);
       host.sendMessage(ws, {
         type: "status",
         status: "idle",

package/src/ws/host.ts

@@ -75,6 +75,8 @@ export interface WsHostOptions {
    * fronting the socket with its own limiter wants.
    */
   wsRate?: { ratePerSecond: number; burst: number };
+  /** Maximum WebSocket connections accepted by this host (default 32). */
+  wsMaxConnections?: number;
   /**
    * Activity recording (span store + live stream). Optional: a host without
    * one records nothing and never sends activity frames — which is also what
@@ -124,7 +126,7 @@ export function turnLogAttributes(turn: TurnLogContext): Record<string, string>
  */
 export class WsHost {
   readonly coordinator = new TurnCoordinator();
-  readonly clients = new ClientSet();
+  readonly clients: ClientSet;
   readonly registry: BackendRegistry;
   catalog: SessionCatalog;
   appName: string;
@@ -151,8 +153,12 @@ export class WsHost {
   private readonly wsErrors: ReturnType<
     ReturnType<Observability["meter"]>["createCounter"]
   >;
+  private readonly connectionsRefused: ReturnType<
+    ReturnType<Observability["meter"]>["createCounter"]
+  >;
 
   constructor(options: WsHostOptions) {
+    this.clients = new ClientSet(options.wsMaxConnections);
     this.registry = options.registry;
     this.catalog = options.catalog;
     this.appName = options.appName ?? "Brain UI";
@@ -181,6 +187,9 @@ export class WsHost {
     this.wsErrors = meter.createCounter("ws.errors", {
       description: "Transport errors reported by the socket layer",
     });
+    this.connectionsRefused = meter.createCounter("ws.connections.refused", {
+      description: "WebSocket connections refused before admission",
+    });
     this.coordinator.log = this.log;
   }
 
@@ -206,6 +215,19 @@ export class WsHost {
     });
   }
 
+  /** Record a socket refused because this process has reached its connection cap. */
+  reportRefusedConnection(): void {
+    this.connectionsRefused.add(1, { reason: "connection_limit" });
+    this.log.emit({
+      severityText: "WARN",
+      body: "websocket connection refused",
+      attributes: {
+        reason: "connection_limit",
+        "connection.limit": this.clients.maxConnections,
+      },
+    });
+  }
+
   /** A turn began executing: counted, and logged with its correlation ids. */
   reportTurnStarted(turn: TurnLogContext): void {
     this.turnsStarted.add(1);