weapp-vite 7.5.0 → 7.7.0

package/dist/openIde-QoYKhuuM.mjs

@@ -0,0 +1,643 @@
+import { n as getDefaultIdeProjectRoot, w as shouldPassPlatformArgToIdeOpen } from "./platform-BiMpsZIb.mjs";
+import { r as logger_default, t as colors } from "./logger-DGn5iEVN.mjs";
+import { t as createCompilerContext } from "./createContext-W0TeXxbo.mjs";
+import { i as resolveRuntimeTargets, t as createInlineConfig } from "./runtime-CKtMVERT.mjs";
+import process from "node:process";
+import path from "pathe";
+import fs from "node:fs";
+import { RETRY_CONFIRM_KEYS, bootstrapWechatDevtoolsSettings, clearWechatIdeCache, clearWechatIdeCacheByAutomator, closeWechatIdeProject, compileWechatIdeByAutomator, connectOpenedAutomator, createWechatIdeLoginRequiredExitError, formatAutomatorLoginError, isAutomatorLoginError, isWechatIdeEngineBuildEndpointMissingError, isWechatIdeLoginRequiredError, isWechatIdeLoginRequiredExitError, launchAutomator, parse, promptRetryKeypress, promptWechatIdeLoginRetry, quitWechatIde, resetWechatIdeFileUtilsByHttp, resolveProjectAutomatorPort, runRetryableCommand, runWechatIdeEngineBuild, runWithSuspendedSharedInput, withWechatDevtoolsSelection, withWechatDevtoolsSelectionArgs } from "weapp-ide-cli";
+// src/cli/openIde/execute.ts
+function readArgOption(argv, ...names) {
+	for (let index = 0; index < argv.length; index += 1) {
+		const current = argv[index];
+		if (!names.includes(current)) continue;
+		const next = argv[index + 1];
+		if (typeof next === "string" && !next.startsWith("-")) return next;
+	}
+}
+async function tryExecuteWechatIdeCliCommandByAutomator(argv, projectPath, options = {}) {
+	if (!projectPath) return false;
+	const command = argv[0];
+	if (!command) return false;
+	if (command === "compile") {
+		await compileWechatIdeByAutomator({
+			preserveProjectRoot: options.preserveProjectRoot,
+			projectPath
+		});
+		return true;
+	}
+	if (command === "cache") {
+		const cleanType = readArgOption(argv, "--clean", "-c");
+		if (cleanType !== "compile" && cleanType !== "all") return false;
+		await clearWechatIdeCacheByAutomator({
+			clean: cleanType,
+			preserveProjectRoot: options.preserveProjectRoot,
+			projectPath
+		});
+		return true;
+	}
+	return false;
+}
+async function tryExecuteWechatIdeCliCommandByHttp(argv, projectPath, engineBuildFallbackToCli = false) {
+	const command = argv[0];
+	if (!command) return false;
+	if (command === "reset-fileutils") {
+		if (!projectPath) return false;
+		await resetWechatIdeFileUtilsByHttp(projectPath);
+		return true;
+	}
+	if (command === "engine" && argv[1] === "build") {
+		const engineProjectPath = argv[2] || projectPath;
+		if (!engineProjectPath) return false;
+		await runWechatIdeEngineBuild(engineProjectPath, {
+			fallbackToCli: engineBuildFallbackToCli,
+			logPath: readArgOption(argv, "--logPath", "-l")
+		});
+		return true;
+	}
+	return false;
+}
+async function tryExecuteWechatIdeCliCommandByHelper(argv) {
+	const command = argv[0];
+	if (!command) return false;
+	if (command === "close") {
+		await closeWechatIdeProject();
+		return true;
+	}
+	if (command === "quit") {
+		await quitWechatIde();
+		return true;
+	}
+	if (command === "cache") {
+		const cleanType = readArgOption(argv, "--clean", "-c");
+		if (!cleanType) return false;
+		await clearWechatIdeCache({ clean: cleanType });
+		return true;
+	}
+	return false;
+}
+/**
+* @description 统一执行 weapp-ide-cli 命令，并在登录失效时复用同一套重试交互。
+*/
+async function executeSelectedWechatIdeCliCommand(argv, options = {}) {
+	const { automatorMode = "prefer", cancelLevel = "warn", engineBuildFallbackToCli = false, httpMode = "prefer", promptOpenIdeLogin = true, onNonLoginError, onRetry, projectPath, preserveProjectRoot } = options;
+	await runWithSuspendedSharedInput(async () => {
+		if (httpMode !== "skip") try {
+			if (await tryExecuteWechatIdeCliCommandByHttp(argv, projectPath, engineBuildFallbackToCli)) return;
+		} catch (error) {
+			if (httpMode === "require" || isWechatIdeEngineBuildEndpointMissingError(error)) throw error;
+		}
+		if (automatorMode !== "skip") try {
+			if (await tryExecuteWechatIdeCliCommandByAutomator(argv, projectPath, { preserveProjectRoot })) return;
+		} catch (error) {
+			if (automatorMode === "require") throw error;
+		}
+		try {
+			if (await tryExecuteWechatIdeCliCommandByHelper(argv)) return;
+		} catch (error) {
+			if (isWechatIdeLoginRequiredExitError(error)) throw error;
+			if (onNonLoginError) {
+				onNonLoginError(error);
+				return;
+			}
+			throw error;
+		}
+		await runRetryableCommand({
+			createCancelError: (error) => createWechatIdeLoginRequiredExitError(error, "cancelled"),
+			execute: async () => {
+				try {
+					await parse(argv);
+					return null;
+				} catch (error) {
+					if (isWechatIdeLoginRequiredExitError(error)) throw error;
+					if (!isWechatIdeLoginRequiredError(error)) {
+						if (onNonLoginError) {
+							onNonLoginError(error);
+							return null;
+						}
+						throw error;
+					}
+					return error;
+				}
+			},
+			isRetryableResult: (result) => result !== null,
+			onCancel: () => {},
+			onRetry: () => {
+				onRetry?.();
+			},
+			promptRetry: async (error) => await promptWechatIdeLoginRetry({
+				cancelLevel,
+				error,
+				logger: logger_default,
+				promptOpenIdeLogin
+			}),
+			shouldRetry: (action) => action === "retry"
+		});
+	});
+}
+/** 安装选择覆盖 HTTP、automator 与 CLI 回退的完整操作。 */
+async function executeWechatIdeCliCommand(argv, options = {}) {
+	return await withWechatDevtoolsSelectionArgs(argv, (args) => executeSelectedWechatIdeCliCommand(args, options));
+}
+// src/cli/openIde/close.ts
+/**
+* @description 执行用户显式请求的 CLI close；失败时保留宿主，不升级为系统级退出。
+*/
+async function closeIde$1() {
+	try {
+		await closeWechatIdeProject();
+		return true;
+	} catch (error) {
+		if (isWechatIdeLoginRequiredError(error)) try {
+			await executeWechatIdeCliCommand(["close"], {
+				cancelLevel: "warn",
+				onNonLoginError: (retryError) => logger_default.error(retryError),
+				onRetry: () => logger_default.info("正在重试连接微信开发者工具...")
+			});
+			return true;
+		} catch (retryError) {
+			logger_default.error(retryError);
+		}
+		else {
+			logger_default.warn("微信开发者工具 CLI close 执行失败，已保留现有宿主；请在开发者工具中手动关闭目标项目。");
+			logger_default.error(error);
+		}
+		return false;
+	}
+}
+// src/cli/openIde/diagnostics.ts
+/**
+* @description 将 automator 启动错误归类为用户可执行的恢复提示。
+*/
+function formatWechatIdeAutomatorFailure(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	if (/需要重新登录|need\s+re-?login|code\s*[:=]\s*10/i.test(message)) return "登录状态失效，请先登录微信开发者工具。";
+	if (/service port|http port|ECONNREFUSED|listen EPERM|EACCES/i.test(message)) return "服务端口不可用，请在设置 -> 安全设置中开启服务端口。";
+	if (/protocol method|protocol timeout|automator.*timeout|Wait timed out|websocket|ws:\/\//i.test(message)) return "自动化 websocket 或协议尚未就绪，已保留普通 CLI 打开的项目。";
+	if (/cliPath|not found|spawn/i.test(message)) return "微信开发者工具 CLI 路径不可用，请执行 `wv ide doctor` 检查配置。";
+	return "当前 DevTools 自动化能力不可用，已保留普通 CLI 打开的项目。";
+}
+/**
+* @description 输出微信开发者工具打开后的自助恢复步骤。
+*/
+function logWechatIdeRecoveryHint(options) {
+	const lines = [
+		`微信开发者工具打开后状态可能不稳定：${options.reason}`,
+		"可按下面顺序恢复：",
+		"1. 在微信开发者工具中确认：设置 -> 安全设置 -> 服务端口已开启。",
+		"2. 仅当项目索引刷新失败时，默认会自动关闭并重开一次当前目标项目；如需跳过，传入 `--no-open-recovery` 或设置 `WEAPP_VITE_DISABLE_IDE_OPEN_RECOVERY=1`。",
+		"3. 如果仍然回到项目选择页，手动导入 project.config.json 所在目录，并关闭多余的微信开发者工具窗口后重试。",
+		"4. 需要查看底层错误时，设置 `WEAPP_VITE_DEBUG_AUTOMATOR_OPEN=1` 后重试。"
+	];
+	if (options.projectPath) lines.push(`当前目标项目目录：${options.projectPath}`);
+	logger_default.warn(lines.join("\n"));
+}
+/**
+* @description 输出服务端口关闭时的定向恢复提示。
+*/
+function logWechatIdeServicePortDisabledHint(projectPath) {
+	const lines = [
+		"检测到微信开发者工具服务端口当前处于关闭状态，已保留用户设置并回退到普通 open 流程。",
+		"自动刷新、截图、MCP 和 IDE 联动能力需要服务端口。",
+		"请在微信开发者工具中打开：设置 -> 安全设置 -> 服务端口，然后重新执行当前 dev/open 命令。"
+	];
+	if (projectPath) lines.push(`当前目标项目目录：${projectPath}`);
+	logger_default.warn(lines.join("\n"));
+}
+// src/cli/openIde/reuse.ts
+const OPENED_PROJECT_HEALTH_CHECK_TIMEOUT = 3e3;
+const OPEN_AUTOMATOR_TIMEOUT = 12e4;
+function formatReuseOpenedWechatIdePrompt() {
+	return `目标项目已在微信开发者工具中打开，已跳过重复打开。按 ${RETRY_CONFIRM_KEYS.map((key) => colors.bold(colors.green(key))).join(" / ")} 重新连接目标项目（保留现有窗口）。`;
+}
+async function disconnectMiniProgram(miniProgram) {
+	await miniProgram.disconnect();
+}
+function withTimeout(task, timeoutMs) {
+	let timer;
+	const timeout = new Promise((_, reject) => {
+		timer = setTimeout(() => {
+			reject(/* @__PURE__ */ new Error(`opened automator health check timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+	});
+	return Promise.race([task, timeout]).finally(() => {
+		if (timer) clearTimeout(timer);
+	});
+}
+async function verifyOpenedProjectHealth(miniProgram) {
+	if (typeof miniProgram.screenshot !== "function") return;
+	await withTimeout(miniProgram.screenshot({ timeout: OPENED_PROJECT_HEALTH_CHECK_TIMEOUT }), OPENED_PROJECT_HEALTH_CHECK_TIMEOUT);
+}
+async function openWechatIdeByAutomator(projectPath, options = {}) {
+	await disconnectMiniProgram(await launchAutomator({
+		persistAsDefaultSession: true,
+		preserveProjectRoot: options.preserveProjectRoot ?? true,
+		projectPath,
+		port: resolveProjectAutomatorPort(projectPath),
+		timeout: OPEN_AUTOMATOR_TIMEOUT,
+		trustProject: options.trustProject !== false
+	}));
+}
+async function connectOpenedProject(projectPath) {
+	let miniProgram;
+	try {
+		miniProgram = await connectOpenedAutomator({
+			projectPath,
+			port: resolveProjectAutomatorPort(projectPath),
+			timeout: 3e3
+		});
+	} catch {
+		return { status: "not-connected" };
+	}
+	try {
+		await verifyOpenedProjectHealth(miniProgram);
+		return {
+			status: "connected",
+			miniProgram
+		};
+	} catch {
+		await disconnectMiniProgram(miniProgram);
+		return { status: "unhealthy" };
+	}
+}
+/**
+* @description 若当前项目已在微信开发者工具中打开且自动化可连通，则直接复用现有会话，避免重复拉起 IDE。
+*/
+async function tryReuseOpenedWechatIde(projectPath, options = {}) {
+	const connection = await connectOpenedProject(projectPath);
+	if (connection.status === "unhealthy") return {
+		reopened: false,
+		reused: false,
+		unhealthy: true
+	};
+	if (connection.status === "not-connected") return null;
+	const { miniProgram } = connection;
+	await disconnectMiniProgram(miniProgram);
+	if (options.promptReopen === false) {
+		logger_default.info("目标项目已在微信开发者工具中打开，已跳过重复打开。");
+		return {
+			reopened: false,
+			reused: true
+		};
+	}
+	logger_default.info(formatReuseOpenedWechatIdePrompt());
+	if (await promptRetryKeypress({ logger: logger_default }) !== "retry") return {
+		reopened: false,
+		reused: true
+	};
+	logger_default.info(colors.bold(colors.green("正在重新连接目标项目，保留现有微信开发者工具窗口...")));
+	await openWechatIdeByAutomator(projectPath, {
+		preserveProjectRoot: options.preserveProjectRoot,
+		trustProject: options.trustProject
+	});
+	return {
+		reopened: true,
+		reused: false
+	};
+}
+/**
+* @description 重新连接目标项目以刷新构建产物；连接失败不授予关闭共享宿主的权限。
+*/
+async function reopenOpenedWechatIde(projectPath, options = {}) {
+	const connection = await connectOpenedProject(projectPath);
+	if (connection.status === "connected") {
+		await disconnectMiniProgram(connection.miniProgram);
+		logger_default.info("目标项目已在微信开发者工具中打开，当前命令将重新连接以刷新最新构建产物，保留现有窗口。");
+	} else if (connection.status === "unhealthy") logger_default.info("目标项目的 automator 会话未通过健康检查，将重试连接目标项目，保留现有窗口。");
+	else logger_default.info("未检测到可复用的 automator 会话，将尝试打开目标项目，保留其他窗口。");
+	await openWechatIdeByAutomator(projectPath, options);
+	return true;
+}
+// src/cli/openIde/index.ts
+function shouldLogAutomatorFallbackError() {
+	const flag = process.env.WEAPP_VITE_DEBUG_AUTOMATOR_OPEN;
+	return flag === "1" || flag === "true";
+}
+const PREPARE_AUTOMATOR_SESSION_TIMEOUT = 8e3;
+const RESET_FILEUTILS_ENV = "WEAPP_VITE_RESET_IDE_FILEUTILS";
+function readProjectConfigObject(projectPath) {
+	try {
+		const raw = fs.readFileSync(path.join(projectPath, "project.config.json"), "utf8");
+		const value = JSON.parse(raw);
+		return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+	} catch {
+		return;
+	}
+}
+function shouldUseAutomatorProjectWrapper(projectPath) {
+	const projectConfig = readProjectConfigObject(projectPath);
+	return projectConfig?.compileType === "plugin" && typeof projectConfig.miniprogramRoot === "string" && projectConfig.miniprogramRoot.trim().length > 0;
+}
+function isWechatIdeOpenRecoveryDisabled(options) {
+	if (options.openRecovery === false) return true;
+	const flag = process.env.WEAPP_VITE_DISABLE_IDE_OPEN_RECOVERY;
+	return flag === "1" || flag === "true";
+}
+function shouldResetWechatIdeFileUtils() {
+	const flag = process.env[RESET_FILEUTILS_ENV];
+	return flag === "1" || flag === "true";
+}
+/**
+* @description 执行 IDE 打开流程，并在登录失效时允许按键重试。
+*/
+async function runWechatIdeOpenWithRetry(argv) {
+	await executeWechatIdeCliCommand(argv, {
+		cancelLevel: "warn",
+		onNonLoginError: (error) => {
+			logger_default.error(error);
+			if (process.env.WEAPP_IDE_MANAGED_PROJECT_JOURNAL?.trim()) throw error;
+		},
+		onRetry: () => {
+			logger_default.info(colors.bold(colors.green("正在重试连接微信开发者工具...")));
+		},
+		promptOpenIdeLogin: true
+	});
+}
+/**
+* @description 根据代码输出目录推导 IDE 项目目录；内联项目配置与 app.json 同目录。
+*/
+function resolveIdeProjectPath(mpDistRoot, generatedProjectConfig = false) {
+	if (!mpDistRoot || !mpDistRoot.trim()) return;
+	if (generatedProjectConfig) return mpDistRoot;
+	const parent = path.dirname(mpDistRoot);
+	if (!parent || parent === "." || parent === "/") return;
+	return parent;
+}
+/**
+* @description 结合 mpDistRoot 与配置根目录解析最终 IDE 项目目录。
+*/
+function resolveIdeProjectRoot(mpDistRoot, cwd, generatedProjectConfig = false) {
+	const projectPath = resolveIdeProjectPath(mpDistRoot, generatedProjectConfig);
+	return generatedProjectConfig && projectPath && cwd ? path.resolve(cwd, projectPath) : projectPath ?? cwd;
+}
+async function closeIde() {
+	return await closeIde$1();
+}
+async function tryOpenWechatIdeByAutomator(projectPath, options) {
+	const preserveProjectRoot = !shouldUseAutomatorProjectWrapper(projectPath);
+	if (options.reuseOpenedProject === false) {
+		if (await reopenOpenedWechatIde(projectPath, {
+			preserveProjectRoot,
+			trustProject: options.trustProject
+		})) return "reopened";
+	}
+	const reuseResult = await tryReuseOpenedWechatIde(projectPath, {
+		preserveProjectRoot,
+		promptReopen: options.reuseOpenedProject !== true,
+		trustProject: options.trustProject
+	});
+	if (reuseResult?.reused) return "reused";
+	if (reuseResult?.reopened) return "reopened";
+	if (reuseResult?.unhealthy) return "unhealthy";
+	await openWechatIdeByAutomator(projectPath, {
+		preserveProjectRoot,
+		trustProject: options.trustProject
+	});
+	return "opened";
+}
+/**
+* @description 打开后主动刷新微信开发者工具的项目索引，避免模拟器沿用过期 app 配置。
+*/
+function appendLoginRetryArgv(argv, options) {
+	if (options.nonInteractive) argv.push("--non-interactive");
+	if (options.loginRetry) argv.push("--login-retry", options.loginRetry);
+	if (options.loginRetryTimeout) argv.push("--login-retry-timeout", options.loginRetryTimeout);
+	return argv;
+}
+function createIdeOpenArgv(platform, projectPath, options = {}) {
+	const argv = ["open", "-p"];
+	if (projectPath) argv.push(projectPath);
+	if (platform === "weapp" && options.trustProject !== false) argv.push("--trust-project");
+	if (platform && shouldPassPlatformArgToIdeOpen(platform)) argv.push("--platform", platform);
+	if (options.nonInteractive) argv.push("--non-interactive");
+	if (options.loginRetry) argv.push("--login-retry", options.loginRetry);
+	if (options.loginRetryTimeout) argv.push("--login-retry-timeout", options.loginRetryTimeout);
+	return argv;
+}
+async function prepareOpenedWechatIdeAutomatorSession(projectPath, options) {
+	const preserveProjectRoot = !shouldUseAutomatorProjectWrapper(projectPath);
+	try {
+		(await launchAutomator({
+			persistAsDefaultSession: true,
+			preserveProjectRoot,
+			projectPath,
+			port: resolveProjectAutomatorPort(projectPath),
+			timeout: PREPARE_AUTOMATOR_SESSION_TIMEOUT,
+			trustProject: options.trustProject !== false
+		})).disconnect?.();
+		return { ok: true };
+	} catch (error) {
+		logger_default.warn("准备当前项目的微信开发者工具自动化会话失败，截图、MCP 或 IDE 联动命令首次运行时将重新连接。");
+		logWechatIdeRecoveryHint({
+			projectPath,
+			reason: "无法建立当前项目的自动化会话，常见原因是 DevTools 服务端口未就绪、窗口停留在项目选择页，或存在残留 DevTools 会话。"
+		});
+		if (shouldLogAutomatorFallbackError()) logger_default.error(error);
+		return {
+			ok: false,
+			reason: "automator-session-failed",
+			error
+		};
+	}
+}
+async function connectOpenedWechatIdeAutomatorSession(projectPath) {
+	try {
+		(await connectOpenedAutomator({
+			projectPath,
+			port: resolveProjectAutomatorPort(projectPath),
+			timeout: PREPARE_AUTOMATOR_SESSION_TIMEOUT
+		})).disconnect?.();
+		return { ok: true };
+	} catch (error) {
+		logger_default.warn("连接当前项目的微信开发者工具自动化会话失败，截图、MCP 或 IDE 联动命令首次运行时将重新连接。");
+		logWechatIdeRecoveryHint({
+			projectPath,
+			reason: "当前项目已完成打开流程，但尚未连接到可复用的自动化会话。"
+		});
+		if (shouldLogAutomatorFallbackError()) logger_default.error(error);
+		return {
+			ok: false,
+			reason: "automator-session-failed",
+			error
+		};
+	}
+}
+async function prepareWechatIdeAutomatorSession(projectPath, options) {
+	if (options.prepareAutomatorSession === "connect-opened") return await connectOpenedWechatIdeAutomatorSession(projectPath);
+	return await prepareOpenedWechatIdeAutomatorSession(projectPath, options);
+}
+async function stabilizeOpenedWechatIdeProject(projectPath, servicePortEnabled, options = {}) {
+	if (servicePortEnabled === false) return {
+		ok: false,
+		reason: "service-port-disabled"
+	};
+	try {
+		if (shouldResetWechatIdeFileUtils()) await executeWechatIdeCliCommand(appendLoginRetryArgv([
+			"reset-fileutils",
+			"-p",
+			projectPath
+		], options), {
+			automatorMode: options.useAutomatorOpen === false ? "skip" : "prefer",
+			httpMode: "require",
+			onNonLoginError: (error) => logger_default.error(error),
+			preserveProjectRoot: options.useAutomatorOpen === false,
+			projectPath
+		});
+		try {
+			await executeWechatIdeCliCommand(appendLoginRetryArgv([
+				"engine",
+				"build",
+				projectPath
+			], options), {
+				automatorMode: options.useAutomatorOpen === false ? "skip" : "prefer",
+				engineBuildFallbackToCli: true,
+				httpMode: "prefer",
+				onNonLoginError: (error) => logger_default.error(error),
+				preserveProjectRoot: options.useAutomatorOpen === false,
+				projectPath
+			});
+		} catch (error) {
+			if (!isWechatIdeEngineBuildEndpointMissingError(error)) throw error;
+			logger_default.warn("当前微信开发者工具不支持自动 engine build 刷新，已跳过该步骤；如模拟器显示旧状态，可在开发者工具内手动编译。");
+		}
+		if (options.useAutomatorOpen !== false && options.skipAutomatorCompile !== true) try {
+			await executeWechatIdeCliCommand(appendLoginRetryArgv(["compile"], options), {
+				automatorMode: "require",
+				httpMode: "skip",
+				preserveProjectRoot: !shouldUseAutomatorProjectWrapper(projectPath),
+				projectPath
+			});
+		} catch (error) {
+			if (shouldLogAutomatorFallbackError()) logger_default.error(error);
+		}
+		return { ok: true };
+	} catch (error) {
+		if (isWechatIdeLoginRequiredExitError(error)) throw error;
+		logger_default.warn("刷新微信开发者工具项目索引失败，已保留当前打开状态；如模拟器仍显示旧状态，可手动刷新一次。");
+		logWechatIdeRecoveryHint({
+			projectPath,
+			reason: "打开项目后的文件索引刷新失败，DevTools 可能仍在使用旧项目状态或内部服务未就绪。"
+		});
+		if (shouldLogAutomatorFallbackError()) logger_default.error(error);
+		return {
+			ok: false,
+			reason: "index-refresh-failed",
+			error
+		};
+	}
+}
+async function verifyOpenedWechatIdeProject(projectPath, servicePortEnabled, options) {
+	const stabilizeResult = await stabilizeOpenedWechatIdeProject(projectPath, servicePortEnabled, options);
+	if (!stabilizeResult.ok) return stabilizeResult;
+	if (options.useAutomatorOpen === false && servicePortEnabled !== false) return await connectOpenedWechatIdeAutomatorSession(projectPath);
+	return stabilizeResult;
+}
+function formatWechatIdeOpenHealthReason(result) {
+	if (result.reason === "index-refresh-failed") return "项目索引刷新失败";
+	return "服务端口未开启";
+}
+async function recoverOpenedWechatIdeProject(platform, projectPath, servicePortEnabled, options, failedResult) {
+	if (failedResult.reason === "service-port-disabled") return failedResult;
+	if (failedResult.reason === "automator-session-failed") {
+		logger_default.warn("已跳过微信开发者工具自动恢复；自动化会话预热失败不影响当前项目打开，截图、MCP 或 IDE 联动命令首次运行时会重新连接。");
+		return failedResult;
+	}
+	if (isWechatIdeOpenRecoveryDisabled(options)) {
+		logger_default.warn("已跳过微信开发者工具自动恢复；请按上方提示手动关闭并重新打开目标项目。");
+		return failedResult;
+	}
+	logger_default.info(`检测到微信开发者工具打开后状态不稳定（${formatWechatIdeOpenHealthReason(failedResult)}），正在重试打开目标项目（保留现有窗口）...`);
+	await runWechatIdeOpenWithRetry(createIdeOpenArgv(platform, projectPath, options));
+	const recoveredResult = await verifyOpenedWechatIdeProject(projectPath, servicePortEnabled, options);
+	if (recoveredResult.ok) logger_default.info("微信开发者工具已完成自动恢复。");
+	else logger_default.warn("微信开发者工具自动恢复未完成；可设置 `WEAPP_VITE_DISABLE_IDE_OPEN_RECOVERY=1` 或传入 `--no-open-recovery` 跳过自动重试，并按提示手动处理。");
+	return recoveredResult;
+}
+async function verifyAndRecoverOpenedWechatIdeProject(platform, projectPath, servicePortEnabled, options) {
+	const healthResult = await verifyOpenedWechatIdeProject(projectPath, servicePortEnabled, options);
+	if (!healthResult.ok) await recoverOpenedWechatIdeProject(platform, projectPath, servicePortEnabled, options, healthResult);
+}
+async function openSelectedIde(platform, projectPath, options = {}) {
+	let bootstrapResult;
+	const openStrategy = options.openStrategy ?? (options.useAutomatorOpen === true ? "automator" : "cli");
+	const useAutomatorOpen = openStrategy === "automator";
+	const normalizedOptions = {
+		...options,
+		openStrategy,
+		useAutomatorOpen
+	};
+	if (platform === "weapp" && projectPath) try {
+		bootstrapResult = await bootstrapWechatDevtoolsSettings({
+			projectPath,
+			trustProject: normalizedOptions.trustProject
+		});
+	} catch (error) {
+		logger_default.warn("检测微信开发者工具服务端口或写入项目信任状态失败，继续执行 open 流程。");
+		logger_default.error(error);
+	}
+	if (platform === "weapp" && projectPath && bootstrapResult?.servicePortEnabled === false) logWechatIdeServicePortDisabledHint(projectPath);
+	if (platform === "weapp" && projectPath && bootstrapResult?.servicePortEnabled !== false && useAutomatorOpen) try {
+		const openResult = await tryOpenWechatIdeByAutomator(projectPath, normalizedOptions);
+		if (openResult === "reused") return;
+		if (openResult === "unhealthy") {
+			logger_default.warn("已连接到目标微信开发者工具项目，但协议健康检查暂未就绪；已保留当前窗口并跳过重复启动。");
+			return;
+		} else if (openResult) {
+			if (!normalizedOptions.skipPostOpenHealthCheck) await verifyAndRecoverOpenedWechatIdeProject(platform, projectPath, bootstrapResult?.servicePortEnabled, normalizedOptions);
+			return;
+		}
+	} catch (error) {
+		if (process.env.WEAPP_IDE_MANAGED_PROJECT_JOURNAL?.trim()) throw error;
+		if (isAutomatorLoginError(error)) {
+			logger_default.error("检测到微信开发者工具登录状态失效，请先登录后重试。");
+			logger_default.warn(formatAutomatorLoginError(error));
+		}
+		logger_default.warn(`通过 automator 启动微信开发者工具失败，回退到普通 open 流程：${formatWechatIdeAutomatorFailure(error)}`);
+		if (shouldLogAutomatorFallbackError()) logger_default.error(error);
+	}
+	await runWechatIdeOpenWithRetry(createIdeOpenArgv(platform, projectPath, normalizedOptions));
+	if (platform === "weapp" && projectPath && normalizedOptions.prepareAutomatorSession) await prepareWechatIdeAutomatorSession(projectPath, normalizedOptions);
+	if (platform === "weapp" && projectPath && !normalizedOptions.skipPostOpenHealthCheck) await verifyAndRecoverOpenedWechatIdeProject(platform, projectPath, bootstrapResult?.servicePortEnabled, normalizedOptions);
+}
+/**
+* @description 解析 IDE 相关命令所需的平台、项目目录与配置上下文。
+*/
+async function resolveIdeCommandContext(options) {
+	const cwd = options.cwd ?? process.cwd();
+	let platform = options.platform;
+	let projectPath = options.projectPath;
+	if (!platform || !projectPath) try {
+		const targets = resolveRuntimeTargets({ platform });
+		const ctx = await createCompilerContext({
+			cwd,
+			mode: options.mode ?? "development",
+			configFile: options.configFile,
+			inlineConfig: createInlineConfig(targets),
+			cliPlatform: options.cliPlatform
+		});
+		platform ??= ctx.configService.platform;
+		if (!projectPath) projectPath = resolveIdeProjectRoot(ctx.configService.mpDistRoot, ctx.configService.cwd, ctx.configService.multiPlatform.projectConfigs !== void 0);
+		return {
+			cwd: ctx.configService.cwd,
+			platform,
+			projectPath,
+			weappViteConfig: ctx.configService.weappViteConfig,
+			mpDistRoot: ctx.configService.mpDistRoot
+		};
+	} catch {}
+	if (!projectPath) {
+		const defaultProjectRoot = getDefaultIdeProjectRoot(platform);
+		if (defaultProjectRoot) projectPath = resolveIdeProjectRoot(defaultProjectRoot, cwd);
+	}
+	return {
+		cwd,
+		platform,
+		projectPath
+	};
+}
+/** 打开项目、健康检查与恢复共用同一安装身份。 */
+async function openIde(platform, projectPath, options = {}) {
+	if (platform === "weapp") return await withWechatDevtoolsSelection(options, () => openSelectedIde(platform, projectPath, options));
+	return await openSelectedIde(platform, projectPath, options);
+}
+export { resolveIdeProjectRoot as a, resolveIdeProjectPath as i, openIde as n, shouldUseAutomatorProjectWrapper as o, resolveIdeCommandContext as r, executeWechatIdeCliCommand as s, closeIde as t };

package/dist/options-Cz8vZ-0w.mjs

@@ -0,0 +1,33 @@
+// 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);
+}
+export { parseDashboardUiHost as a, isUiEnabled as i, convertBase as n, resolveConfigFile as o, filterDuplicateOptions as r, coerceBooleanOption as t };