devframe 0.8.2 → 0.9.0-beta.1

package/dist/adapters/mcp.d.mts

@@ -1,4 +1,5 @@
-import { b as DevframeNodeContext, r as DevframeDefinition } from "../devframe-mQ4qZAuo.mjs";
+import { r as DevframeDefinition, x as DevframeNodeContext } from "../devframe-Bdd9YXTy.mjs";
+import { H3 } from "h3";
 import "@modelcontextprotocol/server";
 //#region src/adapters/mcp/build-server.d.ts
 interface CreateMcpServerOptions {
@@ -85,4 +86,27 @@ interface McpFetchHandler {
  */
 declare function createMcpFetchHandler(ctx: DevframeNodeContext, options: CreateMcpFetchHandlerOptions): McpFetchHandler;
 //#endregion
-export { type CreateMcpFetchHandlerOptions, type CreateMcpServerOptions, type McpFetchHandler, type McpServerHandle, createMcpFetchHandler, createMcpServer };
+//#region src/adapters/mcp/http.d.ts
+interface MountMcpHttpOptions extends CreateMcpFetchHandlerOptions {}
+interface MountedMcpHttp {
+  /** Tear down every live MCP session (closes servers, drops subscriptions). */
+  dispose: () => Promise<void>;
+}
+/**
+ * Mount an MCP Streamable-HTTP endpoint on an h3 app at `path` — the h3
+ * binding over {@link createMcpFetchHandler}, which owns the sessions, the
+ * origin gate, and the transport plumbing.
+ *
+ * The handler is web-standard — it 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
+ */
+declare function mountMcpHttp(app: H3, ctx: DevframeNodeContext, path: string, options: MountMcpHttpOptions): MountedMcpHttp;
+//#endregion
+export { type CreateMcpFetchHandlerOptions, type CreateMcpServerOptions, type McpFetchHandler, type McpServerHandle, type MountMcpHttpOptions, type MountedMcpHttp, createMcpFetchHandler, createMcpServer, mountMcpHttp };

package/dist/adapters/mcp.mjs

@@ -1,2 +1,2 @@
-import { n as createMcpServer, t as createMcpFetchHandler } from "../fetch-BKaD0Vb3.mjs";
-export { createMcpFetchHandler, createMcpServer };
+import { i as createMcpServer, n as mountMcpHttp, r as createMcpFetchHandler } from "../http-DLr_cJZ7.mjs";
+export { createMcpFetchHandler, createMcpServer, mountMcpHttp };

package/dist/cli/main.mjs

@@ -1,5 +1,5 @@
-import { t as diagnostics } from "../diagnostics-D7wM2cwM.mjs";
-import { n as probeDevframeOrigin, t as listLiveDevframeInstances } from "../instance-registry-BnnA2Eoh.mjs";
+import { t as diagnostics } from "../diagnostics-DLYH5oD3.mjs";
+import { n as listLiveDevframeInstances, r as probeDevframeOrigin } from "../instance-registry-BQqGoDO9.mjs";
 import { t as toAgentToolName } from "../agent-tool-name-C3b5vEwJ.mjs";
 import { Diagnostic } from "nostics";
 import process from "node:process";

package/dist/client/index.d.mts

@@ -1,7 +1,8 @@
-import { $ as DevframeRpcServerFunctions, F as ScopedSharedStates, I as SettingsForNamespace, J as RpcSharedStateHost, N as ScopedRpcFn, O as DevframeSettings, P as ScopedServerFunctions, Q as DevframeRpcClientFunctions, _ as ConnectionMeta, at as StreamReader, ht as SharedState, jt as EventEmitter, ot as StreamSink, q as RpcSharedStateGetOptions } from "../devframe-mQ4qZAuo.mjs";
+import { $ as DevframeRpcClientFunctions, F as ScopedServerFunctions, I as ScopedSharedStates, J as RpcSharedStateGetOptions, L as SettingsForNamespace, Mt as EventEmitter, P as ScopedRpcFn, Y as RpcSharedStateHost, _ as ConnectionMeta, et as DevframeRpcServerFunctions, gt as SharedState, k as DevframeSettings, ot as StreamReader, st as StreamSink } from "../devframe-Bdd9YXTy.mjs";
+import { f as RpcCacheManager, p as RpcCacheOptions } from "../index-DSCq4M4q.mjs";
 import { _ as RpcFunctionDefinition, w as RpcFunctionsCollector } from "../types-CnJSgRVa.mjs";
-import { E as RpcCacheOptions, T as RpcCacheManager } from "../index-Dbw1p5ch.mjs";
-import { t as WsRpcChannelOptions } from "../ws-client-B6Tnr0ic.mjs";
+import { t as SseRpcChannelOptions } from "../sse-client-BsIK3hMD.mjs";
+import { t as WsRpcChannelOptions } from "../ws-client-CdNuATYa.mjs";
 import { BirpcOptions, BirpcReturn } from "birpc";
 //#region src/client/connection.d.ts
 interface DevframeConnection {
@@ -251,7 +252,24 @@ interface DevframeRpcClientOptions extends SetupDevframeConnectionOptions {
    * @default true
    */
   simpleAuth?: boolean;
+  /**
+   * Which live transport to connect over:
+   *
+   *  - `'auto'` (default) — trust the server's advertisement: its declared
+   *    primary (`backend`), preferring the WebSocket when both endpoints are
+   *    present. A server that couldn't bind a socket advertises SSE as its
+   *    primary, so no client-side fallback probing is needed.
+   *  - `'websocket'` / `'sse'` — pin one transport; connecting fails with a
+   *    clear error when the server doesn't advertise it. Reach for
+   *    `transport: 'sse'` when an intermediary silently strips WS upgrades —
+   *    something the server cannot detect.
+   *
+   * A `static` backend ignores this option (there is no live transport).
+   */
+  transport?: 'auto' | 'websocket' | 'sse';
   wsOptions?: Partial<WsRpcChannelOptions>;
+  /** Channel overrides for the SSE transport — the `wsOptions` counterpart. */
+  sseOptions?: Partial<SseRpcChannelOptions>;
   rpcOptions?: Partial<BirpcOptions<DevframeRpcServerFunctions, DevframeRpcClientFunctions, boolean>>;
   cacheOptions?: boolean | Partial<RpcCacheOptions>;
   /**
@@ -282,10 +300,16 @@ interface DevframeRpcClient {
    */
   readonly status: DevframeConnectionStatus;
   /**
-   * The most recent connection-level error (WebSocket error, refused trust, or
-   * failed connection-meta load), or `null` when the connection is healthy.
+   * The most recent connection-level error (transport error, refused trust,
+   * or failed connection-meta load), or `null` when the connection is healthy.
    */
   readonly connectionError: Error | null;
+  /**
+   * The transport this client is actually connected over — `'websocket'`,
+   * `'sse'`, or `'static'`. Reflects the resolution of the `transport`
+   * option against the server's advertisement.
+   */
+  readonly transport: 'websocket' | 'sse' | 'static';
   /**
    * The complete connection used by this client, including the metadata source
    * URL external viewers use to resolve relative resources.
@@ -362,8 +386,27 @@ interface DevframeRpcClient {
     <NS extends string>(namespace: NS): DevframeScopedClientContext<NS, SettingsForNamespace<NS>>;
     (namespace?: null | ''): DevframeRpcClient;
   };
+  /**
+   * Close the connection. A `static` backend is a no-op (there is no live socket to close);
+   * a `websocket` backend closes the underlying `WebSocket`, which the server observes as a
+   * normal disconnect. Mirrors {@link WsRpcTransport.close} on the server side.
+   *
+   * There is no corresponding "reconnect" — a closed client is done. Discard it and call
+   * {@link getDevframeRpcClient} again to reconnect.
+   *
+   * Optional so a `DevframeRpcClientMode` implemented before this method existed — a custom
+   * transport, a hand-typed mock — still satisfies the interface; an absent `close` is treated
+   * as nothing to close.
+   */
+  close?: () => void;
 }
 interface DevframeRpcClientMode {
+  /**
+   * The transport this mode speaks. Optional so a mode implemented before
+   * this field existed — a custom transport, a hand-typed mock — still
+   * satisfies the interface; an absent value reads as `'websocket'`.
+   */
+  readonly transport?: 'websocket' | 'sse' | 'static';
   readonly isTrusted: boolean;
   readonly status: DevframeConnectionStatus;
   readonly connectionError: Error | null;
@@ -378,7 +421,17 @@ interface DevframeRpcClientMode {
   call: DevframeRpcClient['call'];
   callEvent: DevframeRpcClient['callEvent'];
   callOptional: DevframeRpcClient['callOptional'];
+  /** See {@link DevframeRpcClient.close}. */
+  close?: () => void;
 }
+/**
+ * Resolve the requested `transport` option against what the server
+ * advertises. `'auto'` trusts the advertisement — the server's declared
+ * primary (`backend`), preferring the WebSocket when both endpoints are
+ * present; an explicit `'websocket'` / `'sse'` pins that transport and
+ * throws when the server doesn't advertise it.
+ */
+declare function resolveClientTransport(requested: 'auto' | 'websocket' | 'sse', meta: ConnectionMeta): 'websocket' | 'sse' | 'static';
 declare function getDevframeRpcClient(options?: DevframeRpcClientOptions): Promise<DevframeRpcClient>;
 //#endregion
 //#region src/client/otp.d.ts
@@ -431,6 +484,17 @@ interface WsUrlLocation {
  */
 declare function resolveWsUrl(websocket: ConnectionMeta['websocket'], metaBaseUrl: string, loc: WsUrlLocation): string;
 //#endregion
+//#region src/client/rpc-sse.d.ts
+/**
+ * Resolve a {@link ConnectionMeta.sse} descriptor into a concrete
+ * `http(s)://` URL, with the same proxy-safe rules as `resolveWsUrl`: the
+ * object / relative-path forms resolve against where `__connection.json`
+ * was loaded (the client trusts its own location, never a server-baked
+ * hostname), while an explicit `port`/`host` (or a full `http(s)://` URL
+ * string) opts into a cross-origin endpoint.
+ */
+declare function resolveSseUrl(sse: ConnectionMeta['sse'], metaBaseUrl: string, loc: WsUrlLocation): string;
+//#endregion
 //#region src/client/settings.d.ts
 /**
  * Build the client-side `settings` surface for a scope namespace. Mirrors
@@ -441,4 +505,4 @@ declare function createClientSettings<T extends Record<string, any> = Record<str
 //#region src/client/index.d.ts
 declare const connectDevframe: typeof getDevframeRpcClient;
 //#endregion
-export { DevframeClientRpcHost, DevframeConnection, DevframeConnectionError, DevframeConnectionErrorKind, DevframeConnectionStatus, DevframeRpcClient, DevframeRpcClientCall, DevframeRpcClientCallEvent, DevframeRpcClientCallOptional, DevframeRpcClientMode, DevframeRpcClientOptions, DevframeRpcContext, DevframeScopedClientContext, DevframeScopedClientRpc, DevframeScopedClientStreamingHost, RpcClientEvents, RpcStreamingClientHost, SetupDevframeConnectionOptions, StreamingSubscribeOptions, type WsUrlLocation, authenticateWithUrlOtp, connectDevframe, consumeOtpFromUrl, createClientSettings, createRpcStreamingClientHost, createScopedClientContext, getDevframeConnection, getDevframeRpcClient, isCallableStatus, readOtpFromUrl, registerDevframeViewerOrigin, resolveWsUrl, setupDevframeConnection };
+export { DevframeClientRpcHost, DevframeConnection, DevframeConnectionError, DevframeConnectionErrorKind, DevframeConnectionStatus, DevframeRpcClient, DevframeRpcClientCall, DevframeRpcClientCallEvent, DevframeRpcClientCallOptional, DevframeRpcClientMode, DevframeRpcClientOptions, DevframeRpcContext, DevframeScopedClientContext, DevframeScopedClientRpc, DevframeScopedClientStreamingHost, RpcClientEvents, RpcStreamingClientHost, SetupDevframeConnectionOptions, StreamingSubscribeOptions, type WsUrlLocation, authenticateWithUrlOtp, connectDevframe, consumeOtpFromUrl, createClientSettings, createRpcStreamingClientHost, createScopedClientContext, getDevframeConnection, getDevframeRpcClient, isCallableStatus, readOtpFromUrl, registerDevframeViewerOrigin, resolveClientTransport, resolveSseUrl, resolveWsUrl, setupDevframeConnection };