devframe 0.6.0-beta.2 → 0.6.0

package/dist/{dev-BaX8fLH2.mjs → dev-zC5542OV.mjs}

@@ -1,12 +1,13 @@
 import { DEVFRAME_CONNECTION_META_FILENAME } from "./constants.mjs";
-import { n as createHostContext, t as createH3DevframeHost } from "./host-h3-C5SZlk03.mjs";
-import { t as startHttpAndWs } from "./server-Dl6TU5LE.mjs";
+import { a as diagnostics } from "./storage-yrUZaiib.mjs";
+import { n as createHostContext, t as createH3DevframeHost } from "./host-h3-Dsf-Tgwx.mjs";
+import { t as startHttpAndWs } from "./server-CAsvfJNK.mjs";
 import { n as resolveBasePath, t as normalizeBasePath } from "./_shared-bWRzeSa0.mjs";
-import { t as open } from "./open-Dusa2Zzd.mjs";
+import { t as open } from "./open-Deb5xmIT.mjs";
 import { mountStaticHandler } from "./utils/serve-static.mjs";
 import { resolve } from "pathe";
-import { networkInterfaces } from "node:os";
 import process$1 from "node:process";
+import { networkInterfaces } from "node:os";
 import { H3 } from "h3";
 import { createServer } from "node:net";
 import { joinURL, withBase as withBase$1, withLeadingSlash, withoutLeadingSlash } from "ufo";
@@ -284,14 +285,40 @@ async function createDevServer(def, options = {}) {
 	});
 	const setupInfo = { flags };
 	await def.setup(ctx, setupInfo);
+	const mcpConfig = resolveMcpConfig(options.mcp ?? def.cli?.mcp);
+	let mcpDispose;
+	let mcpMeta;
+	if (mcpConfig) {
+		const mcpRoute = withoutLeadingSlash(mcpConfig.path ?? "__mcp");
+		const mcpPath = joinURL(basePath, mcpRoute);
+		let mountMcpHttp;
+		try {
+			({mountMcpHttp} = await import("./http-COX960WK.mjs"));
+		} catch (error) {
+			const reason = error instanceof Error ? error.message : String(error);
+			throw diagnostics.DF0017({
+				transport: "http",
+				reason,
+				cause: error
+			});
+		}
+		mcpDispose = mountMcpHttp(app, ctx, mcpPath, {
+			serverName: `${def.id} (devframe)`,
+			serverVersion: def.version ?? "0.0.0",
+			exposeSharedState: true,
+			allowedOrigins: mcpConfig.allowedOrigins
+		}).dispose;
+		mcpMeta = { path: mcpRoute };
+	}
 	const { bindPath, wsPort, meta } = resolveWsConnection(def, options, basePath);
 	const connectionMetaPath = joinURL(basePath, DEVFRAME_CONNECTION_META_FILENAME);
 	app.use(connectionMetaPath, () => ({
 		backend: "websocket",
-		websocket: meta
+		websocket: meta,
+		...mcpMeta ? { mcp: mcpMeta } : {}
 	}));
 	if (distDir) mountStaticHandler(app, basePath, resolve(distDir));
-	return startHttpAndWs({
+	const started = await startHttpAndWs({
 		context: ctx,
 		host,
 		port,
@@ -304,6 +331,22 @@ async function createDevServer(def, options = {}) {
 			await maybeOpenBrowser(def, flags, `${info.origin}${basePath}`, options.openBrowser);
 		}
 	});
+	if (mcpDispose) {
+		const closeServer = started.close;
+		started.close = async () => {
+			await mcpDispose();
+			await closeServer();
+		};
+	}
+	return started;
+}
+/**
+* Normalize the `cli.mcp` / `mcp` option (`boolean | McpRouteOptions`) into
+* concrete options, or `undefined` when the MCP route is disabled.
+*/
+function resolveMcpConfig(mcp) {
+	if (!mcp) return void 0;
+	return mcp === true ? {} : mcp;
 }
 /**
 * Resolve the three WS connection scenarios from the definition / call-site

package/dist/{devframe-D-gr9sBx.d.mts → devframe-BtVHhmwM.d.mts}

@@ -1,5 +1,5 @@
 import { _ as RpcFunctionDefinition } from "./types-DZEx4ffs.mjs";
-import { S as RpcFunctionsCollectorBase } from "./index-CxaPKDXX.mjs";
+import { S as RpcFunctionsCollectorBase } from "./index-Dy6GFDRf.mjs";
 import { t as DevframeNodeRpcSessionMeta } from "./ws-server-Bc2wBHl-.mjs";
 import { CAC } from "cac";
 import { GenericSchema, InferOutput } from "valibot";
@@ -471,9 +471,13 @@ interface DevframeRpcServerFunctions {
    * by the host adapter (e.g. Vite DevTools); the standalone server registers
    * an auto-trust noop when `auth: false`.
    *
+   * Named with the `anonymous:` prefix (see `isAnonymousRpcMethod`) so it is
+   * reachable before the connection is trusted — this is the *only* rule the
+   * pre-trust gate applies, no per-method allowlist.
+   *
    * @internal
    */
-  'devframe:anonymous:auth': (params: {
+  'anonymous:devframe:auth': (params: {
     authToken: string;
     ua: string;
     origin: string;
@@ -485,15 +489,27 @@ interface DevframeRpcServerFunctions {
    * node-issued bearer token, returning the token on success or `null`. The
    * handler is provided by the host adapter on top of `exchangeTempAuthCode`.
    *
+   * Named with the `anonymous:` prefix (see `isAnonymousRpcMethod`) so it is
+   * reachable before the connection is trusted.
+   *
    * @internal
    */
-  'devframe:auth:exchange': (params: {
+  'anonymous:devframe:auth:exchange': (params: {
     code: string;
     ua: string;
     origin: string;
   }) => Promise<{
     authToken: string | null;
   }>;
+  /**
+   * Self-revoke: the caller asks the server to revoke its own bearer token
+   * (if any) and drop to untrusted. Requires an already-trusted caller, so
+   * unlike the two handshake methods above it does **not** carry the
+   * `anonymous:` prefix. Registered by `recipes/interactive-auth`.
+   *
+   * @internal
+   */
+  'devframe:auth:revoke': () => Promise<void>;
   /**
    * Subscribe a client to a shared-state key. Wired by
    * `RpcSharedStateHost`; do not register manually.
@@ -1204,6 +1220,16 @@ interface ConnectionMeta {
    *     URL with its protocol swapped, or a path resolved same-origin.
    */
   websocket?: number | string | ConnectionMetaWebsocket;
+  /**
+   * Present when the dev server exposes a route-based MCP endpoint
+   * (`cli.mcp`). Advertises the MCP Streamable-HTTP route so in-browser
+   * tooling (e.g. an MCP inspector) can discover it without guessing the
+   * path. `path` is relative to `__connection.json`'s location, like the
+   * WebSocket `path`.
+   */
+  mcp?: {
+    path: string;
+  };
   /**
    * Names of RPC functions that have declared `jsonSerializable: true`.
    * Used by the WS / static client to dispatch the per-call wire
@@ -1269,6 +1295,36 @@ interface DevframeWsOptions {
    */
   url?: string;
 }
+/**
+ * Configuration for the route-based MCP server mounted alongside the dev
+ * server (opt-in via {@link DevframeCliOptions.mcp}). The endpoint speaks
+ * the MCP Streamable-HTTP transport over the same origin as the SPA,
+ * exposing the definition's `ctx.agent` tools + shared-state resources to
+ * external MCP clients connected to the *running* server.
+ *
+ * @experimental The agent-native surface is experimental and may change
+ * without a major version bump until it stabilizes.
+ */
+interface McpRouteOptions {
+  /**
+   * Route segment the MCP endpoint binds to, relative to the SPA base.
+   * Default: `__mcp` (i.e. `/__mcp` standalone, `/__<id>/__mcp` hosted).
+   */
+  path?: string;
+  /**
+   * Extra `Origin` header values to accept beyond the loopback default
+   * (`localhost`/`127.0.0.1`/`::1` and any `Origin`-less native client).
+   * Add your LAN/tunnel origin here when reaching the endpoint from another
+   * host, mirroring the WS transport's origin gate. Pass `false` to disable
+   * origin checking entirely (not recommended). Default: loopback-only.
+   *
+   * This is the endpoint's DNS-rebinding protection — the shared
+   * `isAllowedOrigin` gate the WS upgrade already uses, applied as external
+   * middleware (the approach the MCP SDK now recommends over its own
+   * deprecated `allowedHosts`/`allowedOrigins` transport flags).
+   */
+  allowedOrigins?: readonly string[] | false;
+}
 interface DevframeCliOptions {
   /** Binary name; default: the devframe's `id`. */
   command?: string;
@@ -1295,6 +1351,22 @@ interface DevframeCliOptions {
    * `devtools.clientAuth` today.
    */
   auth?: boolean;
+  /**
+   * Expose a route-based MCP server alongside the dev server, speaking the
+   * MCP Streamable-HTTP transport at `/__mcp` (relative to the base path).
+   * It surfaces the same `ctx.agent` tools + shared-state resources as the
+   * stdio `mcp` command, but against the live, running server.
+   *
+   * - `false` / omitted (default) — no MCP route is mounted.
+   * - `true` — mount at the default `__mcp` route with the loopback-only
+   *   origin gate.
+   * - {@link McpRouteOptions} — customise the route path / allowed origins.
+   *
+   * The `--mcp` / `--no-mcp` CLI flags override this per run.
+   *
+   * @experimental
+   */
+  mcp?: boolean | McpRouteOptions;
   /** Author's SPA dist directory (served as the devframe's UI). */
   distDir?: string;
   /**
@@ -1406,4 +1478,4 @@ interface DevframeDefinition {
 }
 declare function defineDevframe(d: DevframeDefinition): DevframeDefinition;
 //#endregion
-export { ScopedServerFunctions as $, createStreamReader as A, SharedStatePatch as B, BufferedChunk as C, CliFlagsSchema as Ct, StreamReader as D, StreamErrorPayload as E, parseCliFlags as Et, ImmutableObject as F, DevframeScopedNodeContext as G, EntriesToObject as H, ImmutableSet as I, DevframeSettings as J, DevframeScopedNodeRpc as K, SharedState as L, Immutable as M, ImmutableArray as N, StreamSink as O, ImmutableMap as P, ScopedClientFunctions as Q, SharedStateEvents as R, RpcStreamingHost as S, EventsMap as St, CreateStreamSinkOptions as T, defineCliFlags as Tt, PartialWithoutId as U, createSharedState as V, Thenable as W, DevframeSettingsStore as X, DevframeSettingsRegistry as Y, ScopedBroadcastOptions as Z, RpcFunctionsHost as _, AgentToolInput as _t, DevframeDuplicationStrategy as a, DevframeRpcSharedStates as at, RpcStreamingChannel as b, EventEmitter as bt, DevframeSpaOptions as c, DevframeDiagnosticsDefinition as ct, ConnectionMeta as d, AgentHandle as dt, ScopedSharedStates as et, ConnectionMetaWebsocket as f, AgentManifest as ft, RpcBroadcastOptions as g, AgentTool as gt, DevframeNodeRpcSession as h, AgentResourceInput as ht, DevframeDeploymentKind as i, DevframeRpcServerFunctions as it, createStreamSink as j, StreamSinkEvents as k, DevframeWsOptions as l, DevframeDiagnosticsHost as lt, DevframeNodeContext as m, AgentResourceContent as mt, DevframeCliOptions as n, DevframeViewHost as nt, DevframeRuntime as o, DevframeHost as ot, DevframeCapabilities as p, AgentResource as pt, DevframeScopedStreamingHost as q, DevframeDefinition as r, DevframeRpcClientFunctions as rt, DevframeSetupInfo as s, DevframeDefineDiagnosticsOptions as st, DevframeBrowserContext as t, SettingsForNamespace as tt, defineDevframe as u, DevframeDiagnosticsLogger as ut, RpcSharedStateGetOptions as v, DevframeAgentHost as vt, CreateStreamReaderOptions as w, InferCliFlags as wt, RpcStreamingChannelOptions as x, EventUnsubscribe as xt, RpcSharedStateHost as y, DevframeAgentHostEvents as yt, SharedStateOptions as z };
+export { ScopedClientFunctions as $, StreamSinkEvents as A, SharedStateOptions as B, RpcStreamingHost as C, EventsMap as Ct, StreamErrorPayload as D, parseCliFlags as Dt, CreateStreamSinkOptions as E, defineCliFlags as Et, ImmutableMap as F, Thenable as G, createSharedState as H, ImmutableObject as I, DevframeScopedStreamingHost as J, DevframeScopedNodeContext as K, ImmutableSet as L, createStreamSink as M, Immutable as N, StreamReader as O, ImmutableArray as P, ScopedBroadcastOptions as Q, SharedState as R, RpcStreamingChannelOptions as S, EventUnsubscribe as St, CreateStreamReaderOptions as T, InferCliFlags as Tt, EntriesToObject as U, SharedStatePatch as V, PartialWithoutId as W, DevframeSettingsRegistry as X, DevframeSettings as Y, DevframeSettingsStore as Z, RpcBroadcastOptions as _, AgentTool as _t, DevframeDuplicationStrategy as a, DevframeRpcServerFunctions as at, RpcSharedStateHost as b, DevframeAgentHostEvents as bt, DevframeSpaOptions as c, DevframeDefineDiagnosticsOptions as ct, defineDevframe as d, DevframeDiagnosticsLogger as dt, ScopedServerFunctions as et, ConnectionMeta as f, AgentHandle as ft, DevframeNodeRpcSession as g, AgentResourceInput as gt, DevframeNodeContext as h, AgentResourceContent as ht, DevframeDeploymentKind as i, DevframeRpcClientFunctions as it, createStreamReader as j, StreamSink as k, DevframeWsOptions as l, DevframeDiagnosticsDefinition as lt, DevframeCapabilities as m, AgentResource as mt, DevframeCliOptions as n, SettingsForNamespace as nt, DevframeRuntime as o, DevframeRpcSharedStates as ot, ConnectionMetaWebsocket as p, AgentManifest as pt, DevframeScopedNodeRpc as q, DevframeDefinition as r, DevframeViewHost as rt, DevframeSetupInfo as s, DevframeHost as st, DevframeBrowserContext as t, ScopedSharedStates as tt, McpRouteOptions as u, DevframeDiagnosticsHost as ut, RpcFunctionsHost as v, AgentToolInput as vt, BufferedChunk as w, CliFlagsSchema as wt, RpcStreamingChannel as x, EventEmitter as xt, RpcSharedStateGetOptions as y, DevframeAgentHost as yt, SharedStateEvents as z };

package/dist/{dump-DoXkj4ku.mjs → dump-D09PZb7T.mjs}

@@ -5,7 +5,7 @@ import { createHash } from "node:crypto";
 function serialize(o) {
 	return typeof o == "string" ? `'${o}'` : new c().serialize(o);
 }
-const c = /* @__PURE__ */ function() {
+const c = /*@__PURE__*/ function() {
 	class o {
 		#t = /* @__PURE__ */ new Map();
 		compare(t, r) {
@@ -501,14 +501,24 @@ async function getRpcResolvedSetupResult(definition, context) {
 	if (!definition.setup) return {};
 	if (typeof context === "object" && context !== null) {
 		definition.__cache ??= /* @__PURE__ */ new WeakMap();
-		let promise = definition.__cache.get(context);
+		const cache = definition.__cache;
+		let promise = cache.get(context);
 		if (!promise) {
 			promise = Promise.resolve(definition.setup(context));
-			definition.__cache.set(context, promise);
+			promise.catch(() => {
+				if (cache.get(context) === promise) cache.delete(context);
+			});
+			cache.set(context, promise);
 		}
 		return await promise;
 	}
-	definition.__promise ??= Promise.resolve(definition.setup(context));
+	if (!definition.__promise) {
+		const promise = Promise.resolve(definition.setup(context));
+		promise.catch(() => {
+			if (definition.__promise === promise) definition.__promise = void 0;
+		});
+		definition.__promise = promise;
+	}
 	return await definition.__promise;
 }
 async function getRpcHandler(definition, context) {

package/dist/{hash-DFc5WwhO.mjs → hash-PAfnyu2k.mjs}

@@ -2,7 +2,7 @@
 function serialize(o) {
 	return typeof o == "string" ? `'${o}'` : new c().serialize(o);
 }
-const c = /* @__PURE__ */ function() {
+const c = /*@__PURE__*/ function() {
 	class o {
 		#t = /* @__PURE__ */ new Map();
 		compare(t, r) {

package/dist/helpers/vite.d.mts

@@ -1,4 +1,4 @@
-import { r as DevframeDefinition } from "../devframe-D-gr9sBx.mjs";
+import { r as DevframeDefinition } from "../devframe-BtVHhmwM.mjs";
 
 //#region src/helpers/vite.d.ts
 interface ViteDevBridgeOptions {

package/dist/helpers/vite.mjs

@@ -1,8 +1,8 @@
 import { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_WS_ROUTE } from "../constants.mjs";
-import { a as diagnostics } from "../storage-l2ezeend.mjs";
+import { a as diagnostics } from "../storage-yrUZaiib.mjs";
 import { n as resolveBasePath, t as normalizeBasePath } from "../_shared-bWRzeSa0.mjs";
 import { serveStaticNodeMiddleware } from "../utils/serve-static.mjs";
-import { n as resolveDevServerPort, t as createDevServer } from "../dev-BaX8fLH2.mjs";
+import { n as resolveDevServerPort, t as createDevServer } from "../dev-zC5542OV.mjs";
 import { resolve } from "pathe";
 //#region src/helpers/vite.ts
 /**

package/dist/{host-h3-C5SZlk03.mjs → host-h3-Dsf-Tgwx.mjs}

@@ -2,14 +2,14 @@ import { t as devframeReporter } from "./diagnostics-reporter-CsIG85Q5.mjs";
 import { t as diagnostics } from "./diagnostics-BXwBQmoN.mjs";
 import { RpcFunctionsCollectorBase } from "./rpc/index.mjs";
 import { defineRpcFunction } from "./index.mjs";
-import { a as diagnostics$1, i as createEventEmitter, n as createSharedState, r as nanoid, t as createStorage } from "./storage-l2ezeend.mjs";
+import { a as diagnostics$1, i as createEventEmitter, n as createSharedState, r as nanoid, t as createStorage } from "./storage-yrUZaiib.mjs";
 import { defineDiagnostics } from "nostics";
 import { isatty } from "node:tty";
 import { formatWithOptions, inspect } from "node:util";
 import { existsSync } from "node:fs";
 import { join } from "pathe";
-import { homedir } from "node:os";
 import process$1 from "node:process";
+import { homedir } from "node:os";
 //#region src/node/host-agent.ts
 /**
 * Framework-neutral host aggregating the agent-exposed surface of a
@@ -203,11 +203,18 @@ var DevframeDiagnosticsHost = class {
 	}
 };
 //#endregion
-//#region ../../node_modules/.pnpm/obug@2.1.1/node_modules/obug/dist/core.js
+//#region ../../node_modules/.pnpm/obug@2.1.3/node_modules/obug/dist/core.js
+/**
+* Coerce `value`.
+*/
 function coerce(value) {
 	if (value instanceof Error) return value.stack || value.message;
 	return value;
 }
+/**
+* Selects a color for a debug namespace
+* @return An ANSI color code for the given namespace
+*/
 function selectColor(colors, namespace) {
 	let hash = 0;
 	for (let i = 0; i < namespace.length; i++) {
@@ -216,6 +223,10 @@ function selectColor(colors, namespace) {
 	}
 	return colors[Math.abs(hash) % colors.length];
 }
+/**
+* Checks if the given string matches a namespace template, honoring
+* asterisks as wildcards.
+*/
 function matchesTemplate(search, template) {
 	let searchIndex = 0;
 	let templateIndex = 0;
@@ -270,8 +281,8 @@ function createDebug$1(namespace, options) {
 		options.formatArgs.call(debug, diff, args);
 		debug.log(...args);
 	};
-	debug.extend = function(namespace$1, delimiter = ":") {
-		return createDebug$1(this.namespace + delimiter + namespace$1, {
+	debug.extend = function(namespace, delimiter = ":") {
+		return createDebug$1(this.namespace + delimiter + namespace, {
 			useColors: this.useColors,
 			color: this.color,
 			formatArgs: this.formatArgs,
@@ -302,21 +313,24 @@ function createDebug$1(namespace, options) {
 }
 let names = [];
 let skips = [];
-function enable(namespaces$1) {
-	globalNamespaces = namespaces$1;
+function enable(namespaces) {
+	globalNamespaces = namespaces;
 	names = [];
 	skips = [];
 	const split = globalNamespaces.trim().replace(/\s+/g, ",").split(",").filter(Boolean);
 	for (const ns of split) if (ns[0] === "-") skips.push(ns.slice(1));
 	else names.push(ns);
 }
+/**
+* Returns true if the given mode name is enabled, false otherwise.
+*/
 function enabled(name) {
 	for (const skip of skips) if (matchesTemplate(name, skip)) return false;
 	for (const ns of names) if (matchesTemplate(name, ns)) return true;
 	return false;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/obug@2.1.1/node_modules/obug/dist/node.js
+//#region ../../node_modules/.pnpm/obug@2.1.3/node_modules/obug/dist/node.js
 const colors = process.stderr.getColorDepth && process.stderr.getColorDepth() > 2 ? [
 	20,
 	21,
@@ -412,7 +426,10 @@ const inspectOpts = Object.keys(process.env).filter((key) => /^debug_/i.test(key
 	else value = Number(value);
 	obj[prop] = value;
 	return obj;
-}, {});
+}, Object.create(null));
+/**
+* Is stdout a TTY? Colored output is enabled when `true`.
+*/
 function useColors() {
 	return "colors" in inspectOpts ? Boolean(inspectOpts.colors) : isatty(process.stderr.fd);
 }
@@ -420,9 +437,12 @@ function getDate() {
 	if (inspectOpts.hideDate) return "";
 	return `${(/* @__PURE__ */ new Date()).toISOString()} `;
 }
+/**
+* Adds ANSI color escape codes if enabled.
+*/
 function formatArgs(diff, args) {
-	const { namespace: name, useColors: useColors$1 } = this;
-	if (useColors$1) {
+	const { namespace: name, useColors } = this;
+	if (useColors) {
 		const c = this.color;
 		const colorCode = `\u001B[3${c < 8 ? c : `8;5;${c}`}`;
 		const prefix = `  ${colorCode};1m${name} \u001B[0m`;
@@ -437,10 +457,16 @@ const defaultOptions = {
 	useColors: useColors(),
 	formatArgs,
 	formatters: {
+		/**
+		* Map %o to `util.inspect()`, all on a single line.
+		*/
 		o(v) {
 			this.inspectOpts.colors = this.useColors;
 			return inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
 		},
+		/**
+		* Map %O to `util.inspect()`, allowing multiple lines if needed.
+		*/
 		O(v) {
 			this.inspectOpts.colors = this.useColors;
 			return inspect(v, this.inspectOpts);

package/dist/http-COX960WK.mjs

@@ -0,0 +1,114 @@
+import { isAllowedOrigin } from "./rpc/transports/ws-server.mjs";
+import { t as buildMcpServerFromContext } from "./build-server-0jWgMrz-.mjs";
+import { randomUUID } from "node:crypto";
+import { defineHandler } from "h3";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+//#region src/adapters/mcp/http.ts
+/**
+* Mount an MCP Streamable-HTTP endpoint on an h3 app at `path`.
+*
+* Each MCP session gets its own {@link WebStandardStreamableHTTPServerTransport}
+* and MCP server (built from the shared, live `ctx` via
+* `buildMcpServerFromContext`), correlated by the `Mcp-Session-Id` header:
+* an `initialize` POST spins up a session; later requests route to it; a
+* `DELETE` (or client disconnect) tears it down.
+*
+* The transport is web-standard — its `handleRequest` takes the h3 event's
+* web `Request` and returns a web `Response` (an SSE `ReadableStream` body
+* for the server→client stream). We copy that response onto `event.res` and
+* return its body rather than returning the `Response` object directly, so a
+* legitimate MCP 404 (unknown session) isn't swallowed by h3's
+* "Response-with-404 falls through to the next handler" rule (which would
+* otherwise hand the request to the SPA static catch-all).
+*
+* @experimental
+*/
+function mountMcpHttp(app, ctx, path, options) {
+	const sessions = /* @__PURE__ */ new Map();
+	const allowedOrigins = options.allowedOrigins;
+	function drop(sessionId) {
+		const session = sessions.get(sessionId);
+		if (!session) return;
+		sessions.delete(sessionId);
+		session.dispose();
+	}
+	async function createSession() {
+		let session;
+		const transport = new WebStandardStreamableHTTPServerTransport({
+			sessionIdGenerator: () => randomUUID(),
+			onsessioninitialized: (id) => {
+				sessions.set(id, session);
+			},
+			onsessionclosed: (id) => {
+				drop(id);
+			}
+		});
+		const { server, dispose } = buildMcpServerFromContext(ctx, {
+			serverName: options.serverName,
+			serverVersion: options.serverVersion,
+			exposeSharedState: options.exposeSharedState
+		});
+		session = {
+			transport,
+			dispose: async () => {
+				dispose();
+				await server.close();
+			}
+		};
+		transport.onclose = () => {
+			if (transport.sessionId) drop(transport.sessionId);
+		};
+		await server.connect(transport);
+		return session;
+	}
+	app.use(path, defineHandler(async (event) => {
+		const req = event.req;
+		const origin = req.headers.get("origin") ?? void 0;
+		if (allowedOrigins !== false && !isAllowedOrigin(origin, allowedOrigins ?? [])) {
+			event.res.status = 403;
+			return "Forbidden: origin not allowed";
+		}
+		const sessionId = req.headers.get("mcp-session-id") ?? void 0;
+		let session = sessionId ? sessions.get(sessionId) : void 0;
+		if (!session && req.method === "POST") {
+			let body;
+			try {
+				body = await req.json();
+			} catch {
+				body = void 0;
+			}
+			if (!sessionId && isInitializeRequest(body)) session = await createSession();
+			else {
+				event.res.status = sessionId ? 404 : 400;
+				return sessionId ? "Not Found: unknown MCP session" : "Bad Request: no valid session ID and not an initialize request";
+			}
+			return respond(event, await session.transport.handleRequest(req, { parsedBody: body }));
+		}
+		if (!session) {
+			event.res.status = sessionId ? 404 : 400;
+			return sessionId ? "Not Found: unknown MCP session" : "Bad Request: missing MCP session ID";
+		}
+		return respond(event, await session.transport.handleRequest(req));
+	}));
+	return { dispose: async () => {
+		const live = [...sessions.values()];
+		sessions.clear();
+		await Promise.all(live.map((session) => session.dispose()));
+	} };
+}
+/**
+* Copy a web `Response` from the MCP transport onto the h3 event's response
+* and return its body. Returning the body (a `ReadableStream` or `null`)
+* rather than the `Response` object avoids h3's 404-fall-through behavior.
+*/
+function respond(event, response) {
+	event.res.status = response.status;
+	event.res.statusText = response.statusText;
+	response.headers.forEach((value, key) => {
+		event.res.headers.set(key, value);
+	});
+	return response.body ?? "";
+}
+//#endregion
+export { mountMcpHttp };

package/dist/index-ByaMT1Xp.d.mts

@@ -0,0 +1,107 @@
+import { R as SharedState, g as DevframeNodeRpcSession, h as DevframeNodeContext } from "./devframe-BtVHhmwM.mjs";
+import { v as RpcFunctionDefinitionAny } from "./types-DZEx4ffs.mjs";
+import { n as InternalAnonymousAuthStorage } from "./context-UX9qUDK7.mjs";
+import { Peer } from "crossws";
+
+//#region src/node/auth/handler.d.ts
+/**
+ * A ready-made pre-auth RPC handler, as produced by
+ * `devframe/recipes/interactive-auth`'s `createInteractiveAuth`. Bundles
+ * everything a host adapter needs to wire an authenticated server:
+ * the handshake RPC functions, the resolver gate, the connect-time trust
+ * hook, and the startup banner.
+ *
+ * `startHttpAndWs` accepts one of these directly via its `auth` option —
+ * see {@link https://devfra.me | devframe}'s server docs — or a host can
+ * wire the four pieces itself against a lower-level transport.
+ */
+interface DevframeAuthHandler {
+  /**
+   * `anonymous:devframe:auth` + `anonymous:devframe:auth:exchange` (the
+   * handshake) and `devframe:auth:revoke` (self-revoke) — register these on
+   * the RPC host (e.g. `rpcHost.register(fn)` for each).
+   */
+  rpcFunctions: RpcFunctionDefinitionAny[];
+  /**
+   * Resolver gate: whether `methodName` is callable given `session`'s
+   * current trust state. Defaults to allowing any `anonymous:`-prefixed
+   * method (see `isAnonymousRpcMethod`) plus anything once the session is
+   * trusted.
+   */
+  authorize: (methodName: string, session: DevframeNodeRpcSession) => boolean;
+  /**
+   * Connect-time trust: reads a bearer token off the peer's upgrade request
+   * (an `Authorization: Bearer <token>` header, or a static/pre-shared
+   * token from `clientAuthTokens`) and, when valid, marks the session
+   * trusted immediately — before the client's own handshake call.
+   */
+  onConnect: (peer: Peer, session: DevframeNodeRpcSession) => void;
+  /**
+   * Print the current one-time code and its magic-link URL. Devframe stays
+   * headless — call this yourself once the server is listening. Safe to
+   * call repeatedly; it only prints once per code.
+   */
+  printBanner: () => void;
+}
+//#endregion
+//#region src/node/auth/revoke.d.ts
+/**
+ * Flip `isTrusted` to false on any live WS clients connected with `token`
+ * and broadcast the `auth:revoked` event so they can react.
+ *
+ * Shared between persisted-auth revocation and remote-dock token revocation.
+ */
+declare function revokeActiveConnectionsForToken(context: DevframeNodeContext, token: string): Promise<void>;
+/**
+ * Revoke an auth token: remove from storage and notify all connected clients
+ * using this token that they are no longer trusted.
+ */
+declare function revokeAuthToken(context: DevframeNodeContext, storage: SharedState<InternalAnonymousAuthStorage>, token: string): Promise<void>;
+//#endregion
+//#region src/node/auth/state.d.ts
+/**
+ * The current one-time authentication code. Display this to the user (e.g. in
+ * the dev-server terminal) so they can type it into the browser to authenticate.
+ */
+declare function getTempAuthCode(): string;
+/**
+ * Rotate the authentication code, resetting its expiry window and failed-attempt
+ * counter. Call this when a new authentication flow begins (e.g. when an
+ * untrusted client starts authenticating) so the displayed code is freshly
+ * valid for its full TTL.
+ */
+declare function refreshTempAuthCode(): string;
+/**
+ * Build a "magic link" authentication URL that embeds a one-time code (OTP) as
+ * a query parameter. Opening it authenticates the client without typing — print
+ * it on startup (devframe stays headless, so the host prints its own banner).
+ * Defaults to the current code; the link is subject to the same TTL.
+ */
+declare function buildOtpAuthUrl(baseUrl: string, code?: string): string;
+/**
+ * Re-authenticate a connection that presents a previously-issued bearer token.
+ * Returns `true` and marks the session trusted when the token is known.
+ *
+ * Used by the `anonymous:devframe:auth` handler so a client that already
+ * authenticated (token persisted in the browser) is trusted on reconnect
+ * without entering the code again.
+ */
+declare function verifyAuthToken(token: string, session: DevframeNodeRpcSession, storage: SharedState<InternalAnonymousAuthStorage>): boolean;
+/**
+ * Exchange a one-time authentication code for a fresh, node-issued bearer token.
+ *
+ * On success this mints a high-entropy token, records it in the trusted store,
+ * marks the calling session trusted, rotates the code, and returns the token
+ * for the client to persist. Returns `null` on any failure.
+ *
+ * Because the code is short and human-typed, verification is hardened against
+ * brute force: it enforces a time-to-live, compares in constant time, and
+ * rotates the code after {@link TEMP_AUTH_MAX_ATTEMPTS} failed attempts so an
+ * attacker cannot keep guessing against the same code.
+ */
+declare function exchangeTempAuthCode(code: string, session: DevframeNodeRpcSession, info: {
+  ua: string;
+  origin: string;
+}, storage: SharedState<InternalAnonymousAuthStorage>): string | null;
+//#endregion
+export { verifyAuthToken as a, DevframeAuthHandler as c, refreshTempAuthCode as i, exchangeTempAuthCode as n, revokeActiveConnectionsForToken as o, getTempAuthCode as r, revokeAuthToken as s, buildOtpAuthUrl as t };

package/dist/{index-CxaPKDXX.d.mts → index-Dy6GFDRf.d.mts}

@@ -16,6 +16,7 @@ declare class RpcCacheManager {
   constructor(options: RpcCacheOptions);
   updateOptions(options: Partial<RpcCacheOptions>): void;
   cached<T>(m: string, a: unknown[]): T | undefined;
+  has(m: string, a: unknown[]): boolean;
   apply(req: {
     m: string;
     a: unknown[];