weapp-vite 7.4.0 → 7.6.0

package/dist/dashboardTransport-C_Y6jMp-.mjs

@@ -0,0 +1,16 @@
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+//#region src/cli/analyze/dashboardTransport/index.ts
+/** 从已选 Dashboard 的安装位置解析传输依赖，兼容嵌套安装和包管理器的虚拟目录。 */
+async function loadDashboardTransportModule(packageJsonPath, specifier) {
+	const require = createRequire(packageJsonPath);
+	let resolved;
+	try {
+		resolved = require.resolve(specifier);
+	} catch (error) {
+		throw new Error(`[weapp-vite ui] 已安装的 Dashboard 无法解析传输依赖 ${specifier}，请重新安装或更新 @weapp-vite/dashboard。`, { cause: error });
+	}
+	return import(pathToFileURL(resolved).href);
+}
+//#endregion
+export { loadDashboardTransportModule as t };

package/dist/dashboardViteBridge-DCGR43aM.mjs

@@ -0,0 +1,302 @@
+import { t as loadDashboardTransportModule } from "./dashboardTransport-C_Y6jMp-.mjs";
+import process from "node:process";
+import path from "pathe";
+import { defineRpcFunction } from "devframe";
+import { Server } from "node:http";
+import { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_SSE_ROUTE, DEVFRAME_WS_ROUTE } from "devframe/constants";
+import { toNodeHandler } from "@modelcontextprotocol/node";
+import { registerDevframeInstance } from "devframe/internal";
+import { isLoopbackAddress, validateOriginCandidate } from "devframe/utils/origin";
+//#region src/cli/analyze/dashboardMcp.ts
+const MCP_ROUTE = "__mcp";
+/** MCP 只公开 Dashboard 的 Agent RPC，不继承宿主工具、浏览器 OTP 或共享状态。 */
+async function createDashboardMcp(instance, httpServer, options) {
+	const { createMcpFetchHandler } = await loadDashboardTransportModule(options.packageJsonPath, "@devframes/agentic/mcp");
+	const context = await instance.context;
+	const prefix = `${options.id}:`;
+	const getTool = (id) => {
+		const tool = context.agent.getTool(id);
+		return tool?.kind === "rpc" && tool.id.startsWith(prefix) ? tool : void 0;
+	};
+	const agent = Object.create(context.agent);
+	agent.list = () => ({
+		tools: context.agent.list().tools.filter((tool) => tool.kind === "rpc" && tool.id.startsWith(prefix)),
+		resources: []
+	});
+	agent.getTool = getTool;
+	agent.invoke = (id, args) => {
+		const tool = getTool(id);
+		if (!tool) throw new Error("Dashboard MCP tool is not available.");
+		return context.agent.invoke(tool.id, args);
+	};
+	agent.read = () => {
+		throw new Error("Dashboard MCP resources are not available.");
+	};
+	const handler = createMcpFetchHandler({
+		...context,
+		agent
+	}, {
+		serverName: `${options.id} (devframe)`,
+		serverVersion: options.version ?? "0.0.0",
+		exposeSharedState: false,
+		allowedOrigins: []
+	});
+	const base = options.base ?? instance.base;
+	const route = `${base}${MCP_ROUTE}`;
+	let registration;
+	let closing;
+	let closed = false;
+	const nodeHandler = toNodeHandler({ async fetch(request) {
+		const origin = request.headers.get("origin");
+		if (!origin || validateOriginCandidate(origin, []) !== origin) return new Response("Forbidden", { status: 403 });
+		return handler.fetch(request);
+	} });
+	return {
+		route,
+		async nodeMiddleware(request, response) {
+			const remoteAddress = request.socket.remoteAddress;
+			if (!remoteAddress || !isLoopbackAddress(remoteAddress)) {
+				response.writeHead(403);
+				response.end("Forbidden");
+				return;
+			}
+			await nodeHandler(request, response);
+		},
+		discoveryMiddleware: toNodeHandler({ async fetch() {
+			return Response.json({
+				...instance.connectionMeta(),
+				mcp: { path: MCP_ROUTE }
+			});
+		} }),
+		register() {
+			if (closed || registration || !httpServer.listening) return;
+			const address = httpServer.address();
+			if (!address || typeof address === "string") return;
+			const hostname = address.address === "::" || address.address === "0.0.0.0" ? "localhost" : address.address.includes(":") ? `[${address.address}]` : address.address;
+			registration = registerDevframeInstance({
+				pid: process.pid,
+				port: address.port,
+				origin: `http://${hostname}:${address.port}`,
+				basePath: base,
+				id: options.id,
+				name: options.name,
+				rootDir: path.resolve(options.projectRoot),
+				mcp: { path: route },
+				startedAt: Date.now()
+			});
+		},
+		close() {
+			if (!closing) {
+				closed = true;
+				closing = Promise.resolve().then(async () => {
+					const errors = [];
+					for (const release of [() => registration?.unregister(), () => handler.dispose()]) try {
+						await release();
+					} catch (error) {
+						errors.push(error);
+					}
+					if (errors.length) throw errors.length === 1 ? errors[0] : new AggregateError(errors, "Dashboard MCP cleanup failed");
+				});
+			}
+			return closing;
+		}
+	};
+}
+//#endregion
+//#region src/cli/analyze/dashboardPolicy.ts
+const rejectDashboardSharedStateSet = defineRpcFunction({
+	name: "devframe:rpc:server-state:set",
+	type: "action",
+	handler: () => {
+		throw new Error("Dashboard Devframe shared state 只允许服务端修改。");
+	}
+});
+const rejectDashboardSharedStatePatch = defineRpcFunction({
+	name: "devframe:rpc:server-state:patch",
+	type: "action",
+	handler: () => {
+		throw new Error("Dashboard Devframe shared state 只允许服务端修改。");
+	}
+});
+/** 独立宿主在开放 RPC 前禁止全局共享状态写入，不影响嵌入宿主的策略。 */
+function withStandaloneDashboardPolicy(definition) {
+	return {
+		...definition,
+		async setup(ctx, info) {
+			ctx.rpc.register(rejectDashboardSharedStateSet, true);
+			ctx.rpc.register(rejectDashboardSharedStatePatch, true);
+			await definition.setup?.(ctx, info);
+		}
+	};
+}
+//#endregion
+//#region src/cli/analyze/dashboardViteBridge.ts
+const ANALYZE_DASHBOARD_DEVFRAME_BASE = "/__weapp-vite/";
+const ANALYZE_DASHBOARD_HUB_BASE = "/__devframes/";
+const transportPaths = /* @__PURE__ */ new Set([
+	`${ANALYZE_DASHBOARD_DEVFRAME_BASE}${DEVFRAME_CONNECTION_META_FILENAME}`,
+	`${ANALYZE_DASHBOARD_DEVFRAME_BASE}${DEVFRAME_SSE_ROUTE}`,
+	`${ANALYZE_DASHBOARD_DEVFRAME_BASE}${DEVFRAME_WS_ROUTE}`
+]);
+function createAnalyzeDashboardViteBridge(controller, options) {
+	const hosts = /* @__PURE__ */ new WeakMap();
+	const ownedHosts = /* @__PURE__ */ new Set();
+	let activeHost;
+	let closing;
+	let stopped = false;
+	return {
+		name: "weapp-vite:dashboard-devframe",
+		apply: "serve",
+		configureServer(server) {
+			if (stopped) throw new Error("Dashboard bridge is already closed.");
+			const httpServer = server.httpServer instanceof Server ? server.httpServer : void 0;
+			let instance;
+			let mcp;
+			let starting;
+			let acquiring;
+			let hostClosing;
+			let closed = false;
+			const onListening = () => mcp?.register();
+			const host = {
+				start() {
+					if (closed) throw new Error("Dashboard host is already closed.");
+					starting ??= (async () => {
+						try {
+							acquiring = Promise.resolve().then(async () => {
+								if (closed) return;
+								if (!httpServer) throw new Error("Dashboard requires the Dashboard Vite HTTP server.");
+								if (options.uiHost === "hub") {
+									const [{ initHub }, { createUi }] = await Promise.all([loadDashboardTransportModule(options.packageJsonPath, "@devframes/hub/initiate"), loadDashboardTransportModule(options.packageJsonPath, "@devframes/hub-ui")]);
+									if (closed) return;
+									instance = initHub({
+										base: ANALYZE_DASHBOARD_HUB_BASE,
+										name: "weapp-vite DevTools",
+										cwd: options.projectRoot ?? process.cwd(),
+										server: httpServer,
+										allowedOrigins: [],
+										auth: true,
+										mcp: false,
+										register: false,
+										ui: createUi({ branding: {
+											productName: "weapp-vite DevTools",
+											logo: controller.definition.icon
+										} }),
+										configure: (ctx) => ctx.install({
+											...controller.definition,
+											basePath: ANALYZE_DASHBOARD_DEVFRAME_BASE
+										})
+									});
+									await instance.ready;
+								} else {
+									const { initDevframe } = await loadDashboardTransportModule(options.packageJsonPath, "devframe/initiate");
+									if (closed) return;
+									instance = initDevframe(withStandaloneDashboardPolicy(controller.definition), {
+										base: ANALYZE_DASHBOARD_DEVFRAME_BASE,
+										distDir: false,
+										server: httpServer,
+										allowedOrigins: [],
+										auth: true,
+										mcp: false,
+										register: false
+									});
+									await instance.ready;
+								}
+								if (!closed) mcp = await createDashboardMcp(instance, httpServer, {
+									packageJsonPath: options.packageJsonPath,
+									projectRoot: options.projectRoot ?? process.cwd(),
+									id: controller.definition.id,
+									name: controller.definition.name,
+									version: controller.definition.version,
+									base: ANALYZE_DASHBOARD_DEVFRAME_BASE
+								});
+							});
+							await acquiring;
+							if (closed) throw new Error("Dashboard host initialization was cancelled by shutdown.");
+							activeHost = host;
+							httpServer?.once("listening", onListening);
+							httpServer?.once("close", host.onClose);
+							httpServer?.once("error", host.onClose);
+							onListening();
+						} catch (error) {
+							await host.close().catch(() => {});
+							if (!activeHost) controller.dispose();
+							throw error;
+						}
+					})();
+					return starting;
+				},
+				close() {
+					if (!hostClosing) {
+						closed = true;
+						if (activeHost === host) activeHost = void 0;
+						httpServer?.off("listening", onListening);
+						httpServer?.off("close", host.onClose);
+						httpServer?.off("error", host.onClose);
+						hostClosing = Promise.resolve().then(async () => {
+							await acquiring?.catch(() => {});
+							const errors = [];
+							for (const release of [() => mcp?.close(), () => instance?.close()]) try {
+								await release();
+							} catch (error) {
+								errors.push(error);
+							}
+							if (errors.length) throw errors.length === 1 ? errors[0] : new AggregateError(errors, "Dashboard host cleanup failed");
+							ownedHosts.delete(host);
+						});
+					}
+					return hostClosing;
+				},
+				onClose() {
+					host.close().catch((error) => server.config.logger.error(String(error)));
+				}
+			};
+			hosts.set(server.config, host);
+			ownedHosts.add(host);
+			server.middlewares.use((request, response, next) => {
+				if (closed || !instance) {
+					next();
+					return;
+				}
+				const url = request.url ?? "/";
+				const queryIndex = url.indexOf("?");
+				const pathname = queryIndex < 0 ? url : url.slice(0, queryIndex);
+				if (mcp && pathname === mcp.route) {
+					mcp.nodeMiddleware(request, response).catch(next);
+					return;
+				}
+				if (mcp && pathname === `/__weapp-vite/${DEVFRAME_CONNECTION_META_FILENAME}`) {
+					mcp.discoveryMiddleware(request, response).catch(next);
+					return;
+				}
+				if (options.uiHost === "hub") {
+					if (pathname === "/__devframes/".slice(0, -1) || pathname.startsWith("/__devframes/")) instance.nodeMiddleware(request, response, next);
+					else next();
+					return;
+				}
+				if (transportPaths.has(pathname)) instance.nodeMiddleware(request, response, next);
+				else next();
+			});
+		},
+		async buildStart() {
+			await hosts.get(this.environment.getTopLevelConfig())?.start();
+		},
+		async closeBundle() {
+			await hosts.get(this.environment.getTopLevelConfig())?.close();
+		},
+		closeServer({ reason }) {
+			if (reason === "close" && !activeHost) controller.dispose();
+		},
+		close() {
+			if (!closing) {
+				stopped = true;
+				closing = Promise.allSettled([...ownedHosts].map((host) => host.close())).then((results) => {
+					const errors = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+					if (errors.length) throw errors.length === 1 ? errors[0] : new AggregateError(errors, "Dashboard bridge cleanup failed");
+				});
+			}
+			return closing;
+		}
+	};
+}
+//#endregion
+export { ANALYZE_DASHBOARD_DEVFRAME_BASE, ANALYZE_DASHBOARD_HUB_BASE, createAnalyzeDashboardViteBridge };

package/dist/dev-C2fgr_Xd.mjs

@@ -0,0 +1,67 @@
+import { E as createViteWatchIgnored, m as notifyDevModuleGraphHost, t as createDevModuleGraphPlugin } from "./devProvider-D-hTfsEO.mjs";
+import { WEAPP_VITE_STATEFUL_HMR_BRIDGE_KEY } from "@weapp-core/constants";
+//#region src/vite/dev.ts
+/** 宿主仅提供依赖图和服务生命周期；小程序快照沿用原生构建落盘。 */
+function prepareDevHostConfig(session, merged, user) {
+	const ctx = session.context;
+	if (session.statefulController) {
+		const { plugins: _plugins, configFile: _configFile, ...normalized } = merged;
+		return {
+			plugins: [...session.statefulController.plugins, ...merged.plugins ?? []],
+			config: {
+				...normalized,
+				logLevel: user.logLevel,
+				customLogger: user.customLogger,
+				appType: "custom",
+				define: {
+					...merged.define,
+					App: `globalThis[${JSON.stringify(WEAPP_VITE_STATEFUL_HMR_BRIDGE_KEY)}].App`,
+					Page: `globalThis[${JSON.stringify(WEAPP_VITE_STATEFUL_HMR_BRIDGE_KEY)}].Page`
+				},
+				optimizeDeps: {
+					noDiscovery: true,
+					include: [],
+					entries: []
+				},
+				experimental: {
+					...merged.experimental,
+					bundledDev: true
+				},
+				server: {
+					...merged.server,
+					...user.server,
+					hmr: user.server?.hmr,
+					watch: {
+						...user.server?.watch,
+						ignored: createViteWatchIgnored(ctx.configService.cwd, ctx.configService.outDir, user.server?.watch?.ignored)
+					}
+				},
+				build: {
+					...merged.build,
+					watch: void 0,
+					write: false
+				}
+			}
+		};
+	}
+	return {
+		plugins: [createDevModuleGraphPlugin(ctx, merged, (change) => notifyDevModuleGraphHost(ctx, change))],
+		config: {
+			appType: "custom",
+			resolve: merged.resolve,
+			define: merged.define,
+			experimental: {
+				...merged.experimental,
+				bundledDev: false
+			},
+			optimizeDeps: {
+				noDiscovery: true,
+				include: [],
+				entries: []
+			},
+			server: { watch: { ignored: createViteWatchIgnored(ctx.configService.cwd, ctx.configService.outDir, user.server?.watch?.ignored) } }
+		}
+	};
+}
+//#endregion
+export { prepareDevHostConfig };