weapp-vite 7.4.0 → 7.5.0

package/dist/dashboard.d.mts

@@ -1,2 +1,3 @@
-import { a as resolveDashboardClientAssets, c as DashboardContentRoots, d as createDashboardArtifactSnapshot, f as AnalyzeSubpackagesResult, i as createAnalyzeDashboardDevframe, l as DashboardArtifactFile, n as CreateAnalyzeDashboardDevframeOptions, o as DashboardRuntimeEventInput, r as DashboardAnalyzeSnapshot, s as DashboardRuntimeEventProfile, t as AnalyzeDashboardDevframeController, u as DashboardArtifactFiles } from "./index-DbqVupg0.mjs";
-export { AnalyzeDashboardDevframeController, type AnalyzeSubpackagesResult, CreateAnalyzeDashboardDevframeOptions, DashboardAnalyzeSnapshot, type DashboardArtifactFile, type DashboardArtifactFiles, type DashboardContentRoots, type DashboardRuntimeEventInput, type DashboardRuntimeEventProfile, createAnalyzeDashboardDevframe, createDashboardArtifactSnapshot, resolveDashboardClientAssets };
+import { a as AnalyzeSubpackagesResult } from "./budget-BD7VqLCl.mjs";
+import { A as DashboardInvestigationReceiptInput, B as DashboardRuntimeEventInput, C as DashboardClaimInvestigationRequest, D as DashboardInvestigationClaim, E as DashboardInvestigation, F as DashboardObjectMeasurements, G as DashboardFileReadRequest, H as DashboardRuntimeEventsPage, I as DashboardProposeInvestigationRequest, J as DashboardArtifactFiles, K as DashboardContentRoots, L as DashboardReportIdentity, M as DashboardInvestigationStatus, N as DashboardInvestigationTarget, O as DashboardInvestigationProposal, P as DashboardInvestigationsState, R as DashboardVerifyInvestigationRequest, S as DashboardAuthorizeInvestigationRequest, T as DashboardCreateInvestigationRequest, U as DashboardRuntimeEventsQueryRequest, V as DashboardRuntimeEventProfile, W as DashboardFileContent, Y as createDashboardArtifactSnapshot, _ as DashboardAnalyzePage, a as createAnalyzeDashboardDevframe, b as DashboardAnalyzePayloadsDescriptor, c as DashboardAnalyzeSummary, d as DashboardComparisonPage, f as DashboardComparisonQuery, g as DashboardPackagesQuery, h as DashboardPackagesPage, i as DashboardDevframeState, j as DashboardInvestigationRequest, k as DashboardInvestigationProposalInput, l as DashboardArtifactsPage, m as DashboardModulesQuery, n as CreateAnalyzeDashboardDevframeOptions, o as resolveDashboardClientAssets, p as DashboardModulesPage, q as DashboardArtifactFile, r as DashboardAnalyzeSnapshot, s as DashboardAnalyzeQuery, t as AnalyzeDashboardDevframeController, u as DashboardArtifactsQuery, v as DashboardAnalyzePageRequest, w as DashboardCompleteInvestigationRequest, x as DashboardAgentInvestigationRequest, y as DashboardAnalyzePayloadDescriptor, z as DashboardRuntimeEvent } from "./index-C9HjUX5c.mjs";
+export { AnalyzeDashboardDevframeController, type AnalyzeSubpackagesResult, CreateAnalyzeDashboardDevframeOptions, type DashboardAgentInvestigationRequest, type DashboardAnalyzePage, type DashboardAnalyzePageRequest, type DashboardAnalyzePayloadDescriptor, type DashboardAnalyzePayloadsDescriptor, type DashboardAnalyzeQuery, DashboardAnalyzeSnapshot, type DashboardAnalyzeSummary, type DashboardArtifactFile, type DashboardArtifactFiles, type DashboardArtifactsPage, type DashboardArtifactsQuery, type DashboardAuthorizeInvestigationRequest, type DashboardClaimInvestigationRequest, type DashboardComparisonPage, type DashboardComparisonQuery, type DashboardCompleteInvestigationRequest, type DashboardContentRoots, type DashboardCreateInvestigationRequest, DashboardDevframeState, type DashboardFileContent, type DashboardFileReadRequest, type DashboardInvestigation, type DashboardInvestigationClaim, type DashboardInvestigationProposal, type DashboardInvestigationProposalInput, type DashboardInvestigationReceiptInput, type DashboardInvestigationRequest, type DashboardInvestigationStatus, type DashboardInvestigationTarget, type DashboardInvestigationsState, type DashboardModulesPage, type DashboardModulesQuery, type DashboardObjectMeasurements, type DashboardPackagesPage, type DashboardPackagesQuery, type DashboardProposeInvestigationRequest, type DashboardReportIdentity, type DashboardRuntimeEvent, type DashboardRuntimeEventInput, type DashboardRuntimeEventProfile, type DashboardRuntimeEventsPage, type DashboardRuntimeEventsQueryRequest, type DashboardVerifyInvestigationRequest, createAnalyzeDashboardDevframe, createDashboardArtifactSnapshot, resolveDashboardClientAssets };

package/dist/dashboard.mjs

@@ -1,2 +1 @@
-import { a as createDashboardArtifactSnapshot, r as resolveDashboardClientAssets, t as createAnalyzeDashboardDevframe } from "./dashboard-BzaVesmQ.mjs";
-export { createAnalyzeDashboardDevframe, createDashboardArtifactSnapshot, resolveDashboardClientAssets };
+export { t as createAnalyzeDashboardDevframe, a as createDashboardArtifactSnapshot, r as resolveDashboardClientAssets } from "./dashboard-DvqF3Key.mjs";

package/dist/dashboardViteBridge-Dy3nAD4m.mjs

@@ -0,0 +1,299 @@
+import process from "node:process";
+import path from "pathe";
+import { defineRpcFunction } from "devframe";
+import { Server } from "node:http";
+import { createUi } from "@devframes/hub-ui";
+import { initHub } from "@devframes/hub/initiate";
+import { DEVFRAME_CONNECTION_META_FILENAME, DEVFRAME_SSE_ROUTE, DEVFRAME_WS_ROUTE } from "devframe/constants";
+import { initDevframe } from "devframe/initiate";
+import { toNodeHandler } from "@modelcontextprotocol/node";
+import { createMcpFetchHandler } from "devframe/adapters/mcp";
+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 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") {
+									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 {
+									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, {
+									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-fR5GiJRO.mjs

@@ -0,0 +1,63 @@
+import { E as createViteWatchIgnored, m as notifyDevModuleGraphHost, t as createDevModuleGraphPlugin } from "./devProvider-BGBkw28J.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,
+			optimizeDeps: {
+				noDiscovery: true,
+				include: [],
+				entries: []
+			},
+			server: { watch: { ignored: createViteWatchIgnored(ctx.configService.cwd, ctx.configService.outDir, user.server?.watch?.ignored) } }
+		}
+	};
+}
+//#endregion
+export { prepareDevHostConfig };