weapp-ide-cli 6.1.9 → 6.3.0

package/dist/automator-BOe32upt.js

@@ -0,0 +1,822 @@
+import { a as readPersistedAutomatorSession, i as persistAutomatorSession, j as colors, m as assertWechatDevtoolsPort, p as assertWechatDevtoolsHost, r as resolveAutomatorProjectPath, u as resolveWechatDevtoolsTarget, z as readCustomConfig } from "./automatorProject-DjYLqMj6.js";
+import path from "node:path";
+import { withMachineE2ELease } from "@weapp-vite/devtools-runtime";
+import fs from "node:fs/promises";
+import process from "node:process";
+import { createHash } from "node:crypto";
+import { OperationLifecycle } from "@weapp-vite/miniprogram-automator/operation";
+import { emitKeypressEvents } from "node:readline";
+//#region src/cli/automator/port.ts
+/** 显式端口不能被截断或作为默认值忽略，避免连接其他项目。 */
+function assertAutomatorPort(port) {
+	if (port !== void 0 && (typeof port !== "number" || !Number.isInteger(port) || port < 1 || port > 65535)) throw Object.assign(/* @__PURE__ */ new RangeError("Automator port must be an integer between 1 and 65535."), { code: "DEVTOOLS_INVALID_PORT" });
+}
+/** CLI 只接受完整十进制数字，缺失值、尾随字符和指数写法均报错。 */
+function parseAutomatorPort(raw) {
+	const port = raw !== void 0 && /^\d+$/.test(raw) ? Number(raw) : NaN;
+	assertAutomatorPort(port);
+	return port;
+}
+//#endregion
+//#region src/cli/automator/context.ts
+/** 在连接与共享缓存入口固定安装选择；headless 不读取或修改 IDE 状态。 */
+async function resolveAutomatorSessionOptions(options) {
+	assertAutomatorPort(options.port);
+	options.signal?.throwIfAborted();
+	const runtimeProvider = options.runtimeProvider ?? process.env.WEAPP_VITE_AUTOMATOR_RUNTIME_PROVIDER ?? process.env.WEAPP_VITE_E2E_RUNTIME_PROVIDER;
+	if (runtimeProvider === "headless") return {
+		...options,
+		runtimeProvider,
+		installationId: "headless"
+	};
+	const target = await resolveWechatDevtoolsTarget(options);
+	options.signal?.throwIfAborted();
+	if (options.installationId && options.installationId !== target.installationId) throw Object.assign(/* @__PURE__ */ new Error("DEVTOOLS_INSTALLATION_MISMATCH: resolved installation does not match the selected session."), { code: "DEVTOOLS_INSTALLATION_MISMATCH" });
+	return {
+		...options,
+		target,
+		cliPath: target.cliPath,
+		installationId: target.installationId
+	};
+}
+//#endregion
+//#region src/i18n.ts
+let currentLocale = "zh";
+/**
+* @description 设置当前语言。
+*/
+function setLocale(locale) {
+	currentLocale = normalizeLocale(locale);
+}
+/**
+* @description 从 argv 和环境变量中解析语言并设置。
+*/
+function configureLocaleFromArgv(argv, fallbackLocale) {
+	const localeFromArgv = readLangOption(argv);
+	if (localeFromArgv) {
+		setLocale(localeFromArgv);
+		return currentLocale;
+	}
+	if (fallbackLocale) {
+		setLocale(fallbackLocale);
+		return currentLocale;
+	}
+	const localeFromEnv = process.env.WEAPP_IDE_CLI_LANG || process.env.LANG;
+	if (localeFromEnv) {
+		setLocale(localeFromEnv);
+		return currentLocale;
+	}
+	setLocale("zh");
+	return currentLocale;
+}
+/**
+* @description 根据当前语言选择文案。
+*/
+function i18nText(zh, en) {
+	return currentLocale === "en" ? en : zh;
+}
+/**
+* @description 校验 --lang 参数是否合法。
+*/
+function validateLocaleOption(argv) {
+	const localeFromArgv = readLangOption(argv);
+	if (!localeFromArgv) return;
+	if (!isLocaleTokenSupported(localeFromArgv)) throw new Error(`不支持的语言: ${localeFromArgv}，仅支持 zh 或 en`);
+}
+function normalizeLocale(raw) {
+	if (!raw) return "zh";
+	const normalized = raw.trim().toLowerCase();
+	if (normalized === "en" || normalized.startsWith("en_") || normalized.startsWith("en-")) return "en";
+	return "zh";
+}
+function isLocaleTokenSupported(raw) {
+	const normalized = raw.trim().toLowerCase();
+	return normalized === "zh" || normalized === "en" || normalized.startsWith("zh_") || normalized.startsWith("zh-") || normalized.startsWith("en_") || normalized.startsWith("en-");
+}
+function readLangOption(argv) {
+	for (let index = 0; index < argv.length; index += 1) {
+		const token = argv[index];
+		if (!token) continue;
+		if (token === "--lang") {
+			const value = argv[index + 1];
+			return typeof value === "string" ? value : void 0;
+		}
+		if (token.startsWith("--lang=")) return token.slice(7);
+	}
+}
+//#endregion
+//#region src/cli/inputCoordinator.ts
+const sharedSessions = /* @__PURE__ */ new Set();
+const exclusiveKeypressStack = [];
+const EXCLUSIVE_KEYPRESS_CARRYOVER_GUARD_MS = 500;
+let initialized = false;
+let rawModeEnabled = false;
+let dataListenerAttached = false;
+let keypressListenerAttached = false;
+let lastExclusiveResolvedKeypress;
+function hasInteractiveStdin() {
+	return Boolean(process.stdin?.isTTY);
+}
+function canSetRawMode() {
+	return typeof process.stdin?.setRawMode === "function";
+}
+function updateTerminalState() {
+	const shouldKeepInputActive = Array.from(sharedSessions).some((session) => !session.closed && !session.suspended) || exclusiveKeypressStack.length > 0;
+	if (canSetRawMode() && rawModeEnabled !== shouldKeepInputActive) {
+		process.stdin.setRawMode(shouldKeepInputActive);
+		rawModeEnabled = shouldKeepInputActive;
+	}
+	if (shouldKeepInputActive) {
+		process.stdin.resume();
+		return;
+	}
+	process.stdin.pause();
+}
+function handleData(chunk) {
+	if (exclusiveKeypressStack.length > 0) return;
+	for (const session of sharedSessions) {
+		if (session.closed || session.suspended || !session.options.onData) continue;
+		session.options.onData(chunk);
+	}
+}
+function handleKeypress(str, key) {
+	const activeExclusive = exclusiveKeypressStack[exclusiveKeypressStack.length - 1];
+	if (activeExclusive) {
+		const now = Date.now();
+		const signature = `${key?.ctrl ? "ctrl+" : ""}${key?.name ?? str}`;
+		if (lastExclusiveResolvedKeypress && lastExclusiveResolvedKeypress.signature === signature && now - lastExclusiveResolvedKeypress.timestamp <= EXCLUSIVE_KEYPRESS_CARRYOVER_GUARD_MS) {
+			lastExclusiveResolvedKeypress.timestamp = now;
+			return;
+		}
+		if (now < activeExclusive.ignoreUntil) return;
+		const nextValue = activeExclusive.onKeypress(str, key);
+		if (nextValue !== void 0) {
+			clearTimeout(activeExclusive.timeout);
+			exclusiveKeypressStack.pop();
+			lastExclusiveResolvedKeypress = {
+				signature,
+				timestamp: now
+			};
+			updateTerminalState();
+			activeExclusive.resolve(nextValue);
+		}
+		return;
+	}
+	for (const session of sharedSessions) {
+		if (session.closed || session.suspended || !session.options.onKeypress) continue;
+		session.options.onKeypress(str, key);
+	}
+}
+function ensureCoordinatorInitialized() {
+	if (initialized || !hasInteractiveStdin()) return;
+	emitKeypressEvents(process.stdin);
+	if (!dataListenerAttached) {
+		process.stdin.on("data", handleData);
+		dataListenerAttached = true;
+	}
+	if (!keypressListenerAttached) {
+		process.stdin.on("keypress", handleKeypress);
+		keypressListenerAttached = true;
+	}
+	initialized = true;
+}
+function createSharedInputSession(options) {
+	if (!hasInteractiveStdin()) return;
+	ensureCoordinatorInitialized();
+	const session = {
+		closed: false,
+		options,
+		suspended: false
+	};
+	sharedSessions.add(session);
+	updateTerminalState();
+	return {
+		close() {
+			if (session.closed) return;
+			session.closed = true;
+			sharedSessions.delete(session);
+			updateTerminalState();
+		},
+		resume() {
+			if (session.closed) return;
+			session.suspended = false;
+			updateTerminalState();
+		},
+		suspend() {
+			if (session.closed) return;
+			session.suspended = true;
+			updateTerminalState();
+		}
+	};
+}
+async function waitForExclusiveKeypress(options) {
+	options.signal?.throwIfAborted();
+	if (!hasInteractiveStdin()) return "timeout";
+	ensureCoordinatorInitialized();
+	return await new Promise((resolve, reject) => {
+		const normalizedTimeoutMs = Number.isFinite(options.timeoutMs) && options.timeoutMs && options.timeoutMs > 0 ? options.timeoutMs : 3e4;
+		const normalizedIgnoreInitialMs = Number.isFinite(options.ignoreInitialMs) && options.ignoreInitialMs && options.ignoreInitialMs > 0 ? options.ignoreInitialMs : 0;
+		let onAbort;
+		const record = {
+			ignoreUntil: Date.now() + normalizedIgnoreInitialMs,
+			onKeypress: options.onKeypress,
+			resolve: (value) => {
+				options.signal?.removeEventListener("abort", onAbort);
+				resolve(value);
+			},
+			timeout: setTimeout(() => {
+				const index = exclusiveKeypressStack.lastIndexOf(record);
+				if (index >= 0) exclusiveKeypressStack.splice(index, 1);
+				updateTerminalState();
+				record.resolve("timeout");
+			}, normalizedTimeoutMs)
+		};
+		onAbort = () => {
+			clearTimeout(record.timeout);
+			options.signal?.removeEventListener("abort", onAbort);
+			const index = exclusiveKeypressStack.indexOf(record);
+			if (index >= 0) exclusiveKeypressStack.splice(index, 1);
+			updateTerminalState();
+			reject(options.signal?.reason);
+		};
+		options.signal?.addEventListener("abort", onAbort, { once: true });
+		exclusiveKeypressStack.push(record);
+		updateTerminalState();
+	});
+}
+async function runWithSuspendedSharedInput(runner) {
+	const previousStates = /* @__PURE__ */ new Map();
+	for (const session of sharedSessions) {
+		if (session.closed) continue;
+		previousStates.set(session, session.suspended);
+		session.suspended = true;
+	}
+	if (canSetRawMode() && rawModeEnabled) {
+		process.stdin.setRawMode(false);
+		rawModeEnabled = false;
+	}
+	process.stdin.resume();
+	try {
+		return await runner();
+	} finally {
+		for (const [session, suspended] of previousStates) if (!session.closed) session.suspended = suspended;
+		updateTerminalState();
+	}
+}
+//#endregion
+//#region src/cli/retry.ts
+const RETRY_PROMPT_INITIAL_IGNORE_MS = 300;
+const RETRY_CONFIRM_KEYS = ["y"];
+const RETRY_CANCEL_KEYS = [
+	"q",
+	"Esc",
+	"Ctrl+C"
+];
+const LOGIN_REQUIRED_PATTERNS = [
+	/code(?:\s*[:=]\s*|\s+)13\b/i,
+	/需要重新登录/,
+	/need\s+re-?login/i,
+	/re-?login/i,
+	/\blogin(?:\s+again)?\s+(?:is\s+)?required\b/i
+];
+/**
+* @description 提取执行错误文本，便于统一匹配与提示。
+*/
+function extractExecutionErrorText(error) {
+	if (!error || typeof error !== "object") return "";
+	const parts = [];
+	const candidate = error;
+	for (const field of [
+		candidate.message,
+		candidate.shortMessage,
+		candidate.stderr,
+		candidate.stdout
+	]) if (typeof field === "string" && field.trim()) parts.push(field);
+	return parts.join("\n");
+}
+function extractLoginRequiredMessage$1(text) {
+	if (!text) return "";
+	if (/需要重新登录/.test(text)) return "需要重新登录";
+	const englishMatch = text.match(/need\s+re-?login|re-?login/i);
+	if (englishMatch?.[0]) return englishMatch[0].toLowerCase();
+	const firstLine = text.split(/\r?\n/).map((line) => line.trim()).find((line) => Boolean(line) && !line.startsWith("at "));
+	if (!firstLine) return "";
+	return firstLine.replace(/^\[error\]\s*/i, "").replace(/^error\s*:\s*/i, "").slice(0, 120);
+}
+/**
+* @description 判断是否为微信开发者工具登录失效错误。
+*/
+function isWechatIdeLoginRequiredError(error) {
+	const text = extractExecutionErrorText(error);
+	if (!text) return false;
+	return LOGIN_REQUIRED_PATTERNS.some((pattern) => pattern.test(text));
+}
+/**
+* @description 将登录失效错误格式化为更易读的摘要。
+*/
+function formatWechatIdeLoginRequiredError(error) {
+	const text = extractExecutionErrorText(error);
+	const code = text.match(/code\s*[:=]\s*(\d+)/i)?.[1];
+	const message = extractLoginRequiredMessage$1(text);
+	const lines = ["微信开发者工具返回登录错误："];
+	if (code) lines.push(`- code: ${code}`);
+	if (message) lines.push(`- message: ${message}`);
+	if (!code && !message) lines.push("- message: 需要重新登录");
+	return lines.join("\n");
+}
+/**
+* @description 创建登录失效专用错误，并携带退出码语义。
+*/
+function createWechatIdeLoginRequiredExitError(error, reason) {
+	const summary = formatWechatIdeLoginRequiredError(error);
+	const message = reason ? `${reason}\n${summary}` : summary;
+	const loginError = new Error(message, { cause: error });
+	loginError.name = "WechatIdeLoginRequiredError";
+	loginError.code = 10;
+	loginError.exitCode = 10;
+	return loginError;
+}
+/**
+* @description 判断错误是否为登录失效专用退出错误。
+*/
+function isWechatIdeLoginRequiredExitError(error) {
+	if (!error || typeof error !== "object") return false;
+	const candidate = error;
+	return candidate.name === "WechatIdeLoginRequiredError" || (candidate.code === 10 || candidate.exitCode === 10) && isWechatIdeLoginRequiredError(error);
+}
+/**
+* @description 交互等待用户按 y 重试，按 q 或 Ctrl+C 取消。
+*/
+async function waitForRetryKeypress(options = {}) {
+	const { timeoutMs = 3e4 } = options;
+	if (!process.stdin.isTTY) return "cancel";
+	return await waitForExclusiveKeypress({
+		signal: options.signal,
+		ignoreInitialMs: 300,
+		onKeypress: (_str, key) => {
+			if (!key) return;
+			if (key.ctrl && key.name === "c") return "cancel";
+			if (key.name === "y") return "retry";
+			if (key.name === "q" || key.name === "escape") return "cancel";
+		},
+		timeoutMs
+	});
+}
+function highlightHotkey(key) {
+	return colors.bold(colors.green(key));
+}
+/**
+* @description 生成重试按键提示，并高亮关键热键。
+*/
+function formatRetryHotkeyPrompt(timeoutMs = 3e4) {
+	const highlight = (key) => highlightHotkey(key);
+	const timeoutSeconds = Math.max(1, Math.ceil(timeoutMs / 1e3));
+	const confirmKeys = RETRY_CONFIRM_KEYS.map(highlight).join(" / ");
+	const cancelKeys = RETRY_CANCEL_KEYS.map(highlight).join(" / ");
+	return i18nText(`按 ${confirmKeys} 重试，按 ${cancelKeys} 退出（${timeoutSeconds}s 内无输入将自动失败）。`, `Press ${confirmKeys} to retry, ${cancelKeys} to cancel (auto fail in ${timeoutSeconds}s).`);
+}
+/**
+* @description 输出重试热键提示，并独占等待当前提示对应的按键输入。
+*/
+async function promptRetryKeypress(options) {
+	const { logger, timeoutMs = 3e4 } = options;
+	logger.info(formatRetryHotkeyPrompt(timeoutMs));
+	return await waitForRetryKeypress({
+		timeoutMs,
+		signal: options.signal
+	});
+}
+/**
+* @description 统一处理微信开发者工具登录失效场景下的提示与重试交互。
+*/
+async function promptWechatIdeLoginRetry(options) {
+	const { allowRetry = true, cancelLevel = "info", error, logger, promptOpenIdeLogin = false, retryTimeoutMs = 3e4 } = options;
+	logger.error(i18nText("检测到微信开发者工具登录状态失效，请先登录后重试。", "Wechat DevTools login has expired. Please login and retry."));
+	if (promptOpenIdeLogin) logger.warn(i18nText("请先打开微信开发者工具完成登录。", "Please open Wechat DevTools and complete login first."));
+	logger.warn(formatWechatIdeLoginRequiredError(error));
+	if (!allowRetry) return "cancel";
+	const action = await promptRetryKeypress({
+		logger,
+		timeoutMs: retryTimeoutMs,
+		signal: options.signal
+	});
+	if (action === "timeout") {
+		logger.error(i18nText(`等待登录重试输入超时（${retryTimeoutMs}ms），已自动取消。`, `Retry prompt timed out (${retryTimeoutMs}ms), canceled automatically.`));
+		return "cancel";
+	}
+	if (action !== "retry") {
+		logger[cancelLevel](i18nText("已取消重试。完成登录后请重新执行当前命令。", "Retry canceled. Please run the command again after login."));
+		return "cancel";
+	}
+	return "retry";
+}
+//#endregion
+//#region src/cli/automator/errors.ts
+const ERROR_STACK_PREFIX_RE = /^at /;
+const ERROR_PREFIX_RE = /^\[error\]\s*/i;
+const ERROR_LABEL_PREFIX_RE = /^error\s*:\s*/i;
+const ERROR_LINE_SPLIT_RE = /\r?\n/;
+const LOGIN_REQUIRED_CN_RE = /需要重新登录/;
+const LOGIN_REQUIRED_EN_RE = /need\s+re-?login|re-?login/i;
+const LOGIN_REQUIRED_CODE_RE = /code\s*[:=]\s*(\d+)/i;
+const DEVTOOLS_HTTP_PORT_ERROR = "Failed to launch wechat web devTools, please make sure http port is open";
+const DEVTOOLS_EXTENSION_CONTEXT_INVALIDATED_RE = /Extension context invalidated/i;
+const AUTOMATOR_LAUNCH_TIMEOUT_RE = /Wait timed out after \d+ ms/i;
+const AUTOMATOR_WS_CONNECT_RE = /Failed connecting to ws:\/\/127\.0\.0\.1:\d+/i;
+const AUTOMATOR_PORT_IN_USE_RE = /Port \d+ is in use, please specify another port/i;
+const DEVTOOLS_PROTOCOL_TIMEOUT_RE = /DevTools did not respond to protocol method (\S+) within \d+ms/i;
+const DEVTOOLS_INFRA_ERROR_PATTERNS = [
+	/#initialize-error:\s*wait IDE port timeout/i,
+	/wait IDE port timeout/i,
+	/listen EPERM/i,
+	/operation not permitted 0\.0\.0\.0/i,
+	/EACCES/i,
+	/ECONNREFUSED/i,
+	/connect ECONNREFUSED/i
+];
+/**
+* @description 从错误对象中提取可读文本。
+*/
+function extractErrorText(error) {
+	if (!error || typeof error !== "object") return "";
+	const candidate = error;
+	return [
+		candidate.message,
+		candidate.shortMessage,
+		candidate.stderr,
+		candidate.stdout
+	].filter((value) => typeof value === "string" && value.trim().length > 0).join("\n");
+}
+/**
+* @description 提取登录失效时最适合展示给用户的一行信息。
+*/
+function extractLoginRequiredMessage(text) {
+	if (!text) return "";
+	if (LOGIN_REQUIRED_CN_RE.test(text)) return "需要重新登录";
+	const englishMatch = text.match(LOGIN_REQUIRED_EN_RE);
+	if (englishMatch?.[0]) return englishMatch[0].toLowerCase();
+	const firstLine = text.split(ERROR_LINE_SPLIT_RE).map((line) => line.trim()).find((line) => Boolean(line) && !ERROR_STACK_PREFIX_RE.test(line));
+	if (!firstLine) return "";
+	return firstLine.replace(ERROR_PREFIX_RE, "").replace(ERROR_LABEL_PREFIX_RE, "").slice(0, 120);
+}
+/**
+* @description 判断错误是否属于开发者工具服务端口不可用。
+*/
+function isDevtoolsHttpPortError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return message.includes(DEVTOOLS_HTTP_PORT_ERROR) || DEVTOOLS_INFRA_ERROR_PATTERNS.some((pattern) => pattern.test(message));
+}
+/**
+* @description 判断错误是否属于开发者工具 automator 扩展上下文尚未就绪。
+*/
+function isDevtoolsExtensionContextInvalidatedError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return DEVTOOLS_EXTENSION_CONTEXT_INVALIDATED_RE.test(message);
+}
+/**
+* @description 判断错误是否属于可重试的 automator 启动抖动。
+*/
+function isRetryableAutomatorLaunchError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return DEVTOOLS_EXTENSION_CONTEXT_INVALIDATED_RE.test(message) || AUTOMATOR_LAUNCH_TIMEOUT_RE.test(message) || AUTOMATOR_WS_CONNECT_RE.test(message);
+}
+/**
+* @description 判断错误是否属于开发者工具 websocket 连接失败。
+*/
+function isAutomatorWsConnectError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return AUTOMATOR_WS_CONNECT_RE.test(message);
+}
+/**
+* @description 判断错误是否属于目标项目 automator 端口仍被旧会话占用。
+*/
+function isAutomatorPortInUseError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return AUTOMATOR_PORT_IN_USE_RE.test(message);
+}
+/**
+* @description 判断错误是否属于开发者工具协议调用超时。
+*/
+function isAutomatorProtocolTimeoutError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return DEVTOOLS_PROTOCOL_TIMEOUT_RE.test(message);
+}
+/**
+* @description 提取协议超时的方法名。
+*/
+function getAutomatorProtocolTimeoutMethod(error) {
+	return (error instanceof Error ? error.message : String(error)).match(DEVTOOLS_PROTOCOL_TIMEOUT_RE)?.[1];
+}
+/**
+* @description 判断错误是否属于开发者工具登录失效。
+*/
+function isAutomatorLoginError(error) {
+	return isWechatIdeLoginRequiredError(error);
+}
+/**
+* @description 格式化开发者工具登录失效错误，便于终端展示。
+*/
+function formatAutomatorLoginError(error) {
+	const text = extractErrorText(error);
+	const code = text.match(LOGIN_REQUIRED_CODE_RE)?.[1];
+	const message = extractLoginRequiredMessage(text);
+	const lines = ["微信开发者工具返回登录错误："];
+	if (code) lines.push(`- code: ${code}`);
+	if (message) lines.push(`- message: ${message}`);
+	if (!code && !message) lines.push("- message: 需要重新登录");
+	return lines.join("\n");
+}
+//#endregion
+//#region src/cli/wechatDevtoolsSettings.ts
+function createStorageHash(key) {
+	return createHash("md5").update(key).digest("hex");
+}
+const SETTINGS_STORAGE_HASH = createStorageHash("reduxPersist:settings");
+const SETTINGS_STORAGE_FILE_NAMES = [`localstorage_${SETTINGS_STORAGE_HASH}.json`, `ls_${SETTINGS_STORAGE_HASH}.json`];
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizePort(value) {
+	if (typeof value !== "number" || !Number.isInteger(value)) return;
+	if (value <= 0 || value > 65535) return;
+	return value;
+}
+function normalizeWechatDevtoolsSecuritySettings(value) {
+	if (!isRecord(value)) return;
+	const normalized = {};
+	if (typeof value.enableServicePort === "boolean") normalized.enableServicePort = value.enableServicePort;
+	const port = normalizePort(value.port);
+	if (port !== void 0) normalized.port = port;
+	if (typeof value.allowGetTicket === "boolean") normalized.allowGetTicket = value.allowGetTicket;
+	if (typeof value.trustWhenAuto === "boolean") normalized.trustWhenAuto = value.trustWhenAuto;
+	return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+async function resolveSelectedProfile(options) {
+	const platform = options.platform ?? process.platform;
+	if (!options.target && platform !== "darwin" && platform !== "win32") return;
+	return (await resolveWechatDevtoolsTarget(options)).profileDir;
+}
+async function readJsonObject(filePath) {
+	try {
+		const raw = await fs.readFile(filePath, "utf8");
+		const parsed = JSON.parse(raw);
+		if (!isRecord(parsed)) return {};
+		return parsed;
+	} catch (error) {
+		if (error.code === "ENOENT") return {};
+		if (error instanceof SyntaxError) return {};
+		throw error;
+	}
+}
+async function writeJsonObject(filePath, value) {
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
+	await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+async function detectWechatDevtoolsSecuritySettings(localDataDir) {
+	for (const fileName of SETTINGS_STORAGE_FILE_NAMES) {
+		const security = normalizeWechatDevtoolsSecuritySettings((await readJsonObject(path.join(localDataDir, fileName))).security);
+		if (security) return security;
+	}
+}
+async function trustWechatDevtoolsProject(localDataDir, projectPath) {
+	const normalizedProjectPath = path.resolve(projectPath);
+	const projectHash = createStorageHash(`project2_${normalizedProjectPath}`);
+	const fileNames = [`localstorage_${projectHash}.json`, `ls_${projectHash}.json`];
+	let trusted = false;
+	for (const fileName of fileNames) {
+		const projectFilePath = path.join(localDataDir, fileName);
+		const current = await readJsonObject(projectFilePath);
+		if (current.projectid !== normalizedProjectPath || current.projectpath !== normalizedProjectPath || typeof current.appid !== "string" || !current.appid || !isRecord(current.attr) || !isRecord(current.attr.setting)) continue;
+		await writeJsonObject(projectFilePath, {
+			...current,
+			isTrusted: true
+		});
+		trusted = true;
+	}
+	return trusted;
+}
+async function scanWechatDevtoolsServicePort(profileDir) {
+	const localDataDir = profileDir && path.join(profileDir, "WeappLocalData");
+	const exists = localDataDir && await fs.stat(localDataDir).then((stat) => stat.isDirectory(), (error) => {
+		if (error.code !== "ENOENT") throw error;
+		return false;
+	});
+	const security = exists && localDataDir ? await detectWechatDevtoolsSecuritySettings(localDataDir) : void 0;
+	return {
+		touchedInstanceCount: exists ? 1 : 0,
+		detectedSecurityCount: security ? 1 : 0,
+		servicePort: security?.port,
+		servicePortEnabled: security?.enableServicePort
+	};
+}
+/**
+* @description 检测微信开发者工具当前服务端口配置，严格沿用用户已有设置。
+*/
+async function detectWechatDevtoolsServicePort(options = {}) {
+	return await scanWechatDevtoolsServicePort(await resolveSelectedProfile(options));
+}
+/**
+* @description 在启动微信开发者工具前，检测服务端口配置，并按需写入项目信任信息。
+*/
+async function bootstrapWechatDevtoolsSettings(options = {}) {
+	const profileDir = await resolveSelectedProfile(options);
+	const result = await scanWechatDevtoolsServicePort(profileDir);
+	const trusted = profileDir && result.touchedInstanceCount && options.projectPath && options.trustProject === true ? await trustWechatDevtoolsProject(path.join(profileDir, "WeappLocalData"), options.projectPath) : false;
+	return {
+		...result,
+		updatedSecurityCount: 0,
+		trustedProjectCount: trusted ? 1 : 0
+	};
+}
+//#endregion
+//#region src/cli/automator.ts
+const PROJECT_AUTOMATOR_PORT_BASE = 9620;
+const PROJECT_AUTOMATOR_PORT_RANGE = 2e3;
+/**
+* @description 为项目路径派生稳定的 DevTools automator 端口，避免多个 dev:open 项目抢占默认端口。
+*/
+function resolveProjectAutomatorPort(projectPath) {
+	const offset = createHash("sha1").update(path.resolve(projectPath)).digest().readUInt32BE(0) % PROJECT_AUTOMATOR_PORT_RANGE;
+	return PROJECT_AUTOMATOR_PORT_BASE + offset;
+}
+async function launchSelectedAutomator(options) {
+	const { port, projectPath, sessionId, timeout = 3e4 } = options;
+	const lifecycle = new OperationLifecycle(timeout, "IDE launch", options.signal);
+	let managedLaunch;
+	try {
+		return await lifecycle.run(async (scope) => {
+			const { Launcher } = await scope.step(() => import("@weapp-vite/miniprogram-automator"), { stage: "load-automator" });
+			const { target, cliPath: resolvedCliPath, installationId, runtimeProvider } = await scope.step(() => resolveAutomatorSessionOptions(options), { stage: "resolve-cli" });
+			if (runtimeProvider === "headless") return await scope.step(() => new Launcher().launch({
+				projectPath,
+				runtimeProvider,
+				timeout: scope.remainingMs(),
+				signal: scope.signal
+			}), {
+				stage: "launch",
+				disposeLate: (program) => program.disconnect()
+			});
+			await scope.step(() => assertWechatDevtoolsHost(target, {
+				signal: scope.signal,
+				timeout: scope.remainingMs()
+			}), { stage: "host-identity" });
+			const config = await scope.step(() => readCustomConfig(), { stage: "configuration" });
+			const resolvedTrustProject = options.trustProject ?? config.autoTrustProject ?? false;
+			const launcher = new Launcher();
+			let lastError = null;
+			let bootstrapResult;
+			if (process.env["WEAPP_IDE_MANAGED_PROJECT_JOURNAL"]?.trim()) {
+				const { launchManagedAutomator } = await import("./managed-B04Xo9U_.js");
+				managedLaunch = launchManagedAutomator({
+					launcher,
+					scope,
+					target,
+					projectPath: path.resolve(projectPath),
+					sourceProjectPath: projectPath,
+					port: port ?? resolveProjectAutomatorPort(projectPath),
+					sessionId,
+					trustProject: resolvedTrustProject,
+					persistAsDefaultSession: options.persistAsDefaultSession,
+					preserveProjectRoot: options.preserveProjectRoot
+				});
+				return await managedLaunch;
+			}
+			const resolvedProject = options.preserveProjectRoot ? {
+				projectPath: path.resolve(projectPath),
+				sourceProjectPath: path.resolve(projectPath)
+			} : await scope.step(() => resolveAutomatorProjectPath(projectPath), { stage: "project" });
+			if (config.autoBootstrapDevtools !== false) bootstrapResult = await scope.step(() => bootstrapWechatDevtoolsSettings({
+				target,
+				projectPath: resolvedProject.projectPath,
+				trustProject: resolvedTrustProject
+			}), { stage: "settings" });
+			if (bootstrapResult?.servicePortEnabled === false) throw new Error("Detected WeChat DevTools service port is disabled in current settings. Please enable it manually; existing user settings were not modified.");
+			for (let attempt = 0; attempt < 2; attempt += 1) {
+				scope.attempt();
+				try {
+					const miniProgram = await scope.step(() => launcher.launch({
+						cliPath: resolvedCliPath,
+						...port ? { port } : {},
+						projectPath: resolvedProject.projectPath,
+						timeout: scope.remainingMs(),
+						signal: scope.signal,
+						trustProject: resolvedTrustProject
+					}), {
+						stage: "launch",
+						disposeLate: (program) => program.disconnect()
+					});
+					scope.own(() => miniProgram.disconnect(), "automator-session");
+					const sessionMetadata = Reflect.get(miniProgram, "__WEAPP_VITE_SESSION_METADATA");
+					if (typeof sessionMetadata?.wsEndpoint === "string" && sessionMetadata.wsEndpoint) {
+						const wsEndpoint = sessionMetadata.wsEndpoint;
+						await scope.step(() => assertWechatDevtoolsPort(target, Number(new URL(wsEndpoint).port), {
+							signal: scope.signal,
+							timeout: scope.remainingMs()
+						}), { stage: "port-identity" });
+						await scope.step(() => persistAutomatorSession({
+							installationId,
+							signal: scope.signal,
+							...port ? { port: sessionMetadata.port ?? port } : {},
+							projectPath,
+							sessionId,
+							wsEndpoint
+						}), { stage: "session-persist" });
+						if (options.persistAsDefaultSession && (port || sessionId)) await scope.step(() => persistAutomatorSession({
+							installationId,
+							signal: scope.signal,
+							projectPath,
+							wsEndpoint
+						}), { stage: "session-persist" });
+					}
+					return miniProgram;
+				} catch (error) {
+					lastError = error;
+					scope.recordFailure(error);
+					scope.throwIfAborted();
+					if (!isRetryableAutomatorLaunchError(error) || attempt === 1) throw error;
+				}
+			}
+			throw lastError instanceof Error ? lastError : new Error(String(lastError));
+		});
+	} catch (error) {
+		if (managedLaunch) await (await managedLaunch).close();
+		throw error;
+	}
+}
+/**
+* @description 基于当前配置解析 CLI 路径，并通过现代化 automator 入口启动会话。
+*/
+async function launchAutomator(options) {
+	options.signal?.throwIfAborted();
+	return (options.runtimeProvider ?? process.env.WEAPP_VITE_AUTOMATOR_RUNTIME_PROVIDER ?? process.env.WEAPP_VITE_E2E_RUNTIME_PROVIDER) === "headless" ? await launchSelectedAutomator(options) : await withMachineE2ELease(() => launchSelectedAutomator(options));
+}
+/**
+* @description 登记由外部 automator bridge 创建的会话，供 CLI 子进程安全复用。
+*/
+async function persistOpenedAutomatorSession(options) {
+	const resolved = await resolveAutomatorSessionOptions(options);
+	if (resolved.runtimeProvider === "headless" || !resolved.target) throw new Error("DEVTOOLS_SESSION_PROVIDER_INVALID: external automator sessions require the WeChat DevTools provider.");
+	const endpoint = new URL(options.wsEndpoint);
+	if (endpoint.protocol !== "ws:" || endpoint.hostname !== "127.0.0.1" || !endpoint.port) throw new Error("DEVTOOLS_SESSION_ENDPOINT_INVALID: automator session endpoint must be a loopback websocket.");
+	const endpointPort = Number(endpoint.port);
+	const port = options.port ?? endpointPort;
+	if (port !== endpointPort) throw new Error(`DEVTOOLS_SESSION_PORT_MISMATCH: endpoint=${endpointPort} option=${port}`);
+	await assertWechatDevtoolsPort(resolved.target, endpointPort, {
+		signal: options.signal,
+		timeout: options.timeout ?? 3e4
+	});
+	await persistAutomatorSession({
+		installationId: resolved.installationId,
+		projectPath: options.projectPath,
+		port,
+		...options.sessionId ? { sessionId: options.sessionId } : {},
+		signal: options.signal,
+		wsEndpoint: options.wsEndpoint
+	});
+	if (!options.port && !options.sessionId) await persistAutomatorSession({
+		installationId: resolved.installationId,
+		projectPath: options.projectPath,
+		signal: options.signal,
+		wsEndpoint: options.wsEndpoint
+	});
+}
+/**
+* @description 只读连接当前项目已打开的自动化会话；失败不证明缓存过期，也不删除其他操作持有的会话记录。
+*/
+async function connectOpenedAutomator(options) {
+	const { port, projectPath, sessionId } = options;
+	return await new OperationLifecycle(options.timeout ?? 3e4, "IDE connect", options.signal).run(async (scope) => {
+		const { Launcher } = await scope.step(() => import("@weapp-vite/miniprogram-automator"), { stage: "load-automator" });
+		scope.attempt();
+		const launcher = new Launcher();
+		const resolved = await scope.step(() => resolveAutomatorSessionOptions(options), { stage: "resolve-cli" });
+		const persistedSession = await scope.step(() => readPersistedAutomatorSession({
+			projectPath,
+			sessionId,
+			port,
+			installationId: resolved.installationId
+		}), { stage: "session-lookup" });
+		if (!persistedSession) throw Object.assign(/* @__PURE__ */ new Error("DEVTOOLS_SESSION_IDENTITY_UNVERIFIED: no matching installation-bound session; launch the selected installation before connecting."), { code: "DEVTOOLS_SESSION_IDENTITY_UNVERIFIED" });
+		const wsEndpoint = persistedSession.wsEndpoint;
+		await scope.step(() => assertWechatDevtoolsPort(resolved.target, Number(new URL(wsEndpoint).port), {
+			signal: scope.signal,
+			timeout: scope.remainingMs()
+		}), { stage: "port-identity" });
+		const miniProgram = await scope.step(async () => await launcher.connect({
+			timeout: scope.remainingMs(),
+			signal: scope.signal,
+			wsEndpoint
+		}), {
+			stage: "connect",
+			disposeLate: (program) => {
+				if (program && typeof program === "object" && "disconnect" in program && typeof program.disconnect === "function") return program.disconnect();
+			}
+		});
+		if (process.env.WEAPP_IDE_MANAGED_PROJECT_JOURNAL) miniProgram.close = async () => {
+			await miniProgram.disconnect();
+		};
+		return miniProgram;
+	});
+}
+//#endregion
+export { waitForExclusiveKeypress as A, isWechatIdeLoginRequiredError as C, waitForRetryKeypress as D, promptWechatIdeLoginRetry as E, parseAutomatorPort as F, i18nText as M, validateLocaleOption as N, createSharedInputSession as O, resolveAutomatorSessionOptions as P, formatWechatIdeLoginRequiredError as S, promptRetryKeypress as T, RETRY_CONFIRM_KEYS as _, bootstrapWechatDevtoolsSettings as a, extractExecutionErrorText as b, getAutomatorProtocolTimeoutMethod as c, isAutomatorProtocolTimeoutError as d, isAutomatorWsConnectError as f, RETRY_CANCEL_KEYS as g, isRetryableAutomatorLaunchError as h, resolveProjectAutomatorPort as i, configureLocaleFromArgv as j, runWithSuspendedSharedInput as k, isAutomatorLoginError as l, isDevtoolsHttpPortError as m, launchAutomator as n, detectWechatDevtoolsServicePort as o, isDevtoolsExtensionContextInvalidatedError as p, persistOpenedAutomatorSession as r, formatAutomatorLoginError as s, connectOpenedAutomator as t, isAutomatorPortInUseError as u, RETRY_PROMPT_INITIAL_IGNORE_MS as v, isWechatIdeLoginRequiredExitError as w, formatRetryHotkeyPrompt as x, createWechatIdeLoginRequiredExitError as y };