@nifrajs/mcp 3.3.0 → 4.0.0

package/src/server.ts

@@ -15,9 +15,10 @@
  * {@link McpServer.handle} dispatches a single JSON-RPC message directly (for headless verification / tests).
  *
  * SECURITY: this has NO built-in authentication - once mounted, every tool is callable by anyone who can
- * reach the route (the CORS header is `*` and no credentials are used, so it is effectively public). That
- * is fine for read-only/public tools; if any tool mutates state or returns private data, gate the route
- * yourself (check an `Authorization` header / session in the nifra handler before calling `mcp.fetch`).
+ * reach the route. Browser access is same-origin by default; set `allowAnyOrigin: true` only for a
+ * secret-free public server. Same-origin does not stop DNS rebinding: a server on localhost or a
+ * private network should also set `allowedHosts`. If any tool mutates state or returns private data, gate the route yourself
+ * (check an `Authorization` header / session in the nifra handler before calling `mcp.fetch`).
  */
 
 import { type McpHttpOptions, respondMcpHttp } from "./http.ts"
@@ -26,6 +27,7 @@ import {
   type JsonRpcRequest,
   type JsonRpcResponse,
   type McpPrompt,
+  type McpProtocolState,
   type McpResource,
   type McpServerFeatures,
   type McpTool,
@@ -46,11 +48,20 @@ export interface CreateMcpServerOptions {
   readonly health?: string
   /** Max JSON-RPC body size in bytes (default 1 MB). */
   readonly maxBodyBytes?: number
+  /** Max serialized JSON-RPC response or SSE frame size (default 1 MB). */
+  readonly maxResponseBytes?: number
   /** Natural-language guidance for LLMs, surfaced in the modern `server/discover` result (2026-07-28). */
   readonly instructions?: string
-  /** Origin allowlist for the DNS-rebinding guard. Omit to allow any origin; set it to reject other
-   * browser origins with 403 (e.g. a hardened, non-public mount). */
+  /** Explicitly allow browser clients from any origin. Omit for the secure same-origin default. */
+  readonly allowAnyOrigin?: boolean
+  /** Origin allowlist for the DNS-rebinding guard. Set it to permit exact cross-origin clients. */
   readonly allowedOrigins?: readonly string[]
+  /** Host allowlist; set it for a server on localhost or a private network. See {@link McpHttpOptions}. */
+  readonly allowedHosts?: readonly string[]
+  /** Shared state for one authenticated MCP session; prefer `resolveState` for multi-session hosts. */
+  readonly state?: McpProtocolState
+  /** Resolve a session-scoped request registry after per-message authorization. */
+  readonly resolveState?: McpHttpOptions["resolveState"]
   /**
    * Per-message authorization, applied after the message parses and before any tool runs. Return
    * `false` to answer 403 with a JSON-RPC `unauthorized` error (`MCP_ERROR.UNAUTHORIZED`) and no result.
@@ -71,7 +82,10 @@ export interface McpServer {
   readonly features: McpServerFeatures
   readonly serverInfo: { name: string; version: string }
   /** Web `fetch` handler - mount at `POST /mcp` (GET is a health page, OPTIONS the CORS preflight). */
-  fetch(request: Request, overrides?: Pick<McpHttpOptions, "authorizeMessage">): Promise<Response>
+  fetch(
+    request: Request,
+    overrides?: Pick<McpHttpOptions, "authorizeMessage" | "state" | "resolveState">,
+  ): Promise<Response>
   /** Dispatch one JSON-RPC message directly (no HTTP) - for headless verification and unit tests. */
   handle(message: JsonRpcRequest): Promise<JsonRpcResponse | null>
   /**
@@ -103,12 +117,22 @@ export function createMcpServer(opts: CreateMcpServerOptions): McpServer {
         features,
         ...(opts.health !== undefined ? { health: opts.health } : {}),
         ...(opts.maxBodyBytes !== undefined ? { maxBodyBytes: opts.maxBodyBytes } : {}),
+        ...(opts.maxResponseBytes !== undefined ? { maxResponseBytes: opts.maxResponseBytes } : {}),
+        ...(opts.allowAnyOrigin === true ? { allowAnyOrigin: true } : {}),
         ...(opts.allowedOrigins !== undefined ? { allowedOrigins: opts.allowedOrigins } : {}),
+        ...(opts.allowedHosts !== undefined ? { allowedHosts: opts.allowedHosts } : {}),
+        ...(opts.state === undefined ? {} : { state: opts.state }),
+        ...(opts.resolveState === undefined ? {} : { resolveState: opts.resolveState }),
         ...(opts.authorizeMessage !== undefined ? { authorizeMessage: opts.authorizeMessage } : {}),
         ...(overrides?.authorizeMessage !== undefined
           ? { authorizeMessage: overrides.authorizeMessage }
           : {}),
+        ...(overrides?.state === undefined ? {} : { state: overrides.state }),
+        ...(overrides?.resolveState === undefined ? {} : { resolveState: overrides.resolveState }),
+      }),
+    handle: (message) =>
+      handleRpc(message, tools, serverInfo, features, {
+        ...(opts.state === undefined ? {} : { state: opts.state }),
       }),
-    handle: (message) => handleRpc(message, tools, serverInfo, features),
   }
 }