weapp-vite 6.13.4 → 6.14.1

package/dist/cli.mjs

@@ -1,23 +1,27 @@
-import { _ as getDefaultIdeProjectRoot, b as shouldPassPlatformArgToIdeOpen, c as SHARED_CHUNK_VIRTUAL_PREFIX, d as checkRuntime, f as getProjectConfigFileName, g as DEFAULT_MP_PLATFORM, h as createCjsConfigLoadError, m as parseCommentJson, n as syncProjectSupportFiles, o as formatBytes, p as loadViteConfigFile, r as syncManagedTsconfigBootstrapFiles, s as createSharedBuildConfig, t as createCompilerContext, u as resolveWeappConfigFile, v as normalizeMiniPlatform, x as isPathInside, y as resolveMiniPlatform } from "./createContext-Bb4OSo1-.mjs";
-import { r as logger_default, t as colors } from "./logger-gutcwWKE.mjs";
-import { p as VERSION } from "./file-Cf3pf5w7.mjs";
-import { resolveWeappMcpConfig, startWeappViteMcpServer } from "./mcp.mjs";
+import { S as isPathInside, _ as DEFAULT_MP_PLATFORM, b as resolveMiniPlatform, c as createSharedBuildConfig, d as resolveWeappConfigFile, f as checkRuntime, g as createCjsConfigLoadError, h as parseCommentJson, l as SHARED_CHUNK_VIRTUAL_PREFIX, m as loadViteConfigFile, n as syncProjectSupportFiles, p as getProjectConfigFileName, r as syncManagedTsconfigBootstrapFiles, s as formatBytes, t as createCompilerContext, v as getDefaultIdeProjectRoot, x as shouldPassPlatformArgToIdeOpen, y as normalizeMiniPlatform } from "./createContext-DT4tLA1C.mjs";
+import { r as logger_default, t as colors } from "./logger-CgxdNjvb.mjs";
+import { m as VERSION } from "./file-BkvmW6_2.mjs";
+import { a as resolveWeappMcpConfig, o as startWeappViteMcpServer } from "./mcp-DRlj32v4.mjs";
 import { createRequire } from "node:module";
 import { defu, fs } from "@weapp-core/shared";
 import path, { posix } from "pathe";
 import process from "node:process";
 import fs$1 from "node:fs/promises";
 import { build, createServer } from "vite";
+import os from "node:os";
 import { execFile } from "node:child_process";
 import { Buffer } from "node:buffer";
 import fs$2 from "node:fs";
 import { cac } from "cac";
 import { resolveCommand } from "package-manager-detector/commands";
 import { promisify } from "node:util";
-import { formatRetryHotkeyPrompt, formatWechatIdeLoginRequiredError, getConfig, isWeappIdeTopLevelCommand, isWechatIdeLoginRequiredError, parse, startForwardConsole, waitForRetryKeypress } from "weapp-ide-cli";
+import { closeSharedMiniProgram, connectOpenedAutomator, formatRetryHotkeyPrompt, formatWechatIdeLoginRequiredError, getConfig, isWeappIdeTopLevelCommand, isWechatIdeLoginRequiredError, launchAutomator, parse, startForwardConsole, takeScreenshot, waitForRetryKeypress } from "weapp-ide-cli";
 import { generateJs, generateJson, generateWxml, generateWxss } from "@weapp-core/schematics";
 import { determineAgent } from "@vercel/detect-agent";
 import { initConfig } from "@weapp-core/init";
+import { createInterface } from "node:readline/promises";
+import { clearTimeout, setTimeout as setTimeout$1 } from "node:timers";
+import { emitKeypressEvents } from "node:readline";
 //#region src/analyze/subpackages/classifier.ts
 const VIRTUAL_MODULE_INDICATOR = "\0";
 const VIRTUAL_PREFIX = `${SHARED_CHUNK_VIRTUAL_PREFIX}/`;
@@ -950,13 +954,27 @@ function logBuildPackageSizeReport(options) {
 //#region src/cli/openIde.ts
 const execFileAsync = promisify(execFile);
 async function openWechatIdeByAutomator(projectPath) {
-	const { Launcher } = await import("@weapp-vite/miniprogram-automator");
-	(await new Launcher().launch({
+	(await launchAutomator({
 		projectPath,
 		trustProject: true
 	})).disconnect();
 }
 /**
+* @description 若当前项目已在微信开发者工具中打开且自动化可连通，则直接复用现有会话，避免重复拉起 IDE。
+*/
+async function tryReuseOpenedWechatIde(projectPath) {
+	try {
+		(await connectOpenedAutomator({
+			projectPath,
+			timeout: 3e3
+		})).disconnect();
+		logger_default.info("目标项目已在微信开发者工具中打开，跳过重复打开。");
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
 * @description 执行 IDE 打开流程，并在登录失效时允许按键重试。
 */
 async function runWechatIdeOpenWithRetry(argv) {
@@ -1017,6 +1035,7 @@ function resolveIdeProjectRoot(mpDistRoot, cwd) {
 }
 async function openIde(platform, projectPath, options = {}) {
 	if (platform === "weapp" && projectPath && options.trustProject !== false) try {
+		if (await tryReuseOpenedWechatIde(projectPath)) return;
 		await openWechatIdeByAutomator(projectPath);
 		return;
 	} catch (error) {
@@ -1117,7 +1136,9 @@ function registerBuildCommand(cli) {
 			configFile,
 			inlineConfig,
 			cliPlatform: targets.rawPlatform,
-			projectConfigPath: options.projectConfig
+			projectConfigPath: options.projectConfig,
+			syncSupportFiles: false,
+			preloadAppEntry: false
 		});
 		const { buildService, configService, webService } = ctx;
 		logRuntimeTarget(targets, { resolvedConfigPlatform: configService.platform });
@@ -1588,6 +1609,278 @@ function registerInitCommand(cli) {
 	});
 }
 //#endregion
+//#region src/cli/mcpClient.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 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
+	};
+}
+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 = options.transport === "http" ? resolveHttpEntry(options.client, options.url ?? "") : resolveCommandEntry(options.client, workspaceRoot);
+	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
+	};
+}
+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");
+}
+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);
+}
+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/commands/mcp.ts
 function resolvePort(port) {
 	if (typeof port === "number" && Number.isInteger(port)) return port;
@@ -1596,17 +1889,109 @@ function resolvePort(port) {
 		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 resolved = resolveWeappMcpConfig((await loadConfig(resolveConfigFile(options)))?.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;
+	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;
+	await startWeappViteMcpServer({
+		endpoint: options.endpoint,
+		host: options.host,
+		port: resolvePort(options.port),
+		transport: resolvedTransport,
+		unref: options.unref,
+		workspaceRoot: options.workspaceRoot
+	});
+	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", "start weapp-vite MCP server").option("--transport <type>", "[string] stdio | streamable-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("--unref", "[boolean] unref HTTP server to not block process exit").option("--workspace-root <path>", "[string] workspace root path, defaults to auto detect from cwd").action(async (options) => {
-		const { startWeappViteMcpServer } = await import("./mcp.mjs");
-		await startWeappViteMcpServer({
-			endpoint: options.endpoint,
-			host: options.host,
-			port: resolvePort(options.port),
-			transport: options.transport,
-			unref: options.unref,
-			workspaceRoot: options.workspaceRoot
-		});
+	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("--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
@@ -1665,6 +2050,343 @@ function registerPrepareCommand(cli) {
 	});
 }
 //#endregion
+//#region package.json
+var version = "6.14.1";
+//#endregion
+//#region src/cli/devHotkeys.ts
+const DEV_SCREENSHOT_DIR = ".tmp/weapp-vite-dev-screenshots";
+const DEFAULT_SCREENSHOT_TIMEOUT = 3e4;
+const REG_PENDING_PREFIX = /^正在/;
+const FULLWIDTH_ASCII_START = 65281;
+const FULLWIDTH_ASCII_END = 65374;
+const FULLWIDTH_ASCII_OFFSET = 65248;
+const HOTKEY_DEDUP_WINDOW_MS = 32;
+function formatMcpUrl(host, port, endpoint) {
+	return `http://${host}:${port}${endpoint}`;
+}
+function forwardSigint() {
+	process.kill(process.pid, "SIGINT");
+}
+function forwardSigtstp() {
+	process.kill(process.pid, "SIGTSTP");
+}
+function formatProjectLabel(cwd) {
+	return path.basename(cwd) || cwd;
+}
+function formatMcpStatus(state) {
+	if (!state.mcpEnabled) return "已禁用";
+	return state.mcpRunning ? "运行中" : "未启动";
+}
+function formatFooterLine(state) {
+	if (state.currentAction) return `执行中    ${state.currentAction}`;
+	return "就绪      等待操作...";
+}
+/**
+* @description 生成带状态的开发态快捷键帮助文本。
+*/
+function formatDevHotkeyHelpWithState(state) {
+	const key = (value) => colors.bold(colors.green(value));
+	const actionRows = [{
+		key: key("s"),
+		description: "截图当前页面并保存到本地"
+	}, {
+		key: key("m"),
+		description: "开关 MCP 服务"
+	}];
+	const processRows = [
+		{
+			key: key("q"),
+			description: "退出当前 dev"
+		},
+		{
+			key: key("Ctrl+C"),
+			description: "强制中断当前 dev"
+		},
+		{
+			key: key("Ctrl+Z"),
+			description: "暂时挂起当前 dev，恢复终端控制"
+		}
+	];
+	const helpRows = [{
+		key: key("h"),
+		description: "重新显示这份帮助"
+	}];
+	const keyColumnWidth = Math.max(...[
+		...actionRows,
+		...processRows,
+		...helpRows
+	].map((row) => row.key.length));
+	const formatRows = (rows) => rows.map(({ key, description }) => `按 ${key.padEnd(keyColumnWidth)}  ${description}`);
+	return [
+		`${colors.bold(colors.green("DEV"))}  weapp-vite v${version}  ${state.projectLabel ?? "weapp"}`,
+		"",
+		"快捷命令",
+		...formatRows(actionRows),
+		"",
+		"进程控制",
+		...formatRows(processRows),
+		"",
+		"帮助",
+		...formatRows(helpRows),
+		"",
+		`当前状态：${state.currentAction ?? "等待操作"} / MCP ${formatMcpStatus(state)}`
+	].join("\n");
+}
+/**
+* @description 生成带状态的开发态快捷键简短提示。
+*/
+function formatDevHotkeyHintWithState(state) {
+	const key = (value) => colors.bold(colors.green(value));
+	if (state.currentAction) return `${formatFooterLine(state)}，按 ${key("h")} 显示帮助，按 ${key("q")} 退出`;
+	return `开发快捷键已就绪，按 ${key("h")} 显示帮助，按 ${key("q")} 退出`;
+}
+/**
+* @description 生成开发态截图输出路径。
+*/
+function resolveDevScreenshotOutputPath(cwd, now = /* @__PURE__ */ new Date()) {
+	const stamp = now.toISOString().replace(/[:.]/g, "-");
+	return path.join(cwd, DEV_SCREENSHOT_DIR, `screenshot-${stamp}.png`);
+}
+function formatLogPath(cwd, targetPath) {
+	const relativePath = path.relative(cwd, targetPath);
+	if (!relativePath || relativePath.startsWith("..")) return targetPath;
+	return relativePath;
+}
+function formatResolvedScreenshotPath(cwd, fallbackPath, result) {
+	return formatLogPath(cwd, result.path ?? fallbackPath);
+}
+function normalizeInputChar(input) {
+	if (input.length !== 1) return input;
+	const codePoint = input.codePointAt(0);
+	if (!codePoint) return input;
+	if (codePoint >= FULLWIDTH_ASCII_START && codePoint <= FULLWIDTH_ASCII_END) return String.fromCodePoint(codePoint - FULLWIDTH_ASCII_OFFSET);
+	return input;
+}
+/**
+* @description 执行当前页面截图并输出结果日志。
+*/
+async function runScreenshotAction(options) {
+	const outputPath = resolveDevScreenshotOutputPath(options.cwd);
+	await fs$1.mkdir(path.dirname(outputPath), { recursive: true });
+	logger_default.info(`[dev action] 正在截图当前页面，输出到 ${colors.cyan(formatLogPath(options.cwd, outputPath))}`);
+	const result = await takeScreenshot({
+		fullPage: true,
+		projectPath: options.projectPath,
+		sharedSession: true,
+		outputPath,
+		timeout: DEFAULT_SCREENSHOT_TIMEOUT
+	});
+	const resolvedPath = formatResolvedScreenshotPath(options.cwd, outputPath, result);
+	logger_default.success(`[dev action] 当前页面截图完成：${colors.cyan(resolvedPath)}`);
+	return resolvedPath;
+}
+/**
+* @description 在开发态启动终端快捷键，并将动作输出到本地日志。
+*/
+function startDevHotkeys(options) {
+	if (options.platform !== "weapp" || !process.stdin.isTTY) return;
+	emitKeypressEvents(process.stdin);
+	const hasSetRawMode = typeof process.stdin.setRawMode === "function";
+	if (hasSetRawMode) process.stdin.setRawMode(true);
+	process.stdin.resume();
+	let closed = false;
+	let running = false;
+	let mcpHandle;
+	let onData;
+	let onKeypress;
+	let onSigcont;
+	let currentAction;
+	let lastAction;
+	let lastRenderedPanel = "";
+	const recentInputs = /* @__PURE__ */ new Map();
+	const resolvedMcp = resolveWeappMcpConfig(options.mcpConfig);
+	const getState = () => ({
+		currentAction,
+		lastAction,
+		mcpEnabled: resolvedMcp.enabled,
+		mcpRunning: Boolean(mcpHandle?.close),
+		projectLabel: formatProjectLabel(options.cwd)
+	});
+	const detachTerminal = () => {
+		if (hasSetRawMode) process.stdin.setRawMode(false);
+		process.stdin.pause();
+	};
+	const attachTerminal = () => {
+		if (closed) return;
+		if (hasSetRawMode) process.stdin.setRawMode(true);
+		process.stdin.resume();
+	};
+	const ensureTerminalActive = () => {
+		if (closed) return;
+		if (hasSetRawMode) process.stdin.setRawMode(true);
+		process.stdin.resume();
+	};
+	const close = () => {
+		if (closed) return;
+		closed = true;
+		if (onData) process.stdin.off("data", onData);
+		if (onKeypress) process.stdin.off("keypress", onKeypress);
+		if (onSigcont) process.off("SIGCONT", onSigcont);
+		detachTerminal();
+		if (mcpHandle?.close) mcpHandle.close().catch((error) => {
+			logger_default.warn(`[dev action] MCP 服务关闭失败：${error instanceof Error ? error.message : String(error)}`);
+		});
+		closeSharedMiniProgram(options.projectPath).catch((error) => {
+			logger_default.warn(`[dev action] DevTools 会话关闭失败：${error instanceof Error ? error.message : String(error)}`);
+		});
+	};
+	const printPanel = (message, force = false) => {
+		if (!force && message === lastRenderedPanel) return;
+		lastRenderedPanel = message;
+		logger_default.info(message);
+	};
+	const printHelp = () => {
+		printPanel(formatDevHotkeyHelpWithState(getState()), true);
+		ensureTerminalActive();
+	};
+	const printHint = () => {
+		printPanel(formatDevHotkeyHintWithState(getState()));
+		ensureTerminalActive();
+	};
+	const restore = () => {
+		if (closed) return;
+		if (onData) process.stdin.off("data", onData);
+		if (onKeypress) process.stdin.off("keypress", onKeypress);
+		attachTerminal();
+		if (onData) process.stdin.on("data", onData);
+		if (onKeypress) process.stdin.on("keypress", onKeypress);
+		printHint();
+	};
+	const suspend = () => {
+		lastRenderedPanel = "";
+		detachTerminal();
+		forwardSigtstp();
+	};
+	const toggleMcp = async () => {
+		if (!resolvedMcp.enabled) {
+			logger_default.warn("[dev action] MCP 已在配置中禁用，跳过切换。");
+			return "MCP 已禁用";
+		}
+		if (mcpHandle?.close) {
+			const url = formatMcpUrl(resolvedMcp.host, resolvedMcp.port, resolvedMcp.endpoint);
+			logger_default.info(`[dev action] 正在关闭 MCP 服务：${colors.cyan(url)}`);
+			await mcpHandle.close();
+			mcpHandle = void 0;
+			logger_default.success(`[dev action] MCP 服务已关闭：${colors.cyan(url)}`);
+			return `MCP 已关闭 (${url})`;
+		}
+		const url = formatMcpUrl(resolvedMcp.host, resolvedMcp.port, resolvedMcp.endpoint);
+		logger_default.info(`[dev action] 正在启动 MCP 服务：${colors.cyan(url)}`);
+		mcpHandle = await startWeappViteMcpServer({
+			endpoint: resolvedMcp.endpoint,
+			host: resolvedMcp.host,
+			port: resolvedMcp.port,
+			transport: "streamable-http",
+			unref: false,
+			workspaceRoot: options.cwd
+		});
+		logger_default.success(`[dev action] MCP 服务已启动：${colors.cyan(url)}`);
+		for (const line of formatMcpQuickStart({
+			httpUrl: url,
+			transport: "http"
+		})) logger_default.info(line);
+		return `MCP 已启动 (${url})`;
+	};
+	const runAction = (label, pendingLabel, action) => {
+		if (running) {
+			const current = currentAction ?? "已有命令";
+			logger_default.warn(`[dev action] 当前正在${current.replace(REG_PENDING_PREFIX, "")}，请稍后再试。`);
+			return;
+		}
+		running = true;
+		currentAction = pendingLabel;
+		printHint();
+		action().then((summary) => {
+			if (summary) lastAction = summary;
+		}).catch((error) => {
+			logger_default.error(`[dev action] ${label}失败：${error instanceof Error ? error.message : String(error)}`);
+		}).finally(() => {
+			running = false;
+			currentAction = void 0;
+			if (!closed) printHint();
+		});
+	};
+	const handleInput = (input) => {
+		if (closed) return;
+		const normalizedInput = normalizeInputChar(input);
+		if (normalizedInput === "") {
+			close();
+			forwardSigint();
+			return;
+		}
+		if (normalizedInput === "") {
+			suspend();
+			return;
+		}
+		const normalized = normalizedInput.toLowerCase();
+		if (normalized === "q") {
+			close();
+			forwardSigint();
+			return;
+		}
+		if (normalized === "h") {
+			printHelp();
+			return;
+		}
+		if (normalized === "s") {
+			runAction("截图", "正在截图当前页面", async () => {
+				return `截图已保存到 ${await runScreenshotAction(options)}`;
+			});
+			return;
+		}
+		if (normalized === "m") runAction("MCP 切换", mcpHandle?.close ? "正在关闭 MCP 服务" : "正在启动 MCP 服务", async () => {
+			return await toggleMcp();
+		});
+	};
+	const handleInputOnce = (input, source) => {
+		const normalizedInput = normalizeInputChar(input);
+		const now = Date.now();
+		for (const [token, timestamp] of recentInputs) if (now - timestamp > HOTKEY_DEDUP_WINDOW_MS) recentInputs.delete(token);
+		const dedupKey = normalizedInput;
+		const recentEntry = recentInputs.get(dedupKey);
+		if (recentEntry !== void 0) {
+			const [recentSource, recentTimestamp] = recentEntry.split(":");
+			if (recentSource !== source && now - Number(recentTimestamp) <= HOTKEY_DEDUP_WINDOW_MS) return;
+		}
+		recentInputs.set(dedupKey, `${source}:${now}`);
+		handleInput(normalizedInput);
+	};
+	onData = (chunk) => {
+		const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+		for (const char of text) handleInputOnce(char, "data");
+	};
+	process.stdin.on("data", onData);
+	onKeypress = (str, key) => {
+		if (key?.ctrl && key.name === "c") {
+			handleInputOnce("", "keypress");
+			return;
+		}
+		if (key?.ctrl && key.name === "z") {
+			handleInputOnce("", "keypress");
+			return;
+		}
+		if (typeof str === "string" && str) handleInputOnce(str, "keypress");
+	};
+	process.stdin.on("keypress", onKeypress);
+	onSigcont = () => {
+		restore();
+	};
+	process.on("SIGCONT", onSigcont);
+	if (!options.silentStartupHint) printHint();
+	if (resolvedMcp.enabled && resolvedMcp.autoStart) runAction("MCP 自动启动", "正在启动 MCP 服务", async () => {
+		await toggleMcp();
+	});
+	return {
+		close,
+		restore
+	};
+}
+//#endregion
 //#region src/cli/commands/serve.ts
 function emitDashboardEvents(handle, events) {
 	handle?.emitRuntimeEvents(events);
@@ -1680,6 +2402,17 @@ const REG_DIST_POSIX_SEP = /\\/g;
 function hasAnalyzeData(result) {
 	return result.packages.length > 0 || result.modules.length > 0;
 }
+function waitForServeShutdownSignal() {
+	return new Promise((resolve) => {
+		const onSignal = () => {
+			process.off("SIGINT", onSignal);
+			process.off("SIGTERM", onSignal);
+			resolve();
+		};
+		process.on("SIGINT", onSignal);
+		process.on("SIGTERM", onSignal);
+	});
+}
 async function collectOutputFiles(root) {
 	const entries = await fs$1.readdir(root, { withFileTypes: true });
 	const files = [];
@@ -1811,165 +2544,181 @@ function registerServeCommand(cli) {
 		const enableAnalyze = Boolean(isUiEnabled(options) && targets.runMini);
 		let analyzeHandle;
 		let analyzeRunId = 0;
-		const runAnalyze = async () => {
-			const startedAt = Date.now();
-			try {
-				const result = await analyzeSubpackages(await createCompilerContext({
-					key: `serve-ui-analyze:${process.pid}:${++analyzeRunId}`,
-					cwd: configService.cwd,
-					mode: configService.mode,
-					isDev: false,
-					configFile,
-					inlineConfig: createInlineConfig(targets.mpPlatform),
-					cliPlatform: targets.rawPlatform,
-					projectConfigPath: options.projectConfig,
-					syncSupportFiles: false
-				}));
-				if (hasAnalyzeData(result)) return {
-					result,
-					durationMs: Date.now() - startedAt,
-					mode: "full"
-				};
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				logger_default.warn(`[ui] 完整分析失败，已回退到 dist 文件扫描：${message}`);
+		const devHotkeysSession = targets.runMini ? startDevHotkeys({
+			cwd: configService.cwd,
+			mcpConfig: configService.weappViteConfig?.weapp?.mcp,
+			platform: configService.platform,
+			projectPath: resolveIdeProjectRoot(configService.mpDistRoot, configService.cwd),
+			silentStartupHint: true
+		}) : void 0;
+		try {
+			const runAnalyze = async () => {
+				const startedAt = Date.now();
+				try {
+					const result = await analyzeSubpackages(await createCompilerContext({
+						key: `serve-ui-analyze:${process.pid}:${++analyzeRunId}`,
+						cwd: configService.cwd,
+						mode: configService.mode,
+						isDev: false,
+						configFile,
+						inlineConfig: createInlineConfig(targets.mpPlatform),
+						cliPlatform: targets.rawPlatform,
+						projectConfigPath: options.projectConfig,
+						syncSupportFiles: false
+					}));
+					if (hasAnalyzeData(result)) return {
+						result,
+						durationMs: Date.now() - startedAt,
+						mode: "full"
+					};
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					logger_default.warn(`[ui] 完整分析失败，已回退到 dist 文件扫描：${message}`);
+					return {
+						result: await analyzeUiFallback(ctx),
+						durationMs: Date.now() - startedAt,
+						mode: "fallback",
+						fallbackReason: message
+					};
+				}
 				return {
 					result: await analyzeUiFallback(ctx),
 					durationMs: Date.now() - startedAt,
 					mode: "fallback",
-					fallbackReason: message
+					fallbackReason: "完整分析结果为空，已回退到 dist 文件扫描。"
 				};
-			}
-			return {
-				result: await analyzeUiFallback(ctx),
-				durationMs: Date.now() - startedAt,
-				mode: "fallback",
-				fallbackReason: "完整分析结果为空，已回退到 dist 文件扫描。"
 			};
-		};
-		const triggerAnalyzeUpdate = async (reason = "watch") => {
-			if (!analyzeHandle) return;
-			emitDashboardEvents(analyzeHandle, [{
-				kind: reason === "watch" ? "hmr" : "build",
-				level: "info",
-				title: reason === "watch" ? "analyze refresh started" : "initial analyze started",
-				detail: reason === "watch" ? "检测到新的构建结束事件，开始刷新 analyze 面板。" : "开发态 UI 已启动，开始生成第一份 analyze 结果。",
-				tags: reason === "watch" ? ["watch", "analyze"] : ["initial", "analyze"]
-			}]);
-			const next = await runAnalyze();
-			if (next.mode === "fallback") emitDashboardEvents(analyzeHandle, [{
-				kind: "diagnostic",
-				level: "warning",
-				title: "analyze fallback enabled",
-				detail: next.fallbackReason ?? "完整分析不可用，已回退到 dist 文件扫描。",
-				durationMs: next.durationMs,
-				tags: ["analyze", "fallback"]
-			}]);
-			await analyzeHandle.update(next.result);
-			emitDashboardEvents(analyzeHandle, [{
-				kind: next.mode === "fallback" ? "diagnostic" : "build",
-				level: next.mode === "fallback" ? "warning" : "success",
-				title: reason === "watch" ? "analyze refresh completed" : "initial analyze completed",
-				detail: next.mode === "fallback" ? `analyze 已回退到 dist 扫描，当前包含 ${next.result.packages.length} 个包。` : `analyze 已刷新完成，当前包含 ${next.result.packages.length} 个包与 ${next.result.modules.length} 个模块。`,
-				durationMs: next.durationMs,
-				tags: next.mode === "fallback" ? ["analyze", "fallback"] : ["analyze", reason === "watch" ? "refresh" : "initial"]
-			}]);
-		};
-		if (targets.runMini) {
-			const miniBuildStartedAt = Date.now();
-			const buildResult = await buildService.build(options);
-			logger_default.success(`小程序初次构建完成，耗时：${formatDuration(Date.now() - miniBuildStartedAt)}`);
-			if (enableAnalyze) {
-				const initialAnalyze = await runAnalyze();
-				analyzeHandle = await startAnalyzeDashboard(initialAnalyze.result, {
-					watch: true,
-					cwd: configService.cwd,
-					packageManagerAgent: configService.packageManager.agent,
-					silentStartupLog: true
-				}) ?? void 0;
+			const triggerAnalyzeUpdate = async (reason = "watch") => {
+				if (!analyzeHandle) return;
 				emitDashboardEvents(analyzeHandle, [{
-					kind: "command",
-					level: "success",
-					title: "dev ui session ready",
-					detail: `开发态分析面板已启动，当前包含 ${initialAnalyze.result.packages.length} 个包。`,
-					durationMs: initialAnalyze.durationMs,
-					tags: ["dev", "ui"]
+					kind: reason === "watch" ? "hmr" : "build",
+					level: "info",
+					title: reason === "watch" ? "analyze refresh started" : "initial analyze started",
+					detail: reason === "watch" ? "检测到新的构建结束事件，开始刷新 analyze 面板。" : "开发态 UI 已启动，开始生成第一份 analyze 结果。",
+					tags: reason === "watch" ? ["watch", "analyze"] : ["initial", "analyze"]
 				}]);
-				if (initialAnalyze.mode === "fallback") emitDashboardEvents(analyzeHandle, [{
+				const next = await runAnalyze();
+				if (next.mode === "fallback") emitDashboardEvents(analyzeHandle, [{
 					kind: "diagnostic",
 					level: "warning",
-					title: "initial analyze fallback enabled",
-					detail: initialAnalyze.fallbackReason ?? "完整分析不可用，已回退到 dist 文件扫描。",
-					durationMs: initialAnalyze.durationMs,
-					tags: [
-						"analyze",
-						"fallback",
-						"initial"
-					]
+					title: "analyze fallback enabled",
+					detail: next.fallbackReason ?? "完整分析不可用，已回退到 dist 文件扫描。",
+					durationMs: next.durationMs,
+					tags: ["analyze", "fallback"]
 				}]);
-				let updating = false;
-				if (analyzeHandle && buildResult && typeof buildResult.on === "function") buildResult.on("event", (event) => {
-					if (event.code !== "END" || updating) return;
-					updating = true;
-					triggerAnalyzeUpdate("watch").finally(() => {
-						updating = false;
+				await analyzeHandle.update(next.result);
+				emitDashboardEvents(analyzeHandle, [{
+					kind: next.mode === "fallback" ? "diagnostic" : "build",
+					level: next.mode === "fallback" ? "warning" : "success",
+					title: reason === "watch" ? "analyze refresh completed" : "initial analyze completed",
+					detail: next.mode === "fallback" ? `analyze 已回退到 dist 扫描，当前包含 ${next.result.packages.length} 个包。` : `analyze 已刷新完成，当前包含 ${next.result.packages.length} 个包与 ${next.result.modules.length} 个模块。`,
+					durationMs: next.durationMs,
+					tags: next.mode === "fallback" ? ["analyze", "fallback"] : ["analyze", reason === "watch" ? "refresh" : "initial"]
+				}]);
+			};
+			if (targets.runMini) {
+				const miniBuildStartedAt = Date.now();
+				const buildResult = await buildService.build(options);
+				logger_default.success(`小程序初次构建完成，耗时：${formatDuration(Date.now() - miniBuildStartedAt)}`);
+				if (enableAnalyze) {
+					const initialAnalyze = await runAnalyze();
+					analyzeHandle = await startAnalyzeDashboard(initialAnalyze.result, {
+						watch: true,
+						cwd: configService.cwd,
+						packageManagerAgent: configService.packageManager.agent,
+						silentStartupLog: true
+					}) ?? void 0;
+					emitDashboardEvents(analyzeHandle, [{
+						kind: "command",
+						level: "success",
+						title: "dev ui session ready",
+						detail: `开发态分析面板已启动，当前包含 ${initialAnalyze.result.packages.length} 个包。`,
+						durationMs: initialAnalyze.durationMs,
+						tags: ["dev", "ui"]
+					}]);
+					if (initialAnalyze.mode === "fallback") emitDashboardEvents(analyzeHandle, [{
+						kind: "diagnostic",
+						level: "warning",
+						title: "initial analyze fallback enabled",
+						detail: initialAnalyze.fallbackReason ?? "完整分析不可用，已回退到 dist 文件扫描。",
+						durationMs: initialAnalyze.durationMs,
+						tags: [
+							"analyze",
+							"fallback",
+							"initial"
+						]
+					}]);
+					let updating = false;
+					if (analyzeHandle && buildResult && typeof buildResult.on === "function") buildResult.on("event", (event) => {
+						if (event.code !== "END" || updating) return;
+						updating = true;
+						triggerAnalyzeUpdate("watch").finally(() => {
+							updating = false;
+						});
 					});
-				});
-				if (analyzeHandle) {
-					updating = true;
-					await triggerAnalyzeUpdate("initial");
-					updating = false;
+					if (analyzeHandle) {
+						updating = true;
+						await triggerAnalyzeUpdate("initial");
+						updating = false;
+					}
 				}
 			}
-		}
-		let webServer;
-		if (targets.runWeb) {
-			const webServerStartedAt = Date.now();
-			try {
-				webServer = await webService?.startDevServer();
-				logger_default.success(`Web 开发服务启动完成，耗时：${formatDuration(Date.now() - webServerStartedAt)}`);
-				emitDashboardEvents(analyzeHandle, [{
-					kind: "system",
-					level: "success",
-					title: "web dev server started",
-					detail: "Web 开发服务器已启动，可与小程序调试 UI 并行工作。",
-					durationMs: Date.now() - webServerStartedAt,
-					tags: ["dev", "web"]
-				}]);
-			} catch (error) {
+			let webServer;
+			if (targets.runWeb) {
+				const webServerStartedAt = Date.now();
+				try {
+					webServer = await webService?.startDevServer();
+					logger_default.success(`Web 开发服务启动完成，耗时：${formatDuration(Date.now() - webServerStartedAt)}`);
+					emitDashboardEvents(analyzeHandle, [{
+						kind: "system",
+						level: "success",
+						title: "web dev server started",
+						detail: "Web 开发服务器已启动，可与小程序调试 UI 并行工作。",
+						durationMs: Date.now() - webServerStartedAt,
+						tags: ["dev", "web"]
+					}]);
+				} catch (error) {
+					emitDashboardEvents(analyzeHandle, [{
+						kind: "diagnostic",
+						level: "error",
+						title: "web dev server failed",
+						detail: error instanceof Error ? error.message : String(error),
+						durationMs: Date.now() - webServerStartedAt,
+						tags: ["dev", "web"]
+					}]);
+					logger_default.error(error);
+					throw error;
+				}
+			}
+			if (targets.runMini) {
+				logBuildAppFinish(configService, webServer, {
+					skipWeb: !targets.runWeb,
+					uiUrls: analyzeHandle?.urls
+				});
+				devHotkeysSession?.restore();
+			} else if (targets.runWeb) logBuildAppFinish(configService, webServer, { skipMini: true });
+			if (options.open && targets.runMini) {
 				emitDashboardEvents(analyzeHandle, [{
-					kind: "diagnostic",
-					level: "error",
-					title: "web dev server failed",
-					detail: error instanceof Error ? error.message : String(error),
-					durationMs: Date.now() - webServerStartedAt,
-					tags: ["dev", "web"]
+					kind: "command",
+					level: "info",
+					title: "opening ide",
+					detail: "开发服务已就绪，准备打开 IDE 项目。",
+					tags: ["ide", "open"]
 				}]);
-				logger_default.error(error);
-				throw error;
+				if (!await maybeStartForwardConsole({
+					platform: configService.platform,
+					mpDistRoot: configService.mpDistRoot,
+					cwd: configService.cwd,
+					weappViteConfig: configService.weappViteConfig
+				})) await openIde(configService.platform, resolveIdeProjectRoot(configService.mpDistRoot, configService.cwd), { trustProject: options.trustProject });
+				devHotkeysSession?.restore();
 			}
+			if (analyzeHandle) await analyzeHandle.waitForExit();
+			else if (targets.runMini || targets.runWeb) await waitForServeShutdownSignal();
+		} finally {
+			devHotkeysSession?.close();
+			ctx.watcherService?.closeAll();
 		}
-		if (targets.runMini) logBuildAppFinish(configService, webServer, {
-			skipWeb: !targets.runWeb,
-			uiUrls: analyzeHandle?.urls
-		});
-		else if (targets.runWeb) logBuildAppFinish(configService, webServer, { skipMini: true });
-		if (options.open && targets.runMini) {
-			emitDashboardEvents(analyzeHandle, [{
-				kind: "command",
-				level: "info",
-				title: "opening ide",
-				detail: "开发服务已就绪，准备打开 IDE 项目。",
-				tags: ["ide", "open"]
-			}]);
-			if (!await maybeStartForwardConsole({
-				platform: configService.platform,
-				mpDistRoot: configService.mpDistRoot,
-				cwd: configService.cwd,
-				weappViteConfig: configService.weappViteConfig
-			})) await openIde(configService.platform, resolveIdeProjectRoot(configService.mpDistRoot, configService.cwd), { trustProject: options.trustProject });
-		}
-		if (analyzeHandle) await analyzeHandle.waitForExit();
 	});
 }
 //#endregion
@@ -2058,13 +2807,12 @@ const SKIP_COMMANDS = new Set([
 	"ide",
 	"mcp"
 ]);
-const DEV_COMMANDS = new Set(["dev", "serve"]);
+const REG_EADDRINUSE = /EADDRINUSE/;
 let started = false;
 function shouldAutoStartMcp(argv) {
 	const command = argv[0];
 	if (!command || command.startsWith("-")) return true;
 	if (SKIP_COMMANDS.has(command)) return false;
-	if (DEV_COMMANDS.has(command)) return true;
 	return command.includes("/") || command.includes("\\") || command.startsWith(".");
 }
 async function maybeAutoStartMcpServer(argv, cliOptions) {
@@ -2092,9 +2840,13 @@ async function maybeAutoStartMcpServer(argv, cliOptions) {
 		const mcpUrl = `http://${resolvedMcp.host}:${resolvedMcp.port}${resolvedMcp.endpoint}`;
 		logger_default.success("MCP 服务已自动启动：");
 		logger_default.info(`  ➜  ${colors.cyan(mcpUrl)}`);
+		for (const line of formatMcpQuickStart({
+			httpUrl: mcpUrl,
+			transport: "http"
+		})) logger_default.info(line);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		if (/EADDRINUSE/.test(message)) {
+		if (REG_EADDRINUSE.test(message)) {
 			logger_default.info(`[mcp] 端口 ${resolvedMcp.port} 已被占用，跳过自动启动。`);
 			started = true;
 			return;
@@ -2174,22 +2926,19 @@ function resolveManagedTsconfigBootstrapRoot(args) {
 	return path.resolve(firstArg);
 }
 try {
-	Promise.resolve().then(async () => {
-		const args = process.argv.slice(2);
-		if (await tryRunIdeCommand(args)) return;
+	const args = process.argv.slice(2);
+	if (!await tryRunIdeCommand(args)) {
 		const managedTsconfigBootstrapRoot = resolveManagedTsconfigBootstrapRoot(args);
 		if (managedTsconfigBootstrapRoot) await syncManagedTsconfigBootstrapFiles(managedTsconfigBootstrapRoot);
 		cli.parse(process.argv, { run: false });
 		await maybeAutoStartMcpServer(args, cli.options);
 		await cli.runMatchedCommand();
-	}).catch((error) => {
-		if (handlePrepareLifecycleError(process.argv.slice(2), error)) return;
+	}
+} catch (error) {
+	if (!handlePrepareLifecycleError(process.argv.slice(2), error)) {
 		handleCLIError(error);
 		process.exitCode = 1;
-	});
-} catch (error) {
-	handleCLIError(error);
-	process.exitCode = 1;
+	}
 }
 //#endregion
 export {};