weapp-ide-cli 6.2.0 → 6.3.0

package/README.md

@@ -259,9 +259,42 @@ console.log(WEAPP_IDE_TOP_LEVEL_COMMAND_NAMES)
 
 ### 安装选择与共享登录
 
-日常开发和本仓库 E2E 推荐使用固定位置的一份官方 Stable。多个项目复用同一个已登录宿主，无需为测试另外准备微信账号；登录正常过期时仍需通过 IDE 完成登录。不要复制 ticket、Cookie 或账号配置来同步两个安装。
+默认选择本机已安装的最新 Stable；官方灰度发布或网络查询失败不会阻塞默认选版。macOS 扫描系统及用户 Applications，Windows 读取安装登记和常见目录，Linux 与自定义位置通过显式 CLI 路径或本地登记接入。渠道和产品版本读取实际应用元数据，按数字段比较版本；符号链接按真实安装去重，同版本存在多份安装时要求 `--cli-path`。
 
-未提供固定 `target` 时，程序化调用的显式 `cliPath` 优先；未指定时依次使用进程环境变量 `WEAPP_IDE_CLI_PATH`、全局 `cliPath` 配置和平台默认路径。提供 `target` 后，额外的 `cliPath` 必须指向同一个真实 CLI 文件，符号链接别名可用；不同安装会抛出 `WECHAT_DEVTOOLS_INSTALLATION_SELECTION_CONFLICT`，不会覆盖既定选择。环境变量只作用于当前进程及其子进程，不写回配置文件。`weapp config doctor` 显示持久配置与实际生效路径、产品版本和安装身份。
+```sh
+weapp devtools list --json
+weapp devtools add "<path-to-cli>"
+weapp devtools remove "<path-to-cli>"
+wv ide devtools list
+wv open --devtools-channel=nightly
+wv dev --open --devtools-channel=rc
+wv ide preview --devtools-channel=rc --devtools-version=2.02.2608080
+```
+
+安装由用户完成，登记只保存 CLI 路径，每次重新读取元数据。列表显示渠道、版本、安装身份、实际配置目录及失效原因；登录使用各安装自己的配置目录，不复制 ticket、Cookie 或账号数据。
+
+同一微信账号切换安装后，另一安装的登录可能失效。无需准备多个账号，可在需要测试的版本中重新扫码；工具不共享或迁移登录数据。矩阵使用非交互模式，登录失效记录为 `blocked`，附带 `runtimeBlocker.code: "needs-login"`，保留原始错误并继续其他版本；不会等待扫码或自动重试，最终返回非零退出码。重新登录后可单独运行该渠道补测。
+
+选择优先级为：已固定的 `target` / 当前操作安装 → 本次 `cliPath`、`devtoolsChannel`、`devtoolsVersion` → 环境变量 → 旧全局 `cliPath` → 本机最新 Stable。显式渠道/版本覆盖继承的路径固定；同层路径、渠道、版本必须一致。`--devtools-version` 是开发者工具产品版本，上传的 `--version` 仍为小程序版本。包装参数不会传给官方 CLI。RC/nightly 需要明确选择，操作的启动、构建、连接、恢复和清理沿用同一安装。
+
+公共环境变量为 `WEAPP_IDE_CLI_PATH`、`WEAPP_IDE_DEVTOOLS_CHANNEL`、`WEAPP_IDE_DEVTOOLS_VERSION`；E2E 使用对应的 `WEAPP_VITE_E2E_DEVTOOLS_*`，解析后向全部子进程传入具体 CLI。兼容 `WEAPP_VITE_E2E_ACCEPTED_DEVTOOLS_VERSION` / `WEAPP_VITE_E2E_ACCEPTED_DEVTOOLS_CHANNEL` 的固定选择。显式 `--require-official-latest`（或公共 `WEAPP_IDE_REQUIRE_OFFICIAL_LATEST=1`、E2E `WEAPP_VITE_E2E_REQUIRE_OFFICIAL_LATEST=1`）才要求匹配所选渠道官方最新版本，查询失败也会阻塞此严格模式。
+
+```ts
+import { listWechatDevtoolsInstallations, previewWechatIde, resolveWechatDevtoolsTarget } from 'weapp-ide-cli'
+
+const installations = await listWechatDevtoolsInstallations()
+const target = await resolveWechatDevtoolsTarget({ devtoolsChannel: 'rc' })
+await previewWechatIde({ projectPath: './dist', target })
+```
+
+两套 MCP 的连接工具和相关 REST 输入都支持 `cliPath`、`devtoolsChannel`、`devtoolsVersion`、`requireOfficialLatest`；会话按真实安装身份隔离，同一项目不会串用 Stable 与 nightly 连接。
+
+```sh
+pnpm e2e:ide:matrix --targets=stable,rc,nightly --suite=ide-smoke
+pnpm e2e:ide:matrix --targets=stable@2.02.2608080,nightly --suite=ide-gate --filter=<task>
+```
+
+矩阵默认只测 Stable，复用既有 suite 及其筛选和严格策略，全程持有同机同用户串行租约。普通测试失败或缺失安装记录后继续；所有权异常、清理失败、OOM 或取消停止后续目标。报告保存在 `docs/reports/devtools-matrix`，分别记录请求、实际安装、runtime/基础库版本、官方查询状态和结果。缺失、阻塞、partial 或未执行不能计为完整通过，返回非零退出码；全量正式验收仍遵守主线工作树要求。
 
 HTTP 服务端口和 automator 会话都绑定选定安装。另一安装的配置较新、端口可连或版本号相同，均不代表可以复用。未知旧会话不会直接连接；宿主或监听端口归属不一致时停止操作，保留原有 IDE 和账号状态。`port` 仍表示对应接口原有的端口类型，不将 automator WebSocket 端口当作 HTTP 服务端口。
 
@@ -269,7 +302,9 @@ HTTP 服务端口和 automator 会话都绑定选定安装。另一安装的配
 
 `openWechatIdeProjectByHttp()` 使用 `/v2/open` 的 `project` 参数并保留原始响应正文；空正文或空 JSON 对象会抛出 `WECHAT_DEVTOOLS_HTTP_OPEN_UNCONFIRMED`，不能把 HTTP 200 当作项目已打开的证据。目标项目及 runtime 是否就绪仍需通过会话或 IDE 界面确认。
 
-本仓库真实 IDE E2E 显式设置 `WEAPP_VITE_E2E_DEVTOOLS_CLI_PATH`，预检把它传入本轮公共 CLI，核对执行时官方 Stable 与实际宿主；不会自动安装或切换版本。不同 worktree 的 E2E 使用同机同用户的排他租约，冲突报告 `Runtime busy`，应等待持有者结束。普通 CLI 的宿主变更同样参与协调，已建立的多项目连接不长期占用此租约。自动恢复不清共享缓存、不退出账号；只释放本任务登记的资源。
+本仓库真实 IDE E2E 自动解析并固定本轮安装，核对实际宿主及 runtime 版本；不会自动安装工具。不同 worktree 的 E2E 使用同机同用户的排他租约，冲突报告 `Runtime busy`，应等待持有者结束。普通 CLI 的宿主变更同样参与协调，已建立的多项目连接不长期占用此租约。自动恢复不清共享缓存、不退出账号；只释放本任务登记的资源。
+
+macOS 安装退出核验直接使用系统报告的映像路径，避免无关进程的受保护或已删除文件阻塞清理。当前磁盘路径被替换也不会覆盖原映像的归属判断；PID、启动时间、端口和任务登记仍须通过校验。
 
 ### 6. 程序化 opened-session helper
 
@@ -318,6 +353,27 @@ await clearWechatIdeCacheByAutomator({
 console.log(info, ticket)
 ```
 
+### 7. 程序化 automator 与异步断开
+
+`connectOpenedAutomator()` 返回的会话提供公开 `send(method, params?, { timeout }?)` 与 `CDP().enable/sendCommand/listProtocol/onEvent`，用于直接调用已连接 DevTools 支持的自动化和调试协议。`onEvent` 返回取消订阅函数；可用域和命令以目标宿主 `listProtocol()` 的结果为准。
+
+```ts
+import { connectOpenedAutomator } from 'weapp-ide-cli'
+
+const miniProgram = await connectOpenedAutomator({ projectPath: '.' })
+try {
+  console.log(await miniProgram.send('Tool.getInfo', {}, { timeout: 3_000 }))
+  console.log(await miniProgram.CDP().listProtocol({ timeout: 3_000 }))
+}
+finally {
+  await miniProgram.disconnect()
+}
+```
+
+`disconnect()` 现在返回 `Promise<void>`，调用时立即停止订阅并拒绝未完成请求，等待 WebSocket 关闭后完成。迁移同步清理回调时应返回或 `await` 此 Promise；超时和清理失败继续抛出。它只释放本连接，保留已打开项目窗口；需要关闭本任务受管窗口时使用相应会话的 `close()`，并等待窗口 owner 完成确认。MCP、日志转发及命令结束清理均等待各自持有的连接，不重新启动 IDE。
+
+headless 会话的 `send` 仅适配 `Tool.getInfo`、`App.getCurrentPage/getPageStack/callFunction/callWxMethod`；`CDP()` 和其他原始协议明确报告 `HEADLESS_PROTOCOL_UNSUPPORTED`。触摸接口使用标准 `changedTouches`，旧 `changeTouches` 仍兼容，同时传入以标准字段为准。
+
 ## 路径与参数兼容
 
 - `-p` 会被自动替换为 `--project`，并且相对路径会解析为绝对路径。

package/dist/{automator-CRpB6_pA.js → automator-BOe32upt.js}

@@ -1,11 +1,11 @@
-import { _ as readCustomConfig, a as assertWechatDevtoolsPort, i as assertWechatDevtoolsHost, n as readPersistedAutomatorSession, r as resolveWechatDevtoolsTarget, t as persistAutomatorSession } from "./sessionStore-zdzy2UFM.js";
+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 { createHash } from "node:crypto";
 import fs from "node:fs/promises";
 import process from "node:process";
-import os from "node:os";
+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) {
@@ -40,6 +40,377 @@ async function resolveAutomatorSessionOptions(options) {
 	};
 }
 //#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;
@@ -63,12 +434,6 @@ const DEVTOOLS_INFRA_ERROR_PATTERNS = [
 	/ECONNREFUSED/i,
 	/connect ECONNREFUSED/i
 ];
-const DEVTOOLS_LOGIN_REQUIRED_PATTERNS = [
-	/code\s*[:=]\s*10/i,
-	/需要重新登录/,
-	/need\s+re-?login/i,
-	/re-?login/i
-];
 /**
 * @description 从错误对象中提取可读文本。
 */
@@ -146,9 +511,7 @@ function getAutomatorProtocolTimeoutMethod(error) {
 * @description 判断错误是否属于开发者工具登录失效。
 */
 function isAutomatorLoginError(error) {
-	const text = extractErrorText(error);
-	if (!text) return false;
-	return DEVTOOLS_LOGIN_REQUIRED_PATTERNS.some((pattern) => pattern.test(text));
+	return isWechatIdeLoginRequiredError(error);
 }
 /**
 * @description 格式化开发者工具登录失效错误，便于终端展示。
@@ -164,124 +527,6 @@ function formatAutomatorLoginError(error) {
 	return lines.join("\n");
 }
 //#endregion
-//#region src/cli/automatorProject.ts
-const WRAPPER_ROOT = path.join(os.tmpdir(), "weapp-ide-cli-automator-projects");
-function normalizeProjectRelativeRoot(rawRoot) {
-	if (typeof rawRoot !== "string") return;
-	const normalized = rawRoot.trim().replace(/\\/g, "/").replace(/^\/+/, "").replace(/\/+$/, "");
-	if (!normalized || normalized === ".") return;
-	if (normalized.split("/").includes("..")) return;
-	return normalized;
-}
-async function pathExists(filePath) {
-	try {
-		await fs.access(filePath);
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function readJsonObject$1(filePath) {
-	try {
-		const raw = await fs.readFile(filePath, "utf8");
-		const value = JSON.parse(raw);
-		return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
-	} catch {
-		return;
-	}
-}
-async function writeJsonObject$1(filePath, value) {
-	await fs.mkdir(path.dirname(filePath), { recursive: true });
-	await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
-}
-async function copyProjectRoot(sourceProjectPath, wrapperProjectPath, relativeRoot) {
-	const sourcePath = path.join(sourceProjectPath, relativeRoot);
-	if (!await pathExists(sourcePath)) return;
-	await fs.cp(sourcePath, path.join(wrapperProjectPath, relativeRoot), {
-		dereference: true,
-		force: true,
-		recursive: true
-	});
-}
-function createWrapperProjectConfig(source, patch) {
-	const { miniprogramRoot: _miniprogramRoot, qcloudRoot: _qcloudRoot, srcMiniprogramRoot: _srcMiniprogramRoot, ...rest } = source;
-	const sourceSetting = source.setting && typeof source.setting === "object" ? source.setting : {};
-	const patchSetting = patch.setting && typeof patch.setting === "object" ? patch.setting : {};
-	return {
-		...rest,
-		...patch,
-		setting: {
-			...sourceSetting,
-			...patchSetting,
-			packNpmManually: false,
-			packNpmRelationList: []
-		}
-	};
-}
-async function ensureWrapperAppConfig(wrapperProjectPath) {
-	const appConfigPath = path.join(wrapperProjectPath, "app.json");
-	const appConfig = await readJsonObject$1(appConfigPath);
-	if (!appConfig) return;
-	await writeJsonObject$1(appConfigPath, {
-		...appConfig,
-		subPackages: Array.isArray(appConfig.subPackages) ? appConfig.subPackages : []
-	});
-}
-/**
-* @description 为 DevTools automator 准备稳定的小程序根目录，避免打开瞬间跨 miniprogramRoot 读取 app.json 抖动。
-*/
-async function resolveAutomatorProjectPath(projectPath) {
-	const sourceProjectPath = path.resolve(projectPath);
-	const projectConfig = await readJsonObject$1(path.join(sourceProjectPath, "project.config.json"));
-	const miniprogramRoot = normalizeProjectRelativeRoot(projectConfig?.miniprogramRoot);
-	if (!miniprogramRoot) return {
-		projectPath: sourceProjectPath,
-		sourceProjectPath
-	};
-	const sourceProjectConfig = projectConfig ?? {};
-	const distRoot = path.join(sourceProjectPath, miniprogramRoot);
-	if (!await pathExists(path.join(distRoot, "app.json"))) return {
-		projectPath: sourceProjectPath,
-		sourceProjectPath
-	};
-	const wrapperHash = createHash("sha1").update(sourceProjectPath).update("\0").update(path.resolve(distRoot)).digest("hex").slice(0, 16);
-	const wrapperProjectPath = path.join(WRAPPER_ROOT, wrapperHash);
-	await fs.rm(wrapperProjectPath, {
-		recursive: true,
-		force: true
-	});
-	await fs.mkdir(wrapperProjectPath, { recursive: true });
-	await fs.cp(distRoot, wrapperProjectPath, {
-		dereference: true,
-		force: true,
-		recursive: true
-	});
-	const pluginRoot = normalizeProjectRelativeRoot(sourceProjectConfig.pluginRoot);
-	if (pluginRoot) await copyProjectRoot(sourceProjectPath, wrapperProjectPath, pluginRoot);
-	const rootPatch = {
-		compileType: sourceProjectConfig.compileType === "plugin" ? "plugin" : "miniprogram",
-		miniprogramRoot: "./",
-		srcMiniprogramRoot: "./"
-	};
-	const projectPrivateConfig = await readJsonObject$1(path.join(sourceProjectPath, "project.private.config.json")) ?? {};
-	await writeJsonObject$1(path.join(wrapperProjectPath, "project.config.json"), createWrapperProjectConfig(sourceProjectConfig, {
-		...projectPrivateConfig,
-		...rootPatch
-	}));
-	await fs.rm(path.join(wrapperProjectPath, "project.private.config.json"), { force: true });
-	await ensureWrapperAppConfig(wrapperProjectPath);
-	return {
-		cleanup: async () => {
-			await fs.rm(wrapperProjectPath, {
-				recursive: true,
-				force: true
-			});
-		},
-		projectPath: wrapperProjectPath,
-		sourceProjectPath
-	};
-}
-//#endregion
 //#region src/cli/wechatDevtoolsSettings.ts
 function createStorageHash(key) {
 	return createHash("md5").update(key).digest("hex");
@@ -420,25 +665,26 @@ async function launchSelectedAutomator(options) {
 			const launcher = new Launcher();
 			let lastError = null;
 			let bootstrapResult;
-			const resolvedProject = options.preserveProjectRoot ? {
-				projectPath: path.resolve(projectPath),
-				sourceProjectPath: path.resolve(projectPath)
-			} : await scope.step(() => resolveAutomatorProjectPath(projectPath), { stage: "project" });
-			if (process.env.WEAPP_IDE_MANAGED_PROJECT_JOURNAL) {
-				const { launchManagedAutomator } = await import("./managed-Sq8y8FzP.js");
+			if (process.env["WEAPP_IDE_MANAGED_PROJECT_JOURNAL"]?.trim()) {
+				const { launchManagedAutomator } = await import("./managed-B04Xo9U_.js");
 				managedLaunch = launchManagedAutomator({
 					launcher,
 					scope,
 					target,
-					projectPath: resolvedProject.projectPath,
+					projectPath: path.resolve(projectPath),
 					sourceProjectPath: projectPath,
-					port: port ?? resolveProjectAutomatorPort(resolvedProject.projectPath),
+					port: port ?? resolveProjectAutomatorPort(projectPath),
 					sessionId,
 					trustProject: resolvedTrustProject,
-					persistAsDefaultSession: options.persistAsDefaultSession
+					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,
@@ -563,14 +809,14 @@ async function connectOpenedAutomator(options) {
 		}), {
 			stage: "connect",
 			disposeLate: (program) => {
-				if (program && typeof program === "object" && "disconnect" in program && typeof program.disconnect === "function") program.disconnect();
+				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 () => {
-			miniProgram.disconnect();
+			await miniProgram.disconnect();
 		};
 		return miniProgram;
 	});
 }
 //#endregion
-export { parseAutomatorPort as _, bootstrapWechatDevtoolsSettings as a, getAutomatorProtocolTimeoutMethod as c, isAutomatorProtocolTimeoutError as d, isAutomatorWsConnectError as f, resolveAutomatorSessionOptions as g, isRetryableAutomatorLaunchError as h, resolveProjectAutomatorPort as i, 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 };
+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 };

package/dist/automator-VSjgHujY.js

@@ -0,0 +1 @@
+export { n as launchAutomator } from "./automator-BOe32upt.js";