devframe 0.1.21 → 0.2.0

package/dist/utils/serve-static.mjs

@@ -0,0 +1,173 @@
+import { createReadStream } from "node:fs";
+import { extname, join, normalize, resolve, sep } from "pathe";
+import { defineHandler, withBase } from "h3";
+import { stat } from "node:fs/promises";
+import { Readable } from "node:stream";
+import { lookup } from "mrmime";
+//#region src/utils/serve-static.ts
+const HTML_EXTENSIONS = [".html", ".htm"];
+async function statFile(abs) {
+	try {
+		const s = await stat(abs);
+		if (!s.isFile()) return null;
+		return {
+			abs,
+			size: s.size,
+			mtime: s.mtime
+		};
+	} catch {
+		return null;
+	}
+}
+async function resolveTarget(absDir, urlPath, indexNames, single) {
+	let cleaned;
+	try {
+		cleaned = decodeURIComponent(urlPath || "/");
+	} catch {
+		return null;
+	}
+	cleaned = cleaned.replace(/[?#].*$/, "");
+	if (cleaned.endsWith("/")) cleaned = cleaned.slice(0, -1);
+	if (cleaned.startsWith("/")) cleaned = cleaned.slice(1);
+	const abs = normalize(join(absDir, cleaned));
+	if (abs !== absDir && !abs.startsWith(absDir + sep)) return null;
+	const direct = await statFile(abs);
+	if (direct) return direct;
+	try {
+		if ((await stat(abs)).isDirectory()) for (const name of indexNames) {
+			const candidate = await statFile(join(abs, name));
+			if (candidate) return candidate;
+		}
+	} catch {}
+	if (!extname(cleaned)) for (const ext of HTML_EXTENSIONS) {
+		const candidate = await statFile(abs + ext);
+		if (candidate) return candidate;
+	}
+	const fallbackIndex = indexNames[0];
+	if (single && fallbackIndex && !/\.[a-z0-9]+$/i.test(cleaned)) {
+		const indexFile = await statFile(join(absDir, fallbackIndex));
+		if (indexFile) return indexFile;
+	}
+	return null;
+}
+function contentTypeFor(abs) {
+	const type = lookup(abs);
+	if (!type) return "application/octet-stream";
+	if (type === "text/html") return "text/html; charset=utf-8";
+	return type;
+}
+function staticHeadersFor(file) {
+	return {
+		"Content-Type": contentTypeFor(file.abs),
+		"Content-Length": String(file.size),
+		"Last-Modified": file.mtime.toUTCString(),
+		"Cache-Control": "no-store"
+	};
+}
+function applyStaticHeadersToNode(res, file) {
+	for (const [k, v] of Object.entries(staticHeadersFor(file))) res.setHeader(k, v);
+}
+function normalizeOptions(options) {
+	return {
+		indexNames: options?.indexNames ?? ["index.html"],
+		single: options?.single ?? true
+	};
+}
+/**
+* h3 event handler that serves files from `dir` with SPA fallback.
+*
+* Drop-in replacement for `fromNodeMiddleware(sirv(dir, { dev: true, single: true }))`
+* when the surrounding server is an h3 app — no `Cache-Control` beyond
+* `no-store`, `Content-Type` resolved via `mrmime`, and a miss with no
+* file extension falls back to `<dir>/index.html` so client-side routing
+* works.
+*/
+function serveStaticHandler(dir, options) {
+	const absDir = resolve(dir);
+	const opts = normalizeOptions(options);
+	return defineHandler(async (event) => {
+		const method = event.req.method;
+		if (method !== "GET" && method !== "HEAD") {
+			event.res.status = 405;
+			event.res.headers.set("Allow", "GET, HEAD");
+			return "";
+		}
+		const file = await resolveTarget(absDir, event.url.pathname, opts.indexNames, opts.single);
+		if (!file) {
+			event.res.status = 404;
+			return "";
+		}
+		for (const [k, v] of Object.entries(staticHeadersFor(file))) event.res.headers.set(k, v);
+		if (method === "HEAD") return "";
+		return Readable.toWeb(createReadStream(file.abs));
+	});
+}
+/**
+* Mount {@link serveStaticHandler} on an h3 app at `base`, handling the
+* route pattern and prefix-stripping required by h3 v2.
+*
+* h3 v2's `app.use(base, handler)` only matches the exact `base` path and
+* does not strip the prefix from `event.url.pathname`. Static serving
+* needs both subpath matching (`/base/**`) and the URL stripped so the
+* file resolver sees paths relative to `dir` — this helper bundles both.
+*/
+function mountStaticHandler(app, base, dir, options) {
+	const trimmed = base.replace(/\/$/, "");
+	const handler = serveStaticHandler(dir, options);
+	if (trimmed === "") {
+		app.use("/**", handler);
+		return;
+	}
+	app.use(`${trimmed}/**`, withBase(trimmed, handler));
+}
+/**
+* Connect/Express-style Node middleware variant of {@link serveStaticHandler}.
+*
+* Use when mounting onto `viteServer.middlewares.use(base, …)` or any other
+* Connect stack — avoids forcing the host package to depend on h3 just to
+* adapt an event handler back into Node middleware.
+*/
+function serveStaticNodeMiddleware(dir, options) {
+	const absDir = resolve(dir);
+	const opts = normalizeOptions(options);
+	return (req, res, next) => {
+		(async () => {
+			const method = req.method;
+			if (method !== "GET" && method !== "HEAD") {
+				if (next) {
+					next();
+					return;
+				}
+				res.statusCode = 405;
+				res.setHeader("Allow", "GET, HEAD");
+				res.end();
+				return;
+			}
+			const file = await resolveTarget(absDir, req.url ?? "/", opts.indexNames, opts.single);
+			if (!file) {
+				if (next) {
+					next();
+					return;
+				}
+				res.statusCode = 404;
+				res.end();
+				return;
+			}
+			applyStaticHeadersToNode(res, file);
+			if (method === "HEAD") {
+				res.end();
+				return;
+			}
+			createReadStream(file.abs).pipe(res);
+		})().catch((err) => {
+			if (next) {
+				next(err instanceof Error ? err : new Error(String(err)));
+				return;
+			}
+			res.statusCode = 500;
+			res.end();
+		});
+	};
+}
+//#endregion
+export { mountStaticHandler, serveStaticHandler, serveStaticNodeMiddleware };

package/dist/utils/shared-state.d.mts

@@ -1,2 +1,2 @@
-import { A as ImmutableArray, F as SharedStateEvents, I as SharedStateOptions, L as SharedStatePatch, M as ImmutableObject, N as ImmutableSet, P as SharedState, R as createSharedState, j as ImmutableMap, k as Immutable } from "../devtool-CNvLs2_Y.mjs";
+import { A as ImmutableArray, F as SharedStateEvents, I as SharedStateOptions, L as SharedStatePatch, M as ImmutableObject, N as ImmutableSet, P as SharedState, R as createSharedState, j as ImmutableMap, k as Immutable } from "../devframe-R5Ex5K5L.mjs";
 export { Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableSet, SharedState, SharedStateEvents, SharedStateOptions, SharedStatePatch, createSharedState };

package/dist/utils/shared-state.mjs

@@ -1,36 +1,2 @@
-import { createEventEmitter } from "./events.mjs";
-import { nanoid } from "./nanoid.mjs";
-import { applyPatches, enablePatches, produce, produceWithPatches } from "immer";
-//#region src/utils/shared-state.ts
-function createSharedState(options) {
-	const { enablePatches: enablePatches$1 = false } = options;
-	const events = createEventEmitter();
-	let state = options.initialValue;
-	const syncIds = /* @__PURE__ */ new Set();
-	return {
-		on: events.on,
-		value: () => state,
-		patch: (patches, syncId = nanoid()) => {
-			if (syncIds.has(syncId)) return;
-			enablePatches();
-			state = applyPatches(state, patches);
-			syncIds.add(syncId);
-			events.emit("updated", state, void 0, syncId);
-		},
-		mutate: (fn, syncId = nanoid()) => {
-			if (syncIds.has(syncId)) return;
-			syncIds.add(syncId);
-			if (enablePatches$1) {
-				const [newState, patches] = produceWithPatches(state, fn);
-				state = newState;
-				events.emit("updated", state, patches, syncId);
-			} else {
-				state = produce(state, fn);
-				events.emit("updated", state, void 0, syncId);
-			}
-		},
-		syncIds
-	};
-}
-//#endregion
+import { t as createSharedState } from "../shared-state-q9-1EOSX.mjs";
 export { createSharedState };

package/dist/utils/streaming-channel.d.mts

@@ -1,2 +1,2 @@
-import { C as StreamErrorPayload, D as createStreamReader, E as StreamSinkEvents, O as createStreamSink, S as CreateStreamSinkOptions, T as StreamSink, b as BufferedChunk, w as StreamReader, x as CreateStreamReaderOptions } from "../devtool-CNvLs2_Y.mjs";
+import { C as StreamErrorPayload, D as createStreamReader, E as StreamSinkEvents, O as createStreamSink, S as CreateStreamSinkOptions, T as StreamSink, b as BufferedChunk, w as StreamReader, x as CreateStreamReaderOptions } from "../devframe-R5Ex5K5L.mjs";
 export { BufferedChunk, CreateStreamReaderOptions, CreateStreamSinkOptions, StreamErrorPayload, StreamReader, StreamSink, StreamSinkEvents, createStreamReader, createStreamSink };

package/dist/utils/structured-clone.d.mts

@@ -0,0 +1,21 @@
+//#region src/utils/structured-clone.d.ts
+/**
+ * Serialize a structured-cloneable value (`Map`, `Set`, `Date`, `BigInt`,
+ * cycles, class instances, …) into a JSON-safe records array.
+ */
+declare function structuredCloneSerialize(value: unknown): unknown[];
+/**
+ * Inverse of {@link structuredCloneSerialize}.
+ */
+declare function structuredCloneDeserialize<T = unknown>(value: unknown[]): T;
+/**
+ * Serialize a structured-cloneable value to a single string. Equivalent
+ * to `JSON.stringify(structuredCloneSerialize(value))`.
+ */
+declare function structuredCloneStringify(value: unknown): string;
+/**
+ * Inverse of {@link structuredCloneStringify}.
+ */
+declare function structuredCloneParse<T = unknown>(value: string): T;
+//#endregion
+export { structuredCloneDeserialize, structuredCloneParse, structuredCloneSerialize, structuredCloneStringify };

package/dist/utils/structured-clone.mjs

@@ -0,0 +1,2 @@
+import { i as structuredCloneStringify, n as structuredCloneParse, r as structuredCloneSerialize, t as structuredCloneDeserialize } from "../structured-clone-CD2l4fI3.mjs";
+export { structuredCloneDeserialize, structuredCloneParse, structuredCloneSerialize, structuredCloneStringify };

package/dist/utils/when.d.mts

@@ -1,4 +1,4 @@
-//#region ../../../node_modules/.pnpm/whenexpr@0.1.2/node_modules/whenexpr/dist/index.d.mts
+//#region ../../node_modules/.pnpm/whenexpr@0.1.2/node_modules/whenexpr/dist/index.d.mts
 //#region src/paths.d.ts
 /**
  * Union of valid context paths for `T` — both flat keys (`keyof T`) and
@@ -325,50 +325,8 @@ type ValidateExpression<S extends string, T> = string extends S ? S : Tokenize<S
  * defineCommand({ name: 'x', title: 'X', when: 'typo' })
  * //                                            ^^^^^ type error
  */
-type WhenExpression<T, S extends string> = S & ValidateExpression<S, T>; //#endregion
+type WhenExpression$1<T, S extends string> = S & ValidateExpression<S, T>; //#endregion
 //#region src/index.d.ts
-interface EvaluateOptions {
-  /**
-   * If `true`, throw when the expression references a context key that does
-   * not exist. Defaults to `false`, where unknown keys evaluate to `undefined`.
-   */
-  strict?: boolean;
-}
-/**
- * Evaluate a when-clause expression string against a context object.
- * Equivalent to `evaluate(parse(expression), ctx, options)`.
- *
- * Supports a JS-expression subset:
- * - Literals: booleans, numbers, strings (quoted with `"` or `'`)
- * - Identifiers: bare keys, including namespaced (`vite.mode`, `vite:buildMode`)
- * - Logical: `&&`, `||`, `!`
- * - Equality: `==`, `!=` (string comparison, bare identifier RHS treated as string),
- *             `===`, `!==` (JS strict equality with full expression RHS)
- * - Relational: `<`, `<=`, `>`, `>=`
- * - Arithmetic: `+`, `-`, `*`, `/`, `%`, unary `-` / `+`
- * - Grouping: `(` … `)`
- *
- * When `ctx` has a specific type with known keys, the expression string is
- * **statically validated** — unknown context keys and syntax errors surface
- * as TypeScript errors at the call site. Pass `ctx` typed as
- * `Record<string, unknown>`, or the expression as `string`, to opt out of
- * static checking (e.g. for dynamic expressions).
- *
- * With `{ strict: true }`, referencing an unknown context key at runtime
- * throws. Short-circuit evaluation still applies — keys not reached are not
- * checked.
- */
-declare function evaluateWhen<T extends object, const E extends string>(expression: E & ValidateExpression<E, T>, ctx: T, options?: EvaluateOptions): boolean;
-/**
- * Resolve a context value by key. Supports namespaced keys with `.` or `:` separators.
- *
- * Lookup order:
- * 1. Exact match — `ctx['plugin.mode']` or `ctx['plugin:mode']`
- * 2. Nested path — e.g. `plugin.mode` falls back to `ctx.plugin?.mode`
- *
- * Returns `undefined` for unknown keys.
- */
-declare function resolveContextValue<T extends Record<string, unknown>>(key: string, ctx: T): unknown; //#endregion
 //#endregion
 //#region src/utils/when.d.ts
 /**
@@ -383,11 +341,9 @@ declare function resolveContextValue<T extends Record<string, unknown>>(key: str
  * Plugins can add namespaced variables using dot or colon separators:
  * - `vite.mode`, `vite:mode` — stored as `{ 'vite.mode': 'development' }` or nested `{ vite: { mode: 'development' } }`
  *
- * The expression language — including all operators and precedence — is provided by
- * the [`whenexpr`](https://github.com/antfu/whenexpr) package. In addition to the
- * VS-Code-style `!`/`==`/`!=`/`&&`/`||` operators, parentheses, strict equality
- * (`===`/`!==`), relational (`<`/`<=`/`>`/`>=`), arithmetic (`+ - * / %`), and
- * number/string literals are supported.
+ * Supported operators: `!`, `==`, `!=`, `===`, `!==`, `<`, `<=`, `>`, `>=`,
+ * `&&`, `||`, `+`, `-`, `*`, `/`, `%`. Parentheses, number and string literals
+ * are also supported.
  */
 interface WhenContext {
   clientType: 'embedded' | 'standalone';
@@ -397,5 +353,32 @@ interface WhenContext {
   /** Allow custom context variables from plugins */
   [key: string]: unknown;
 }
+/**
+ * A statically-validated `when` expression string. Used inside `define*`
+ * helpers to surface unknown context keys and syntax errors as TypeScript
+ * errors at the call site.
+ */
+type WhenExpression<T, S extends string> = WhenExpression$1<T, S>;
+/** Options for `evaluateWhen`. */
+interface EvaluateWhenOptions {
+  /**
+   * Throw when the expression references a context key that does not exist.
+   *
+   * @default false
+   */
+  strict?: boolean;
+}
+/**
+ * Evaluate a when-clause expression string against a context object.
+ *
+ * @example
+ * evaluateWhen('dockOpen && clientType == embedded', ctx)
+ */
+declare function evaluateWhen<T extends object, const E extends string>(expression: E & WhenExpression$1<T, E>, context: T, options?: EvaluateWhenOptions): boolean;
+/**
+ * Resolve a context value by key. Supports namespaced keys with `.` or `:`
+ * separators. Returns `undefined` for unknown keys.
+ */
+declare function resolveContextValue<T extends Record<string, unknown>>(key: string, context: T): unknown;
 //#endregion
-export { WhenContext, type WhenExpression, evaluateWhen, resolveContextValue };
+export { EvaluateWhenOptions, WhenContext, type WhenExpression, evaluateWhen, resolveContextValue };

package/dist/utils/when.mjs

@@ -1,4 +1,4 @@
-//#region ../../../node_modules/.pnpm/whenexpr@0.1.2/node_modules/whenexpr/dist/index.mjs
+//#region ../../node_modules/.pnpm/whenexpr@0.1.2/node_modules/whenexpr/dist/index.mjs
 const OPS = [
 	"===",
 	"!==",
@@ -369,7 +369,7 @@ function runBinary(node, ctx, strict) {
 * throws. Short-circuit evaluation still applies — keys not reached are not
 * checked.
 */
-function evaluateWhen(expression, ctx, options) {
+function evaluateWhen$1(expression, ctx, options) {
 	return evaluate(parse(expression), ctx, options);
 }
 /**
@@ -381,7 +381,7 @@ function evaluateWhen(expression, ctx, options) {
 *
 * Returns `undefined` for unknown keys.
 */
-function resolveContextValue(key, ctx) {
+function resolveContextValue$1(key, ctx) {
 	return resolve(key, ctx).value;
 }
 function lookup(key, ctx, strict) {
@@ -421,4 +421,22 @@ function resolve(key, ctx) {
 	};
 }
 //#endregion
+//#region src/utils/when.ts
+/**
+* Evaluate a when-clause expression string against a context object.
+*
+* @example
+* evaluateWhen('dockOpen && clientType == embedded', ctx)
+*/
+function evaluateWhen(expression, context, options) {
+	return evaluateWhen$1(expression, context, options);
+}
+/**
+* Resolve a context value by key. Supports namespaced keys with `.` or `:`
+* separators. Returns `undefined` for unknown keys.
+*/
+function resolveContextValue(key, context) {
+	return resolveContextValue$1(key, context);
+}
+//#endregion
 export { evaluateWhen, resolveContextValue };

package/dist/{ws-client-CjPuPFbA.d.mts → ws-client-Bavoya6-.d.mts}

@@ -1,4 +1,4 @@
-import { g as RpcFunctionDefinitionAny } from "./types-C5OVe4AC.mjs";
+import { g as RpcFunctionDefinitionAny } from "./types-4rdUEi2R.mjs";
 import { ChannelOptions } from "birpc";
 
 //#region src/rpc/transports/ws-client.d.ts

package/dist/{ws-server-C7LnhOHi.d.mts → ws-server-DjvlwLuM.d.mts}

@@ -1,4 +1,4 @@
-import { g as RpcFunctionDefinitionAny } from "./types-C5OVe4AC.mjs";
+import { g as RpcFunctionDefinitionAny } from "./types-4rdUEi2R.mjs";
 import { BirpcGroup, ChannelOptions } from "birpc";
 import { ServerOptions } from "node:https";
 import { WebSocket, WebSocketServer } from "ws";

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "devframe",
   "type": "module",
-  "version": "0.1.21",
+  "version": "0.2.0",
   "description": "Framework for building generic DevTools",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
-  "homepage": "https://github.com/vitejs/devtools#readme",
+  "homepage": "https://github.com/devframes/devframe#readme",
   "repository": {
-    "directory": "devframe/packages/devframe",
+    "directory": "packages/devframe",
     "type": "git",
-    "url": "git+https://github.com/vitejs/devtools.git"
+    "url": "git+https://github.com/devframes/devframe.git"
   },
-  "bugs": "https://github.com/vitejs/devtools/issues",
+  "bugs": "https://github.com/devframes/devframe/issues",
   "keywords": [
     "devtools",
     "rpc",
@@ -25,11 +25,12 @@
     "./adapters/dev": "./dist/adapters/dev.mjs",
     "./adapters/embedded": "./dist/adapters/embedded.mjs",
     "./adapters/mcp": "./dist/adapters/mcp.mjs",
-    "./adapters/vite": "./dist/adapters/vite.mjs",
     "./client": "./dist/client/index.mjs",
     "./constants": "./dist/constants.mjs",
-    "./internal": "./dist/internal/index.mjs",
+    "./helpers/vite": "./dist/helpers/vite.mjs",
     "./node": "./dist/node/index.mjs",
+    "./node/auth": "./dist/node/auth.mjs",
+    "./node/internal": "./dist/node/internal.mjs",
     "./recipes/open-helpers": "./dist/recipes/open-helpers.mjs",
     "./rpc": "./dist/rpc/index.mjs",
     "./rpc/client": "./dist/rpc/client.mjs",
@@ -37,13 +38,18 @@
     "./rpc/transports/ws-client": "./dist/rpc/transports/ws-client.mjs",
     "./rpc/transports/ws-server": "./dist/rpc/transports/ws-server.mjs",
     "./types": "./dist/types/index.mjs",
+    "./utils/colors": "./dist/utils/colors.mjs",
     "./utils/events": "./dist/utils/events.mjs",
+    "./utils/hash": "./dist/utils/hash.mjs",
     "./utils/human-id": "./dist/utils/human-id.mjs",
+    "./utils/launch-editor": "./dist/utils/launch-editor.mjs",
     "./utils/nanoid": "./dist/utils/nanoid.mjs",
+    "./utils/open": "./dist/utils/open.mjs",
     "./utils/promise": "./dist/utils/promise.mjs",
+    "./utils/serve-static": "./dist/utils/serve-static.mjs",
     "./utils/shared-state": "./dist/utils/shared-state.mjs",
-    "./utils/state": "./dist/utils/state.mjs",
     "./utils/streaming-channel": "./dist/utils/streaming-channel.mjs",
+    "./utils/structured-clone": "./dist/utils/structured-clone.mjs",
     "./utils/when": "./dist/utils/when.mjs",
     "./package.json": "./package.json"
   },
@@ -62,43 +68,57 @@
   },
   "dependencies": {
     "@valibot/to-json-schema": "^1.7.0",
-    "ansis": "^4.2.0",
     "birpc": "^4.0.0",
     "cac": "^7.0.0",
-    "h3": "^1.15.11",
-    "immer": "^11.1.7",
-    "launch-editor": "^2.13.2",
+    "h3": "2.0.1-rc.22",
     "logs-sdk": "^0.0.6",
-    "ohash": "^2.0.11",
+    "mrmime": "^2.0.1",
     "pathe": "^2.0.3",
-    "sirv": "^3.0.2",
-    "structured-clone-es": "^2.0.0",
     "valibot": "^1.4.0",
     "ws": "^8.20.0"
   },
   "devDependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "ansis": "^4.3.0",
+    "get-port-please": "^3.2.0",
+    "human-id": "^4.1.3",
+    "immer": "^11.1.8",
     "launch-editor": "^2.13.2",
-    "tsdown": "^0.21.10",
+    "mlly": "^1.8.2",
+    "obug": "^2.1.1",
+    "ohash": "^2.0.11",
+    "open": "^11.0.0",
+    "p-limit": "^7.3.0",
+    "perfect-debounce": "^2.1.0",
+    "structured-clone-es": "^2.0.0",
+    "tsdown": "^0.22.0",
+    "ua-parser-modern": "^0.1.1",
     "whenexpr": "^0.1.2"
   },
   "inlinedDependencies": {
+    "ansis": "4.3.0",
     "bundle-name": "4.1.0",
-    "default-browser": "5.4.0",
+    "default-browser": "5.5.0",
     "default-browser-id": "5.0.1",
     "define-lazy-prop": "3.0.0",
     "get-port-please": "3.2.0",
     "human-id": "4.1.3",
+    "immer": "11.1.8",
     "is-docker": "3.0.0",
     "is-in-ssh": "1.0.0",
     "is-inside-container": "1.0.0",
-    "is-wsl": "3.1.0",
+    "is-wsl": "3.1.1",
+    "launch-editor": "2.13.2",
     "obug": "2.1.1",
+    "ohash": "2.0.11",
     "open": "11.0.0",
     "p-limit": "7.3.0",
     "perfect-debounce": "2.1.0",
+    "picocolors": "1.1.1",
     "powershell-utils": "0.1.0",
     "run-applescript": "7.1.0",
+    "shell-quote": "1.8.3",
+    "structured-clone-es": "2.0.0",
     "ua-parser-modern": "0.1.1",
     "whenexpr": "0.1.2",
     "wsl-utils": "0.3.1",