weapp-vite 7.4.0 → 7.5.0

package/dist/mcp-D3Yh24Cj.mjs

@@ -0,0 +1,529 @@
+import { r as logger_default } from "./logger-DGn5iEVN.mjs";
+import { c as startWeappViteMcpServer, s as resolveWeappMcpConfig } from "./mcp-Cj8Maqo6.mjs";
+import process from "node:process";
+import path from "pathe";
+import path$1 from "node:path";
+import { fs } from "@weapp-core/shared/fs";
+import { writeFile } from "node:fs/promises";
+import os from "node:os";
+import { runWithSuspendedSharedInput } from "weapp-ide-cli";
+import { createInterface } from "node:readline/promises";
+import { clearTimeout, setTimeout as setTimeout$1 } from "node:timers";
+//#region src/cli/commands/accept.ts
+function registerAcceptCommand(cli) {
+	cli.command("accept [root]", "run deterministic mini-program acceptance without a model").option("--init", "create acceptance configuration without overwriting").option("--inspect", "inspect acceptance prerequisites without executing project code").option("--report <jobId>", "read a saved report and check source freshness").option("--acceptance-config <file>", "select an acceptance JSON configuration").option("--trust", "authorize the reviewed configuration for this invocation").option("--json", "write protocol data only to stdout").action(async (root = ".", options) => {
+		try {
+			const directory = path$1.resolve(root);
+			const { defaultVerification, detectProject, safePath } = await import("@weapp-vite/acceptance");
+			if (options.init) {
+				const target = await safePath(directory, options.acceptanceConfig ?? "weapp-acceptance.config.json");
+				const config = {
+					version: 1,
+					verification: defaultVerification(await detectProject(directory)),
+					acceptance: {
+						requiredChecks: ["build", "devtools"],
+						scenarios: [],
+						timeoutMs: 6e5
+					}
+				};
+				await writeFile(target, `${JSON.stringify(config, null, 2)}\n`, { flag: "wx" });
+				process.stdout.write(`${JSON.stringify({
+					created: target,
+					modelRequired: false
+				})}\n`);
+				return;
+			}
+			const { createRuntimeAcceptanceService } = await import("@weapp-vite/mcp");
+			const { connectMiniProgram, prepareAcceptanceProject, resolveAutomatorSessionOptions } = await import("weapp-ide-cli");
+			const service = await createRuntimeAcceptanceService(directory, {
+				trust: Boolean(options.trust && !options.inspect && !options.report),
+				configFile: options.acceptanceConfig
+			}, {
+				connectMiniProgram,
+				resolveSessionOptions: resolveAutomatorSessionOptions,
+				prepareProject: prepareAcceptanceProject
+			});
+			let jobId;
+			let cancelRequested = false;
+			const cancel = () => {
+				cancelRequested = true;
+				if (jobId) service.cancel(jobId);
+			};
+			process.once("SIGINT", cancel);
+			try {
+				let result;
+				if (options.inspect) result = await service.inspect();
+				else if (options.report) result = await service.report(options.report);
+				else {
+					let report = await service.start();
+					jobId = report.jobId;
+					if (cancelRequested) await service.cancel(jobId);
+					while (report.status === "running") {
+						await new Promise((resolve) => setTimeout(resolve, 100));
+						report = await service.report(jobId);
+					}
+					result = report;
+				}
+				process.stdout.write(`${JSON.stringify(result, null, options.json ? void 0 : 2)}\n`);
+				if ("passed" in result && (!result.passed || result.snapshot.stale)) process.exitCode = 1;
+			} finally {
+				process.off("SIGINT", cancel);
+				await service.close();
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (options.json) process.stdout.write(`${JSON.stringify({
+				status: "failed",
+				passed: false,
+				reason: message
+			})}\n`);
+			else process.stderr.write(`${message}\n`);
+			process.exitCode = 1;
+		}
+	});
+}
+//#endregion
+//#region src/cli/options.ts
+function filterDuplicateOptions(options) {
+	for (const [key, value] of Object.entries(options)) if (Array.isArray(value)) options[key] = value[value.length - 1];
+}
+function resolveConfigFile(options) {
+	if (typeof options.config === "string") return options.config;
+	if (typeof options.c === "string") return options.c;
+}
+function convertBase(value) {
+	if (value === 0) return "";
+	return value;
+}
+function coerceBooleanOption(value) {
+	if (value === void 0) return;
+	if (typeof value === "boolean") return value;
+	if (typeof value === "string") {
+		const normalized = value.trim().toLowerCase();
+		if (normalized === "") return true;
+		if (normalized === "false" || normalized === "0" || normalized === "off" || normalized === "no") return false;
+		if (normalized === "true" || normalized === "1" || normalized === "on" || normalized === "yes") return true;
+		return true;
+	}
+	if (typeof value === "number") return value !== 0;
+	return Boolean(value);
+}
+function parseDashboardUiHost(value) {
+	if (value === void 0 || value === "standalone" || value === "hub") return value;
+	throw new Error(`不支持的 --ui-host 值：${String(value)}（仅支持 standalone 或 hub）`);
+}
+function isUiEnabled(options) {
+	return Boolean(options.ui || options.analyze || options.uiHost !== void 0);
+}
+//#endregion
+//#region src/cli/mcpClient/shared.ts
+const CODEX_BLOCK_PREFIX = "# >>> weapp-vite mcp ";
+const CODEX_BLOCK_SUFFIX = " >>>";
+const CODEX_BLOCK_END_PREFIX = "# <<< weapp-vite mcp ";
+const CODEX_BLOCK_END_SUFFIX = " <<<";
+const DEFAULT_HTTP_TIMEOUT_MS = 1500;
+const WORKSPACE_FOLDER_TOKEN = "${workspaceFolder}";
+const REG_CodexUrl = /^\s*url\s*=\s*"([^"]+)"/m;
+const REG_CodexCommand = /^\s*command\s*=\s*"([^"]+)"/m;
+const REG_CodexArgs = /^\s*args\s*=\s*\[([^\]]*)\]/m;
+const REG_FirstTomlString = /"([^"]+)"/;
+function resolveTargetWorkspaceRoot(target) {
+	if (target.client === "cursor") return path.dirname(path.dirname(target.configPath));
+	if (target.client === "claude-code") return path.dirname(target.configPath);
+	return process.cwd();
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function renderTomlString(value) {
+	return JSON.stringify(value);
+}
+function sanitizeServerNameSegment(value) {
+	return value.trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-{2,}/g, "-").replace(/^-|-$/g, "");
+}
+function resolveServerName(workspaceRoot) {
+	return `weapp-vite-${sanitizeServerNameSegment(path.basename(workspaceRoot)) || "project"}`;
+}
+function resolveNodeBinCommand() {
+	return process.execPath || "node";
+}
+function resolveProjectCliBin(workspaceRoot) {
+	return path.join(workspaceRoot, "node_modules", "weapp-vite", "bin", "weapp-vite.js");
+}
+function renderCommandArgs(args) {
+	return args.map(renderTomlString).join(", ");
+}
+function renderCodexBlock(serverName, entry) {
+	const startMarker = `${CODEX_BLOCK_PREFIX}${serverName}${CODEX_BLOCK_SUFFIX}`;
+	const endMarker = `${CODEX_BLOCK_END_PREFIX}${serverName}${CODEX_BLOCK_END_SUFFIX}`;
+	if (entry.url) return `${startMarker}
+[mcp_servers.${serverName}]
+url = ${renderTomlString(entry.url)}
+${endMarker}
+`;
+	return `${startMarker}
+[mcp_servers.${serverName}]
+command = ${renderTomlString(entry.command ?? resolveNodeBinCommand())}
+args = [${renderCommandArgs(entry.args ?? [])}]
+${endMarker}
+`;
+}
+function renderJsonPreview(serverName, entry) {
+	return `${JSON.stringify({ mcpServers: { [serverName]: entry } }, null, 2)}
+`;
+}
+function resolveCommandEntry(client, workspaceRoot) {
+	const binPath = resolveProjectCliBin(workspaceRoot);
+	if (client === "cursor") return {
+		command: "node",
+		args: [
+			`${WORKSPACE_FOLDER_TOKEN}/node_modules/weapp-vite/bin/weapp-vite.js`,
+			"mcp",
+			"--workspace-root",
+			WORKSPACE_FOLDER_TOKEN
+		]
+	};
+	return {
+		command: resolveNodeBinCommand(),
+		args: [
+			binPath,
+			"mcp",
+			"--workspace-root",
+			workspaceRoot
+		]
+	};
+}
+function resolveHttpEntry(client, url) {
+	if (client === "claude-code") return {
+		type: "http",
+		url
+	};
+	return { url };
+}
+function resolveConfigEntry(client, transport, workspaceRoot, url) {
+	return transport === "http" ? resolveHttpEntry(client, url ?? "") : resolveCommandEntry(client, workspaceRoot);
+}
+function resolveCodexBlockPattern(serverName) {
+	const startMarker = `${CODEX_BLOCK_PREFIX}${serverName}${CODEX_BLOCK_SUFFIX}`;
+	const endMarker = `${CODEX_BLOCK_END_PREFIX}${serverName}${CODEX_BLOCK_END_SUFFIX}`;
+	return new RegExp(`${escapeRegExp(startMarker)}[\\s\\S]*?${escapeRegExp(endMarker)}\\n?`, "g");
+}
+function upsertCodexManagedBlock(content, serverName, block) {
+	const withoutExisting = content.trimEnd().replace(resolveCodexBlockPattern(serverName), "").trimEnd();
+	if (!withoutExisting) return block;
+	return `${withoutExisting}\n\n${block}`;
+}
+function parseJsonConfig(content, configPath) {
+	if (!content.trim()) return {};
+	try {
+		return JSON.parse(content);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`无法解析 MCP 配置文件 ${configPath}：${message}`);
+	}
+}
+function resolveTarget(client, workspaceRoot) {
+	const serverName = resolveServerName(workspaceRoot);
+	if (client === "codex") return {
+		client,
+		configPath: path.join(os.homedir(), ".codex", "config.toml"),
+		displayName: "Codex",
+		serverName
+	};
+	if (client === "claude-code") return {
+		client,
+		configPath: path.join(workspaceRoot, ".mcp.json"),
+		displayName: "Claude Code",
+		serverName
+	};
+	return {
+		client,
+		configPath: path.join(workspaceRoot, ".cursor", "mcp.json"),
+		displayName: "Cursor",
+		serverName
+	};
+}
+//#endregion
+//#region src/cli/mcpClient/inspect.ts
+async function probeHttpEndpoint(url) {
+	const controller = new AbortController();
+	const timer = setTimeout$1(() => {
+		controller.abort();
+	}, DEFAULT_HTTP_TIMEOUT_MS);
+	try {
+		return (await fetch(url, {
+			method: "GET",
+			signal: controller.signal
+		})).status > 0;
+	} catch {
+		return false;
+	} finally {
+		clearTimeout(timer);
+		controller.abort();
+	}
+}
+async function inspectJsonConfig(target) {
+	if (!await fs.pathExists(target.configPath)) return {
+		configExists: false,
+		configPath: target.configPath,
+		displayName: target.displayName,
+		issues: [`未找到配置文件：${target.configPath}`],
+		serverName: target.serverName
+	};
+	const entry = parseJsonConfig(await fs.readFile(target.configPath, "utf8"), target.configPath).mcpServers?.[target.serverName];
+	if (!entry) return {
+		configExists: true,
+		configPath: target.configPath,
+		displayName: target.displayName,
+		issues: [`配置文件中未找到服务器 ${target.serverName}`],
+		serverName: target.serverName
+	};
+	const transport = entry.url ? "http" : "command";
+	const issues = [];
+	let httpReachable;
+	if (transport === "command") {
+		const normalizedBin = (entry.args?.[0])?.replaceAll(WORKSPACE_FOLDER_TOKEN, resolveTargetWorkspaceRoot(target));
+		if (!normalizedBin || !await fs.pathExists(normalizedBin)) issues.push(`未找到本地 CLI 入口：${normalizedBin ?? "缺少 args[0]"}`);
+	} else if (entry.url) {
+		httpReachable = await probeHttpEndpoint(entry.url);
+		if (!httpReachable) issues.push(`HTTP MCP 地址不可达：${entry.url}`);
+	}
+	return {
+		configExists: true,
+		configPath: target.configPath,
+		displayName: target.displayName,
+		httpReachable,
+		issues,
+		serverName: target.serverName,
+		transport
+	};
+}
+async function inspectCodexConfig(target) {
+	if (!await fs.pathExists(target.configPath)) return {
+		configExists: false,
+		configPath: target.configPath,
+		displayName: target.displayName,
+		issues: [`未找到配置文件：${target.configPath}`],
+		serverName: target.serverName
+	};
+	const blockMatch = (await fs.readFile(target.configPath, "utf8")).match(resolveCodexBlockPattern(target.serverName));
+	if (!blockMatch?.[0]) return {
+		configExists: true,
+		configPath: target.configPath,
+		displayName: target.displayName,
+		issues: [`未找到 weapp-vite 生成的 Codex 配置区块：${target.serverName}`],
+		serverName: target.serverName
+	};
+	const block = blockMatch[0];
+	const issues = [];
+	const urlMatch = block.match(REG_CodexUrl);
+	const commandMatch = block.match(REG_CodexCommand);
+	const argsMatch = block.match(REG_CodexArgs);
+	if (urlMatch?.[1]) {
+		const reachable = await probeHttpEndpoint(urlMatch[1]);
+		if (!reachable) issues.push(`HTTP MCP 地址不可达：${urlMatch[1]}`);
+		return {
+			configExists: true,
+			configPath: target.configPath,
+			displayName: target.displayName,
+			httpReachable: reachable,
+			issues,
+			serverName: target.serverName,
+			transport: "http"
+		};
+	}
+	const binPath = (argsMatch?.[1]?.match(REG_FirstTomlString))?.[1];
+	if (!commandMatch?.[1]) issues.push("Codex 配置区块缺少 command 字段");
+	if (!binPath || !await fs.pathExists(binPath)) issues.push(`未找到本地 CLI 入口：${binPath ?? "缺少 args[0]"}`);
+	return {
+		configExists: true,
+		configPath: target.configPath,
+		displayName: target.displayName,
+		issues,
+		serverName: target.serverName,
+		transport: "command"
+	};
+}
+async function inspectMcpClientConfig(options) {
+	const target = resolveTarget(options.client, path.resolve(options.workspaceRoot));
+	if (target.client === "codex") return await inspectCodexConfig(target);
+	return await inspectJsonConfig(target);
+}
+//#endregion
+//#region src/cli/mcpClient/plan.ts
+function resolveSupportedMcpClient(input) {
+	if (input === "codex" || input === "claude-code" || input === "cursor") return input;
+	throw new Error(`不支持的 MCP 客户端：${input}。当前仅支持 codex、claude-code、cursor。`);
+}
+function buildMcpClientConfigPlan(options) {
+	const workspaceRoot = path.resolve(options.workspaceRoot);
+	const target = resolveTarget(options.client, workspaceRoot);
+	const entry = resolveConfigEntry(options.client, options.transport, workspaceRoot, options.url);
+	if (options.transport === "http" && !entry.url) throw new Error("HTTP 模式缺少 MCP 服务地址，请使用 --url 指定或在当前项目中检测到可用地址。");
+	return {
+		entry,
+		preview: target.client === "codex" ? renderCodexBlock(target.serverName, entry) : renderJsonPreview(target.serverName, entry),
+		target,
+		transport: options.transport
+	};
+}
+function formatMcpQuickStart(options) {
+	const suffix = options.transport === "http" && options.httpUrl ? ` --transport http --url ${options.httpUrl}` : "";
+	return [
+		"在 AI 工具中接入 weapp-vite MCP：",
+		`  - Codex: wv mcp init codex${suffix}`,
+		`  - Claude Code: wv mcp init claude-code${suffix}`,
+		`  - Cursor: wv mcp init cursor${suffix}`
+	];
+}
+//#endregion
+//#region src/cli/mcpClient/index.ts
+async function writeMcpClientConfig(plan) {
+	await fs.ensureDir(path.dirname(plan.target.configPath));
+	const existing = await fs.readFile(plan.target.configPath, "utf8").catch(() => "");
+	if (plan.target.client === "codex") {
+		const nextContent = upsertCodexManagedBlock(existing, plan.target.serverName, plan.preview);
+		await fs.writeFile(plan.target.configPath, nextContent, "utf8");
+		return;
+	}
+	const parsed = parseJsonConfig(existing, plan.target.configPath);
+	const nextConfig = {
+		...parsed,
+		mcpServers: {
+			...parsed.mcpServers ?? {},
+			[plan.target.serverName]: plan.entry
+		}
+	};
+	await fs.writeFile(plan.target.configPath, `${JSON.stringify(nextConfig, null, 2)}\n`, "utf8");
+}
+//#endregion
+//#region src/cli/commands/mcp.ts
+function resolvePort(port) {
+	if (typeof port === "number" && Number.isInteger(port)) return port;
+	if (typeof port === "string" && port.trim()) {
+		const parsed = Number.parseInt(port, 10);
+		if (Number.isInteger(parsed)) return parsed;
+	}
+}
+async function resolveHttpUrl(options) {
+	if (options.url?.trim()) return options.url.trim();
+	const workspaceRoot = options.workspaceRoot ? path.resolve(options.workspaceRoot) : process.cwd();
+	const originalCwd = process.cwd();
+	try {
+		if (workspaceRoot !== originalCwd) process.chdir(workspaceRoot);
+		const configFile = resolveConfigFile(options);
+		const { loadConfig } = await import("./loadConfig-VGtBF4qm.mjs");
+		const loaded = await loadConfig(configFile);
+		const resolved = resolveWeappMcpConfig(loaded?.config?.weapp?.mcp);
+		return `http://${resolved.host}:${resolved.port}${resolved.endpoint}`;
+	} catch {
+		const resolved = resolveWeappMcpConfig(void 0);
+		return `http://${resolved.host}:${resolved.port}${resolved.endpoint}`;
+	} finally {
+		if (process.cwd() !== originalCwd) process.chdir(originalCwd);
+	}
+}
+async function confirmWrite() {
+	if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+	return await runWithSuspendedSharedInput(async () => {
+		const rl = createInterface({
+			input: process.stdin,
+			output: process.stdout
+		});
+		try {
+			const normalized = (await rl.question("是否写入配置文件？(Y/n) ")).trim().toLowerCase();
+			return normalized === "" || normalized === "y" || normalized === "yes";
+		} finally {
+			rl.close();
+		}
+	});
+}
+function resolveClientTransport(transport) {
+	return transport === "http" ? "http" : "command";
+}
+async function handlePrint(clientName, options, write = false) {
+	const client = resolveSupportedMcpClient(clientName);
+	const workspaceRoot = options.workspaceRoot ?? process.cwd();
+	const transport = resolveClientTransport(options.transport);
+	const plan = buildMcpClientConfigPlan({
+		client,
+		transport,
+		url: transport === "http" ? await resolveHttpUrl(options) : void 0,
+		workspaceRoot
+	});
+	logger_default.info(`${plan.target.displayName} 配置文件：${plan.target.configPath}`);
+	logger_default.info(`服务器名称：${plan.target.serverName}`);
+	process.stdout.write(`${plan.preview}\n`);
+	if (!write) return;
+	if (options.yes || await confirmWrite()) {
+		await writeMcpClientConfig(plan);
+		logger_default.success(`已写入 ${plan.target.displayName} MCP 配置。`);
+		logger_default.info(`请重启 ${plan.target.displayName}，然后执行：wv mcp doctor ${client}`);
+		return;
+	}
+	logger_default.info("已取消写入。");
+}
+async function handleDoctor(clientName, options) {
+	const result = await inspectMcpClientConfig({
+		client: resolveSupportedMcpClient(clientName),
+		workspaceRoot: options.workspaceRoot ?? process.cwd()
+	});
+	logger_default.info(`${result.displayName} 配置文件：${result.configPath}`);
+	logger_default.info(`服务器名称：${result.serverName}`);
+	if (!result.configExists || result.issues.length > 0) {
+		for (const issue of result.issues) logger_default.warn(issue);
+		throw new Error("MCP 客户端配置检查未通过。");
+	}
+	if (result.transport) logger_default.info(`传输模式：${result.transport}`);
+	if (result.httpReachable !== void 0) logger_default.info(`HTTP 服务可达：${result.httpReachable ? "是" : "否"}`);
+	logger_default.success("MCP 客户端配置检查通过。");
+}
+async function handleServer(options) {
+	const resolvedTransport = options.transport === "http" ? "streamable-http" : options.transport === "command" ? void 0 : options.transport;
+	const handle = await startWeappViteMcpServer({
+		endpoint: options.endpoint,
+		host: options.host,
+		port: resolvePort(options.port),
+		restEndpoint: options.rest === false ? false : options.restEndpoint,
+		transport: resolvedTransport,
+		unref: options.unref,
+		workspaceRoot: options.workspaceRoot
+	});
+	const shutdown = async () => {
+		process.off("SIGINT", shutdown);
+		process.off("SIGTERM", shutdown);
+		process.stdin.off("end", shutdown);
+		await handle.close?.();
+	};
+	process.once("SIGINT", shutdown);
+	process.once("SIGTERM", shutdown);
+	if (resolvedTransport !== "streamable-http") process.stdin.once("end", shutdown);
+	for (const line of formatMcpQuickStart({
+		httpUrl: resolvedTransport === "streamable-http" ? `http://${options.host ?? "127.0.0.1"}:${resolvePort(options.port) ?? 3088}${options.endpoint ?? "/mcp"}` : void 0,
+		transport: resolvedTransport === "streamable-http" ? "http" : "command"
+	})) logger_default.info(line);
+}
+function registerMcpCommand(cli) {
+	cli.command("mcp [...args]", "start weapp-vite MCP server or manage MCP client onboarding").option("--transport <type>", "[string] stdio | streamable-http | command | http", { default: "stdio" }).option("--host <host>", "[string] streamable-http host").option("--port <port>", "[number] streamable-http port").option("--endpoint <path>", "[string] streamable-http endpoint path").option("--rest-endpoint <path>", "[string] streamable-http REST runtime endpoint path").option("--no-rest", "[boolean] disable streamable-http REST runtime endpoints").option("--unref", "[boolean] unref HTTP server to not block process exit").option("--url <url>", "[string] explicit HTTP MCP url").option("--workspace-root <path>", "[string] workspace root path, defaults to cwd").option("-y, --yes", "[boolean] write config without prompt").action(async (args, options) => {
+		const [subcommand, client] = args;
+		if (subcommand === "init") {
+			if (!client) throw new Error("缺少客户端名称，请使用：wv mcp init <codex|claude-code|cursor>");
+			await handlePrint(client, options, true);
+			return;
+		}
+		if (subcommand === "print") {
+			if (!client) throw new Error("缺少客户端名称，请使用：wv mcp print <codex|claude-code|cursor>");
+			await handlePrint(client, options, false);
+			return;
+		}
+		if (subcommand === "doctor") {
+			if (!client) throw new Error("缺少客户端名称，请使用：wv mcp doctor <codex|claude-code|cursor>");
+			await handleDoctor(client, options);
+			return;
+		}
+		if (subcommand) throw new Error(`未知的 mcp 子命令：${subcommand}`);
+		await handleServer(options);
+	});
+}
+//#endregion
+export { filterDuplicateOptions as a, resolveConfigFile as c, convertBase as i, registerAcceptCommand as l, formatMcpQuickStart as n, isUiEnabled as o, coerceBooleanOption as r, parseDashboardUiHost as s, registerMcpCommand as t };

package/dist/mcp.d.mts

@@ -1,6 +1,9 @@
-import { Wt as WeappMcpConfig } from "./config-Dbvj5yK7.mjs";
-import { CreateServerOptions, DEFAULT_MCP_ENDPOINT, DEFAULT_MCP_HOST, DEFAULT_MCP_PORT, DEFAULT_RUNTIME_REST_ENDPOINT, McpServerHandle, StartMcpServerOptions, createWeappViteMcpServer } from "@weapp-vite/mcp";
+import { Wt as WeappMcpConfig } from "./config-V0L-IAJf.mjs";
+import { DEFAULT_MCP_ENDPOINT, DEFAULT_MCP_HOST, DEFAULT_MCP_PORT, DEFAULT_RUNTIME_REST_ENDPOINT } from "@weapp-core/constants";
+import { CreateServerOptions, McpServerHandle, StartMcpServerOptions, createWeappViteMcpServer as createWeappViteMcpServer$1 } from "@weapp-vite/mcp";
 //#region src/mcp.d.ts
+/** 创建服务时才加载 MCP 运行时；配置解析与公开常量保持同步。 */
+export declare function createWeappViteMcpServer(options?: CreateServerOptions): ReturnType<typeof createWeappViteMcpServer$1>;
 export interface ResolvedWeappMcpConfig {
   agentName?: string;
   enabled: boolean;
@@ -22,4 +25,4 @@ export declare function resolveProjectMcpPort(projectRoot?: string): number;
 export declare function resolveWeappMcpConfig(config?: boolean | WeappMcpConfig, options?: ResolveWeappMcpConfigOptions): ResolvedWeappMcpConfig;
 export declare function startWeappViteMcpServer(options?: WeappViteMcpServerOptions): Promise<WeappViteMcpServerHandle>;
 //#endregion
-export { type CreateServerOptions, DEFAULT_MCP_ENDPOINT, DEFAULT_MCP_HOST, DEFAULT_MCP_PORT, DEFAULT_RUNTIME_REST_ENDPOINT, createWeappViteMcpServer };
+export { type CreateServerOptions, DEFAULT_MCP_ENDPOINT, DEFAULT_MCP_HOST, DEFAULT_MCP_PORT, DEFAULT_RUNTIME_REST_ENDPOINT };

package/dist/mcp.mjs

@@ -1,2 +1 @@
-import { a as createWeappViteMcpServer, c as startWeappViteMcpServer, i as DEFAULT_RUNTIME_REST_ENDPOINT, n as DEFAULT_MCP_HOST, o as resolveProjectMcpPort, r as DEFAULT_MCP_PORT, s as resolveWeappMcpConfig, t as DEFAULT_MCP_ENDPOINT } from "./mcp-BG6TliEg.mjs";
-export { DEFAULT_MCP_ENDPOINT, DEFAULT_MCP_HOST, DEFAULT_MCP_PORT, DEFAULT_RUNTIME_REST_ENDPOINT, createWeappViteMcpServer, resolveProjectMcpPort, resolveWeappMcpConfig, startWeappViteMcpServer };
+export { t as DEFAULT_MCP_ENDPOINT, n as DEFAULT_MCP_HOST, r as DEFAULT_MCP_PORT, i as DEFAULT_RUNTIME_REST_ENDPOINT, a as createWeappViteMcpServer, o as resolveProjectMcpPort, s as resolveWeappMcpConfig, c as startWeappViteMcpServer } from "./mcp-Cj8Maqo6.mjs";

package/dist/package-7swhyLmf.mjs

@@ -0,0 +1,91 @@
+import { t as isPathInside } from "./path-doV773b7.mjs";
+import "./utils-CJSCgEj6.mjs";
+import { i as SHARED_CHUNK_VIRTUAL_PREFIX } from "./chunkStrategy-DRA5WpB-.mjs";
+import { posix } from "pathe";
+//#region src/analyze/subpackages/classifier.ts
+const VIRTUAL_MODULE_INDICATOR = "\0";
+const VIRTUAL_PREFIX = `${SHARED_CHUNK_VIRTUAL_PREFIX}/`;
+function classifyModuleSourceKind(options) {
+	if (options.isNodeModule) return "node_modules";
+	if (options.inSrc) return "src";
+	if (options.inPlugin) return "plugin";
+	return "workspace";
+}
+function resolvePluginAssetAbsolute(normalizedFileName, pluginRoot) {
+	if (!pluginRoot) return;
+	if (posix.isAbsolute(normalizedFileName)) return isPathInside(pluginRoot, normalizedFileName) ? normalizedFileName : void 0;
+	const pluginBase = posix.basename(pluginRoot);
+	if (normalizedFileName !== pluginBase && !normalizedFileName.startsWith(`${pluginBase}/`)) return;
+	const relative = normalizedFileName === pluginBase ? "" : normalizedFileName.slice(pluginBase.length + 1);
+	const absolute = posix.resolve(pluginRoot, relative);
+	return isPathInside(pluginRoot, absolute) ? absolute : void 0;
+}
+function resolveSubPackageRoot(fileName, context) {
+	const normalized = posix.normalize(fileName);
+	return Array.from(context.subPackageRoots).filter(Boolean).sort((left, right) => right.length - left.length).find((root) => normalized === root || normalized.startsWith(`${root}/`));
+}
+function classifyPackage(fileName, origin, context) {
+	if (fileName.startsWith(VIRTUAL_PREFIX)) {
+		const combination = fileName.slice(VIRTUAL_PREFIX.length).split("/")[0] || "shared";
+		return {
+			id: `virtual:${combination}`,
+			label: `共享虚拟包 ${combination}`,
+			type: "virtual"
+		};
+	}
+	const rootCandidate = resolveSubPackageRoot(fileName, context);
+	if (rootCandidate) {
+		const isIndependent = context.independentRoots.has(rootCandidate);
+		return {
+			id: rootCandidate,
+			label: `${isIndependent ? "独立分包" : "分包"} ${rootCandidate}`,
+			type: isIndependent || origin === "independent" ? "independent" : "subPackage"
+		};
+	}
+	return {
+		id: "__main__",
+		label: "主包",
+		type: "main"
+	};
+}
+function normalizeModuleId(id) {
+	if (!id || id.includes(VIRTUAL_MODULE_INDICATOR)) return;
+	if (!posix.isAbsolute(id)) return;
+	return posix.normalize(id);
+}
+function resolveModuleSourceType(absoluteId, ctx) {
+	const { configService } = ctx;
+	const isNodeModule = absoluteId.includes("/node_modules/") || absoluteId.includes("\\node_modules\\");
+	const pluginRoot = configService.absolutePluginRoot;
+	const srcRoot = configService.absoluteSrcRoot;
+	const sourceType = classifyModuleSourceKind({
+		isNodeModule,
+		inSrc: isPathInside(srcRoot, absoluteId),
+		inPlugin: pluginRoot ? isPathInside(pluginRoot, absoluteId) : false
+	});
+	return {
+		source: configService.relativeAbsoluteSrcRoot(absoluteId),
+		sourceType
+	};
+}
+function resolveAssetSource(fileName, ctx) {
+	const { configService } = ctx;
+	const normalized = posix.normalize(fileName);
+	const srcCandidate = posix.isAbsolute(normalized) ? normalized : posix.resolve(configService.absoluteSrcRoot, normalized);
+	if (isPathInside(configService.absoluteSrcRoot, srcCandidate)) return {
+		absolute: srcCandidate,
+		source: configService.relativeAbsoluteSrcRoot(srcCandidate),
+		sourceType: "src"
+	};
+	const pluginAbsolute = resolvePluginAssetAbsolute(normalized, configService.absolutePluginRoot);
+	if (pluginAbsolute) return {
+		absolute: pluginAbsolute,
+		source: configService.relativeAbsoluteSrcRoot(pluginAbsolute),
+		sourceType: "plugin"
+	};
+}
+//#endregion
+//#region package.json
+var version = "7.5.0";
+//#endregion
+export { resolveModuleSourceType as a, resolveAssetSource as i, classifyPackage as n, normalizeModuleId as r, version as t };