weapp-ide-cli 6.1.9 → 6.2.0

package/dist/automator-session-gWEsSs_A.js

@@ -0,0 +1,558 @@
+import { D as logger, E as colors } from "./sessionStore-zdzy2UFM.js";
+import { c as getAutomatorProtocolTimeoutMethod, d as isAutomatorProtocolTimeoutError, f as isAutomatorWsConnectError, g as resolveAutomatorSessionOptions, i as resolveProjectAutomatorPort, l as isAutomatorLoginError, m as isDevtoolsHttpPortError, n as launchAutomator, p as isDevtoolsExtensionContextInvalidatedError, s as formatAutomatorLoginError, t as connectOpenedAutomator, u as isAutomatorPortInUseError } from "./automator-CRpB6_pA.js";
+import { acquireSharedMiniProgram, closeSharedMiniProgram, getSharedMiniProgramSessionCount, releaseSharedMiniProgram, withMiniProgram } from "@weapp-vite/devtools-runtime";
+import process from "node:process";
+import { OperationLifecycle } from "@weapp-vite/miniprogram-automator/operation";
+import { emitKeypressEvents } from "node:readline";
+//#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*10/i,
+	/需要重新登录/,
+	/need\s+re-?login/i,
+	/re-?login/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(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(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;
+}
+/**
+* @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/run-login-executor.ts
+/** 命令、登录提示和有限重试共用一个 deadline，取消信号由执行边界传入 I/O。 */
+async function runRetryableCommand(options) {
+	return await new OperationLifecycle(options.timeout ?? 3e4, "IDE command", options.signal).run(async (scope) => {
+		const maxAttempts = options.maxAttempts ?? 3;
+		for (let retryCount = 0;; retryCount += 1) {
+			scope.attempt();
+			const result = await scope.step(() => options.execute(scope), {
+				stage: "execute",
+				waitForExit: true,
+				disposeLate: options.disposeLate
+			});
+			if (!options.isRetryableResult(result)) return result;
+			const cause = options.createCancelError(result);
+			scope.recordFailure(cause);
+			if (retryCount + 1 >= maxAttempts) throw cause;
+			const action = await scope.step(() => options.promptRetry(result, retryCount, scope), {
+				stage: "login-retry",
+				waitForExit: true
+			});
+			if (options.shouldRetry(action)) {
+				scope.throwIfAborted();
+				options.onRetry?.();
+				continue;
+			}
+			options.onCancel?.(result);
+			throw cause;
+		}
+	});
+}
+//#endregion
+//#region src/cli/automator-session.ts
+function unwrapAutomatorConnectionError(result) {
+	return result.kind === "retryable" ? result.error : result.value;
+}
+async function launchFreshAutomator(options) {
+	const shouldUseProjectPort = !options.port && !options.sessionId;
+	return await launchAutomator({
+		...options,
+		...shouldUseProjectPort ? {
+			persistAsDefaultSession: true,
+			port: resolveProjectAutomatorPort(options.projectPath)
+		} : {}
+	});
+}
+function normalizeMiniProgramConnectionError(error, background = false) {
+	const diagnostics = background ? {
+		error: (message) => logger.debug(message),
+		warn: (message) => logger.debug(message)
+	} : logger;
+	if (isAutomatorLoginError(error)) {
+		diagnostics.error(i18nText("检测到微信开发者工具登录状态失效，请先登录后重试。", "Wechat DevTools login has expired. Please login and retry."));
+		diagnostics.warn(formatAutomatorLoginError(error));
+		return new Error("DEVTOOLS_LOGIN_REQUIRED", { cause: error });
+	}
+	if (isDevtoolsHttpPortError(error)) {
+		diagnostics.error(i18nText("无法连接到微信开发者工具，请确保已开启 HTTP 服务端口。", "Cannot connect to Wechat DevTools. Please ensure HTTP service port is enabled."));
+		diagnostics.warn(i18nText("请在微信开发者工具中：设置 -> 安全设置 -> 开启服务端口", "Please enable service port in Wechat DevTools: Settings -> Security -> Service Port"));
+		return new Error("DEVTOOLS_HTTP_PORT_ERROR", { cause: error });
+	}
+	if (isDevtoolsExtensionContextInvalidatedError(error)) {
+		diagnostics.error(i18nText("微信开发者工具自动化上下文尚未就绪，通常是刚启动或正在重载。", "Wechat DevTools automation context is not ready yet, usually because the IDE has just started or is still reloading."));
+		diagnostics.warn(i18nText("请稍后重试；若持续失败，关闭多余的开发者工具窗口后重试。", "Please retry shortly. If it keeps failing, close extra DevTools windows and try again."));
+		return new Error("DEVTOOLS_EXTENSION_CONTEXT_INVALIDATED", { cause: error });
+	}
+	if (isAutomatorWsConnectError(error) || isAutomatorPortInUseError(error)) {
+		diagnostics.error(i18nText("无法连接到当前项目的微信开发者工具自动化 websocket。", "Cannot connect to the Wechat DevTools automation websocket for the current project."));
+		diagnostics.warn(i18nText("请确认当前打开的是目标项目；若之前跑过其他 e2e / screenshot 任务，关闭多余的微信开发者工具窗口，或结束残留的 `wechatwebdevtools cli auto --project ...` 进程后重试。", "Please confirm the current DevTools window is the target project. If you recently ran other e2e / screenshot tasks, close extra windows or stop stale `wechatwebdevtools cli auto --project ...` processes and retry."));
+		return new Error("DEVTOOLS_WS_CONNECT_ERROR", { cause: error });
+	}
+	if (isAutomatorProtocolTimeoutError(error)) {
+		const method = getAutomatorProtocolTimeoutMethod(error) ?? "unknown";
+		diagnostics.error(i18nText(`微信开发者工具在协议调用 ${method} 上超时，未按预期返回结果。`, `Wechat DevTools timed out while executing protocol method ${method} and did not return a result.`));
+		diagnostics.warn(i18nText("这通常表示当前 DevTools 自动化会话已卡住、窗口不在目标项目、或当前 DevTools 版本对该协议调用无响应。请重开目标项目窗口后重试；若仍复现，优先记录当前 DevTools 版本与协议方法名继续排查。", "This usually means the current DevTools automation session is stuck, the window is not on the target project, or the current DevTools version is not responding to that protocol method. Reopen the target project window and retry. If it still reproduces, record the current DevTools version and protocol method name for follow-up debugging."));
+		return new Error("DEVTOOLS_PROTOCOL_TIMEOUT", { cause: error });
+	}
+	return error instanceof Error ? error : new Error(String(error));
+}
+/**
+* @description 建立 automator 会话，并统一处理常见连接错误提示。
+*/
+async function connectMiniProgramWithDiagnostics(options, background) {
+	options = await resolveAutomatorSessionOptions(options);
+	const result = await runRetryableCommand({
+		timeout: options.timeout,
+		signal: options.signal,
+		disposeLate: (result) => {
+			if (result.kind === "result") result.value.disconnect();
+		},
+		createCancelError: (result) => createWechatIdeLoginRequiredExitError(unwrapAutomatorConnectionError(result), "cancelled"),
+		execute: async (operation) => {
+			const operationOptions = () => ({
+				...options,
+				timeout: operation.remainingMs(),
+				signal: operation.signal
+			});
+			if (options.runtimeProvider === "headless" || options.preferOpenedSession === false && options.openedOnly !== true) try {
+				return {
+					kind: "result",
+					value: await launchFreshAutomator(operationOptions())
+				};
+			} catch (error) {
+				if (!isAutomatorLoginError(error)) throw normalizeMiniProgramConnectionError(error, background);
+				return {
+					error,
+					kind: "retryable"
+				};
+			}
+			try {
+				return {
+					kind: "result",
+					value: await connectOpenedAutomator(operationOptions())
+				};
+			} catch (error) {
+				const normalizedOpenSessionError = normalizeMiniProgramConnectionError(error, background);
+				if (options.openedOnly || options.preferOpenedSession !== false && Boolean(options.port || options.sessionId)) throw normalizedOpenSessionError;
+				if (normalizedOpenSessionError instanceof Error && ("code" in normalizedOpenSessionError && normalizedOpenSessionError.code === "WECHAT_DEVTOOLS_HOST_IDENTITY_MISMATCH" || normalizedOpenSessionError.message === "DEVTOOLS_PROTOCOL_TIMEOUT" || normalizedOpenSessionError.message.startsWith("DEVTOOLS_INSTALLATION_MISMATCH") || normalizedOpenSessionError.message.startsWith("DEVTOOLS_PORT_IDENTITY"))) throw normalizedOpenSessionError;
+				try {
+					return {
+						kind: "result",
+						value: await launchFreshAutomator(operationOptions())
+					};
+				} catch (launchError) {
+					if (!isAutomatorLoginError(launchError)) throw normalizeMiniProgramConnectionError(launchError, background);
+					return {
+						error: launchError,
+						kind: "retryable"
+					};
+				}
+			}
+		},
+		isRetryableResult: (result) => result.kind === "retryable",
+		onRetry: () => {
+			logger.info(i18nText("正在重试连接微信开发者工具...", "Retrying to connect Wechat DevTools..."));
+		},
+		promptRetry: async (result, _retryCount, operation) => await promptWechatIdeLoginRetry({
+			error: unwrapAutomatorConnectionError(result),
+			retryTimeoutMs: operation.remainingMs(),
+			signal: operation.signal,
+			logger,
+			promptOpenIdeLogin: true
+		}),
+		shouldRetry: (action) => action === "retry"
+	});
+	if (result.kind === "retryable") throw createWechatIdeLoginRequiredExitError(result.error);
+	return result.value;
+}
+/** 建立交互式会话，并报告最终连接错误。 */
+async function connectMiniProgram(options) {
+	return await connectMiniProgramWithDiagnostics(options, false);
+}
+/** 后台日志桥接的连接探针，不在每次可恢复失败时输出终局错误。 */
+async function connectConsoleMiniProgram(options) {
+	return await connectMiniProgramWithDiagnostics(options, true);
+}
+/** 为后台日志桥接保留共享会话所有权和诊断级别。 */
+async function acquireConsoleMiniProgram(options) {
+	return await acquireSharedMiniProgram({
+		resolveSessionOptions: resolveAutomatorSessionOptions,
+		connectMiniProgram: connectConsoleMiniProgram,
+		normalizeConnectionError: (error) => normalizeMiniProgramConnectionError(error, true)
+	}, options);
+}
+const runtimeHooks = {
+	resolveSessionOptions: resolveAutomatorSessionOptions,
+	connectMiniProgram,
+	normalizeConnectionError: normalizeMiniProgramConnectionError
+};
+/**
+* @description 获取指定项目的共享 automator 会话；若不存在则自动创建。
+*/
+async function acquireSharedMiniProgram$1(options) {
+	return await acquireSharedMiniProgram(runtimeHooks, options);
+}
+/**
+* @description 统一管理 automator 会话生命周期。
+*/
+async function withMiniProgram$1(options, runner) {
+	return await withMiniProgram(runtimeHooks, options, runner);
+}
+//#endregion
+export { runWithSuspendedSharedInput as C, validateLocaleOption as D, i18nText as E, createSharedInputSession as S, configureLocaleFromArgv as T, isWechatIdeLoginRequiredError as _, connectMiniProgram as a, promptWechatIdeLoginRetry as b, withMiniProgram$1 as c, RETRY_CONFIRM_KEYS as d, RETRY_PROMPT_INITIAL_IGNORE_MS as f, formatWechatIdeLoginRequiredError as g, formatRetryHotkeyPrompt as h, connectConsoleMiniProgram as i, runRetryableCommand as l, extractExecutionErrorText as m, acquireSharedMiniProgram$1 as n, getSharedMiniProgramSessionCount as o, createWechatIdeLoginRequiredExitError as p, closeSharedMiniProgram as r, releaseSharedMiniProgram as s, acquireConsoleMiniProgram as t, RETRY_CANCEL_KEYS as u, isWechatIdeLoginRequiredExitError as v, waitForExclusiveKeypress as w, waitForRetryKeypress as x, promptRetryKeypress as y };