devframe 0.9.0-beta.2 → 0.9.0-beta.4

package/dist/_shared-CttmCMBi.mjs

@@ -1,70 +0,0 @@
-import "./constants.mjs";
-import { n as getPort } from "./dist-D8jAMwxU.mjs";
-import { cleanDoubleSlashes, withLeadingSlash, withTrailingSlash, withoutLeadingSlash } from "ufo";
-//#region src/adapters/_shared.ts
-const DEFAULT_PORT = 9999;
-/**
-* Resolve the mount base path for a devframe's SPA. Hosted adapters
-* (`vite`, `embedded`) default to `/__<id>/` so they don't collide
-* with the host app; standalone adapters (`cli`, `spa`, `build`)
-* default to `/` because they own the origin.
-*
-* The devframe author can override with `basePath` on the definition.
-*/
-function resolveBasePath(def, kind) {
-	if (def.basePath) return normalizeBasePath(def.basePath);
-	return kind === "standalone" ? "/" : `/__${def.id}/`;
-}
-function normalizeBasePath(base) {
-	return cleanDoubleSlashes(withTrailingSlash(withLeadingSlash(base)));
-}
-/**
-* Resolve the listening port for `createDevServer` (and `createHandler`'s
-* side-car tiers), honoring the definition's `cli.port` / `cli.portRange` /
-* `cli.random` settings. Exposed separately so authors who run their own
-* argv parsing can resolve a port up-front (to print it, log it, etc.)
-* before starting the server.
-*/
-async function resolveDevServerPort(def, options = {}) {
-	const host = options.host ?? def.cli?.host ?? "localhost";
-	const portOptions = {
-		port: options.defaultPort ?? def.cli?.port ?? DEFAULT_PORT,
-		host
-	};
-	if (def.cli?.portRange) portOptions.portRange = def.cli.portRange;
-	if (def.cli?.random) portOptions.random = def.cli.random;
-	return getPort(portOptions);
-}
-/**
-* 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 `mcp` entry a `__connection.json` should advertise for a dev
-* server started with the given `mcp` option (falling back to `def.cli?.mcp`,
-* exactly like `createDevServer`), or `undefined` when the route is
-* disabled.
-*
-* Hosted bridges that hand-roll their connection meta pass the side-car
-* `port`: the advertised path becomes absolute (the side-car mounts at `/`)
-* and the client dials `<page-host>:<port><path>`. Without `port` the path
-* stays relative, resolved against `__connection.json`'s own location (the
-* same-server default).
-*
-* @experimental
-*/
-function resolveMcpConnectionMeta(def, mcp, port) {
-	const config = resolveMcpConfig(mcp ?? def.cli?.mcp);
-	if (!config) return void 0;
-	const route = withoutLeadingSlash(config.path ?? "__mcp");
-	return port != null ? {
-		path: withLeadingSlash(route),
-		port
-	} : { path: route };
-}
-//#endregion
-export { resolveMcpConnectionMeta as i, resolveBasePath as n, resolveDevServerPort as r, normalizeBasePath as t };

package/dist/helpers/vite.d.mts

@@ -1,104 +0,0 @@
-import { f as McpRouteOptions, p as DevframeAuthHandler, r as DevframeDefinition } from "../devframe-Bdd9YXTy.mjs";
-import { IncomingMessage, Server, ServerResponse } from "node:http";
-//#region src/helpers/vite.d.ts
-interface ViteDevBridgeOptions {
-  /**
-   * Mount base. Defaults to `def.basePath ?? '/__<id>/'` for this hosted
-   * adapter — the devframe shares the origin with the host Vite app.
-   *
-   * Relative spellings like `'./'` (common for base-agnostic Nuxt builds)
-   * are normalized to absolute paths so they compose with Vite's connect
-   * router.
-   */
-  base?: string;
-  /**
-   * Dev-time middleware mode. When set, the host app owns the SPA and
-   * devframe serves the RPC surface through the Vite dev server itself —
-   * `<base>__connection.json` for discovery and the WebSocket upgrade at
-   * `<base>__ws` on Vite's own HTTP server (zero extra ports, proxy/HTTPS
-   * friendly). When Vite runs in middleware mode (no `httpServer`) — or a
-   * `port` is pinned — the socket falls back to a side-car server on its
-   * own port instead.
-   *
-   *  - `false` (default) — static-mount the SPA at `base` with SPA
-   *    fallback. No RPC server is started.
-   *  - `true` — bridge mode with all defaults.
-   *  - object — bridge mode with explicit overrides.
-   */
-  devMiddleware?: boolean | {
-    /**
-     * Pin a side-car port for the RPC socket instead of sharing Vite's
-     * server. Default: share Vite's HTTP server (side-car only when Vite
-     * has none).
-     */
-    port?: number;
-    /** Override the side-car bind host. Default: `def.cli?.host ?? 'localhost'`. */
-    host?: string;
-    /** Flag bag forwarded to `def.setup(ctx, { flags })`. */
-    flags?: Record<string, unknown>;
-  };
-  /**
-   * Whether the bridged devframe runs its own auth gate. The RPC endpoint is
-   * reachable by anything that can open its socket, so it **gates by
-   * default**: when unset, authentication resolves through devframe's
-   * interactive OTP gate (unless the definition's `cli.auth` opts out), and
-   * the bridge prints its code/link banner to stdout. Pass a
-   * {@link DevframeAuthHandler} to install a custom scheme, or `false` to opt
-   * out for a single-user localhost host that owns the trust boundary another
-   * way. Only applies in bridge mode (`devMiddleware`); the static-mount mode
-   * starts no RPC server.
-   *
-   * @default gated (devframe's interactive OTP, unless `cli.auth` opts out)
-   */
-  auth?: boolean | DevframeAuthHandler;
-  /**
-   * Expose the bridge's route-based MCP server (Streamable-HTTP) at
-   * `<base>__mcp` — on the Vite app's own origin — and advertise it in the
-   * bridge's `__connection.json`. Overrides `def.cli?.mcp`, `undefined`
-   * falls through to it, `false` disables the route regardless. Only applies
-   * in bridge mode (`devMiddleware`); the static-mount mode starts no server.
-   *
-   * @experimental
-   */
-  mcp?: boolean | McpRouteOptions;
-}
-/** The slice of a Vite dev server the bridge plugin touches. */
-interface DevframeViteDevServerLike {
-  middlewares: {
-    use: ((path: string, handler: (req: IncomingMessage, res: ServerResponse, next?: (err?: unknown) => void) => void) => void) & ((handler: (req: IncomingMessage, res: ServerResponse, next?: (err?: unknown) => void) => void) => void);
-  };
-  httpServer?: Server | null;
-}
-interface DevframeVitePlugin {
-  name: string;
-  apply: 'serve';
-  configureServer: (server: DevframeViteDevServerLike) => void | Promise<void>;
-  closeBundle?: () => void | Promise<void>;
-}
-/**
- * Bridge a devframe into an existing Vite dev server. Returns a Vite
- * plugin with two modes, picked via `options.devMiddleware`:
- *
- *   - **static-mount mode** (default) — mounts `def.cli.distDir` at
- *     `options.base` with SPA fallback enabled. No RPC server is started.
- *
- *   - **bridge mode** (`devMiddleware: true | {…}`) — skips the static
- *     mount; the host app owns the SPA. Devframe serves discovery
- *     (`<base>__connection.json`), the WebSocket RPC upgrade
- *     (`<base>__ws`, shared on Vite's own HTTP server), and the optional
- *     MCP route through {@link initDevframe}'s node middleware, so the
- *     host-served SPA can discover the endpoint via {@link connectDevframe}.
- *
- * The bridge **gates by default** (devframe's interactive OTP unless the
- * definition's `cli.auth` opts out), printing its code/link banner to stdout,
- * so a bridged devframe isn't silently reachable by anything that can open
- * its socket. Pass `options.auth: false` to opt out for a single-user
- * localhost host, or a {@link DevframeAuthHandler} for a custom scheme.
- *
- * Use bridge mode when integrating with frameworks that own the SPA
- * (Nuxt, Astro, SolidStart, plain Vite apps). For the all-in-one
- * `dev` / `build` / `mcp` shell, reach for {@link createCac} instead.
- */
-declare function viteDevBridge(d: DevframeDefinition, options?: ViteDevBridgeOptions): DevframeVitePlugin;
-//#endregion
-export { DevframeViteDevServerLike, DevframeVitePlugin, ViteDevBridgeOptions, viteDevBridge };

package/dist/helpers/vite.mjs

@@ -1,93 +0,0 @@
-import { t as diagnostics } from "../diagnostics-DLYH5oD3.mjs";
-import { n as resolveBasePath, t as normalizeBasePath } from "../_shared-CttmCMBi.mjs";
-import { serveStaticNodeMiddleware } from "../utils/serve-static.mjs";
-import { r as initDevframe } from "../dev-BEveeA5H.mjs";
-import { resolve } from "pathe";
-//#region src/helpers/vite.ts
-/**
-* Bridge a devframe into an existing Vite dev server. Returns a Vite
-* plugin with two modes, picked via `options.devMiddleware`:
-*
-*   - **static-mount mode** (default) — mounts `def.cli.distDir` at
-*     `options.base` with SPA fallback enabled. No RPC server is started.
-*
-*   - **bridge mode** (`devMiddleware: true | {…}`) — skips the static
-*     mount; the host app owns the SPA. Devframe serves discovery
-*     (`<base>__connection.json`), the WebSocket RPC upgrade
-*     (`<base>__ws`, shared on Vite's own HTTP server), and the optional
-*     MCP route through {@link initDevframe}'s node middleware, so the
-*     host-served SPA can discover the endpoint via {@link connectDevframe}.
-*
-* The bridge **gates by default** (devframe's interactive OTP unless the
-* definition's `cli.auth` opts out), printing its code/link banner to stdout,
-* so a bridged devframe isn't silently reachable by anything that can open
-* its socket. Pass `options.auth: false` to opt out for a single-user
-* localhost host, or a {@link DevframeAuthHandler} for a custom scheme.
-*
-* Use bridge mode when integrating with frameworks that own the SPA
-* (Nuxt, Astro, SolidStart, plain Vite apps). For the all-in-one
-* `dev` / `build` / `mcp` shell, reach for {@link createCac} instead.
-*/
-function viteDevBridge(d, options = {}) {
-	const base = normalizeMountBase(options.base ?? resolveBasePath(d, "hosted"));
-	if (!options.devMiddleware) {
-		const distDir = d.cli?.distDir;
-		return {
-			name: `devframe:${d.id}`,
-			apply: "serve",
-			configureServer(server) {
-				if (!distDir) return;
-				server.middlewares.use(base, serveStaticNodeMiddleware(resolve(distDir)));
-			}
-		};
-	}
-	const mw = options.devMiddleware === true ? {} : options.devMiddleware;
-	let instance;
-	return {
-		name: `devframe:${d.id}`,
-		apply: "serve",
-		async configureServer(server) {
-			await instance?.close().catch(() => {});
-			instance = void 0;
-			try {
-				const created = initDevframe(d, {
-					base,
-					distDir: false,
-					flags: mw.flags,
-					host: mw.host,
-					...mw.port != null ? { ws: { port: mw.port } } : server.httpServer ? { server: server.httpServer } : { ws: { sidecar: true } },
-					auth: options.auth,
-					mcp: options.mcp
-				});
-				server.middlewares.use(created.nodeMiddleware);
-				await created.ready;
-				instance = created;
-			} catch (e) {
-				diagnostics.DF0033({
-					id: d.id,
-					reason: String(e),
-					cause: e
-				}, { method: "warn" });
-				return;
-			}
-			server.httpServer?.once("close", () => {
-				instance?.close().catch(() => {});
-			});
-		},
-		async closeBundle() {
-			await instance?.close().catch(() => {});
-			instance = void 0;
-		}
-	};
-}
-/**
-* Make `base` safe for `server.middlewares.use(path, …)`. Vite's connect
-* router matches by absolute URL prefix, so relative spellings like
-* `'./'` (commonly used for base-agnostic Nuxt builds) collapse to the
-* origin root before the shared leading/trailing-slash normalization.
-*/
-function normalizeMountBase(base) {
-	return normalizeBasePath(base.replace(/^\.\/?/, "/"));
-}
-//#endregion
-export { viteDevBridge };