@weapp-vite/miniprogram-automator 1.3.0 → 1.4.0

package/dist/index.mjs

@@ -6,6 +6,7 @@ import path from "node:path";
 import { EventEmitter } from "node:events";
 import { createDebug } from "obug";
 import WebSocket from "ws";
+import { stripVTControlCharacters } from "node:util";
 import fs from "node:fs/promises";
 import os from "node:os";
 import { spawn } from "node:child_process";
@@ -235,6 +236,304 @@ function cmpVersion(versionA, versionB) {
 	return 0;
 }
 //#endregion
+//#region src/componentCaller/runtime.ts
+/** 在同一个 Runtime 上下文持有真实 caller，不转用其他 ContextManager 的 token。 */
+function createComponentCallerSession(expected, observerTimeout) {
+	const root = this;
+	const adapter = root.__glassEaselAdapter__;
+	const environment = adapter?.getEnv?.();
+	if (typeof environment?.getAdapterPage !== "function") throw new TypeError("Component caller backend selection is unavailable");
+	if (environment.getAdapterPage(expected.pageId)) return {
+		backend: "glass-easel",
+		dispose: () => ({
+			state: "disposed",
+			added: false,
+			removed: false
+		})
+	};
+	const bridge = root.WeixinJSBridge;
+	if (!bridge || typeof bridge.addSubscribeListener !== "function" || typeof bridge.removeSubscribeListener !== "function" || !adapter || typeof adapter.getVirtualDOM !== "function") throw new Error("Exact component caller bridge is unavailable");
+	const add = bridge.addSubscribeListener;
+	const remove = bridge.removeSubscribeListener;
+	const subscribe = bridge.subscribe;
+	const virtualDOM = adapter.getVirtualDOM();
+	const exparser = virtualDOM?.getExparser?.();
+	if (typeof virtualDOM?.getNodeById !== "function" || typeof virtualDOM.getNodeId !== "function" || typeof virtualDOM.getPageId !== "function" || typeof exparser?.Element?.getMethodCaller !== "function") throw new TypeError("Exact component caller mapping is unavailable");
+	let state = "created";
+	let caller;
+	let node;
+	let virtualId;
+	let added = false;
+	let removed = false;
+	let totalInvocations = 0;
+	let matchingInvocations = 0;
+	let timer;
+	const errors = [];
+	const eventName = "exparserComponentInvoker";
+	function identitiesMatch() {
+		return root.WeixinJSBridge === bridge && root.__glassEaselAdapter__ === adapter && bridge.subscribe === subscribe && bridge.addSubscribeListener === add && bridge.removeSubscribeListener === remove && adapter.getVirtualDOM() === virtualDOM && virtualDOM.getExparser() === exparser;
+	}
+	function snapshot() {
+		return {
+			state,
+			added,
+			removed,
+			totalInvocations,
+			matchingInvocations,
+			errors: [...errors],
+			identitiesMatch: identitiesMatch()
+		};
+	}
+	function listener(message, sender) {
+		totalInvocations += 1;
+		if (state !== "armed" && state !== "resolved") return;
+		if (message?.method !== "resolveComponentCaller") return;
+		matchingInvocations += 1;
+		try {
+			const args = message.params;
+			if (matchingInvocations !== 1 || !Array.isArray(args) || args.length !== 1 || args[0] === null || typeof args[0] !== "object" || Array.isArray(args[0])) throw new Error("Component caller resolver payload is ambiguous");
+			const params = args[0];
+			const id = params.nodeId;
+			if (!Number.isSafeInteger(message.callbackId) || message.callbackId <= 0 || sender !== expected.pageId || params.webviewId !== expected.pageId || !(typeof id === "string" && id.length > 0 || Number.isSafeInteger(id) && id >= 0)) throw new Error("Component caller resolver identity disagrees");
+			if (!identitiesMatch()) throw new Error("Component caller bridge identity changed");
+			const resolvedNode = virtualDOM.getNodeById(id, expected.pageId);
+			if (!resolvedNode || virtualDOM.getNodeId(resolvedNode, expected.pageId) !== id || virtualDOM.getPageId(resolvedNode) !== expected.pageId) throw new Error("Component caller virtual node identity disagrees");
+			const resolvedCaller = exparser.Element.getMethodCaller(resolvedNode);
+			if (!resolvedCaller || !["object", "function"].includes(typeof resolvedCaller)) throw new Error("Component caller is unavailable");
+			virtualId = id;
+			node = resolvedNode;
+			caller = resolvedCaller;
+			state = "resolved";
+		} catch (error) {
+			errors.push(error instanceof Error ? error.message : String(error));
+			state = "failed";
+		}
+	}
+	function removeListener() {
+		if (added && !removed) {
+			remove.call(bridge, eventName, listener);
+			removed = true;
+		}
+		if (timer !== void 0) {
+			clearTimeout(timer);
+			timer = void 0;
+		}
+	}
+	function dispose() {
+		try {
+			removeListener();
+			state = "disposed";
+		} finally {
+			caller = void 0;
+			node = void 0;
+			virtualId = void 0;
+		}
+		return {
+			state,
+			added,
+			removed,
+			totalInvocations,
+			matchingInvocations,
+			errors: [...errors]
+		};
+	}
+	return {
+		backend: "exparser",
+		arm() {
+			if (state !== "created") throw new Error("Component caller observer cannot be armed twice");
+			state = "armed";
+			timer = setTimeout(() => {
+				try {
+					dispose();
+				} catch (error) {
+					errors.push(error instanceof Error ? error.message : String(error));
+					state = "failed";
+				}
+			}, observerTimeout);
+			added = true;
+			add.call(bridge, eventName, listener);
+			return snapshot();
+		},
+		snapshot,
+		disarm() {
+			removeListener();
+			if (state !== "resolved" || matchingInvocations !== 1 || errors.length || !identitiesMatch()) throw new Error(`Exact component caller resolution failed: ${JSON.stringify(snapshot())}`);
+			state = "ready";
+			return snapshot();
+		},
+		invoke(method, args) {
+			if (state !== "ready" || !removed || errors.length || !identitiesMatch()) throw new Error("Component caller is not ready for a single invocation");
+			const pages = typeof getCurrentPages === "function" ? getCurrentPages() : [];
+			if (pages[pages.length - 1]?.__wxWebviewId__ !== expected.pageId || virtualDOM.getNodeById(virtualId, expected.pageId) !== node || virtualDOM.getNodeId(node, expected.pageId) !== virtualId || virtualDOM.getPageId(node) !== expected.pageId || exparser.Element.getMethodCaller(node) !== caller) throw new Error("Component caller changed before invocation");
+			state = "dispatched";
+			return caller[method](...args);
+		},
+		dispose
+	};
+}
+//#endregion
+//#region src/componentCaller/index.ts
+const queues = /* @__PURE__ */ new WeakMap();
+const blocked = /* @__PURE__ */ new WeakMap();
+const owners = /* @__PURE__ */ new WeakMap();
+const TIMEOUT = 2500;
+/** 关闭连接前确认全部自有 listener 已移除；失败时保留 token 与可重试的所有权。 */
+function cleanupComponentCallers(connection) {
+	const pending = owners.get(connection);
+	if (!pending?.size) return;
+	return (async () => {
+		const errors = [];
+		for (const owner of [...pending]) try {
+			await owner.cleanup();
+		} catch (error) {
+			errors.push(error);
+		}
+		if (errors.length) throw new AggregateError(errors, "Component caller cleanup remains incomplete", { cause: errors[0] });
+		blocked.delete(connection);
+	})();
+}
+function result(response) {
+	if (response.exceptionDetails) throw new Error(response.exceptionDetails.text ?? "Component caller Runtime exception", { cause: response.exceptionDetails });
+	if (!response.result) throw new Error("Component caller Runtime result is missing");
+	return response.result;
+}
+function serializeArguments(args) {
+	const payload = JSON.parse(stringify({ params: { args } }));
+	return JSON.stringify(payload.params.args);
+}
+/** 保持原 SDK 的 returnByValue 解包，不等待业务返回的 Promise。 */
+async function unwrap(connection, remote) {
+	if (remote.subtype === "null") return null;
+	if (remote.type === "undefined") return;
+	if (remote.value !== void 0) return remote.value;
+	if (remote.unserializableValue) {
+		const value = remote.unserializableValue;
+		if (/^-?\d+n$/.test(value)) return BigInt(value.slice(0, -1));
+		if ([
+			"NaN",
+			"Infinity",
+			"-Infinity",
+			"-0"
+		].includes(value)) return Number(value);
+		throw new Error(`Unsupported component return value: ${value}`);
+	}
+	if (remote.objectId) try {
+		const converted = await connection.send("App.CDPCommand", {
+			domain: "Runtime",
+			method: "callFunctionOn",
+			params: {
+				objectId: remote.objectId,
+				functionDeclaration: "function () { try { return JSON.stringify(this) } catch { return String(this) } }",
+				returnByValue: true
+			}
+		}, { timeout: TIMEOUT });
+		if (converted.result?.value !== void 0) try {
+			return JSON.parse(converted.result.value);
+		} catch {
+			return converted.result.value;
+		}
+	} catch {}
+	return remote.description ?? `[${remote.type}]`;
+}
+async function invoke(connection, target, method, args, native) {
+	let token;
+	let owner;
+	const errors = [];
+	let cleanupFailed = false;
+	let nativeBackend = false;
+	let value;
+	const cdp = async (domain, command, params) => {
+		return await connection.send("App.CDPCommand", {
+			domain,
+			method: command,
+			params
+		}, { timeout: TIMEOUT });
+	};
+	const wrapper = async (body) => result(await cdp("Runtime", "callFunctionOn", {
+		objectId: token,
+		functionDeclaration: `function () { return ${body} }`,
+		arguments: [],
+		returnByValue: true
+	}));
+	try {
+		if (!Number.isSafeInteger(target.nodeId) || target.nodeId < 0 || !Number.isSafeInteger(target.pageId)) throw new Error("Invalid component caller native target");
+		if ((await connection.send("App.getCurrentPage", {}, { timeout: TIMEOUT })).pageId !== target.pageId) throw new Error("Component caller target is not on the current page");
+		const created = result(await cdp("Runtime", "evaluate", {
+			expression: `(${createComponentCallerSession.toString()})(${JSON.stringify(target)}, 10000)`,
+			returnByValue: false
+		}));
+		if (!created.objectId) throw new Error("Component caller session has no owned Runtime token");
+		token = created.objectId;
+		let cleaning;
+		let disposed = false;
+		let released = false;
+		owner = { cleanup() {
+			cleaning ??= (async () => {
+				if (released) return;
+				if (!disposed) {
+					const snapshot = (await wrapper("this.dispose()")).value;
+					if (snapshot?.state !== "disposed" || snapshot.added && !snapshot.removed) throw new Error("Component caller listener removal was not confirmed");
+					disposed = true;
+				}
+				await cdp("Runtime", "releaseObject", { objectId: token });
+				released = true;
+				owners.get(connection)?.delete(owner);
+			})().catch((error) => {
+				cleaning = void 0;
+				throw error;
+			});
+			return cleaning;
+		} };
+		let pending = owners.get(connection);
+		if (!pending) {
+			pending = /* @__PURE__ */ new Set();
+			owners.set(connection, pending);
+		}
+		pending.add(owner);
+		const backend = (await wrapper("this.backend")).value;
+		if (backend === "glass-easel") nativeBackend = true;
+		else if (backend === "exparser") {
+			const argumentSource = serializeArguments(args);
+			await wrapper("this.arm()");
+			await cdp("WxComponent", "resolveComponentCaller", { nodeId: target.nodeId });
+			await wrapper("this.disarm()");
+			value = await unwrap(connection, await wrapper(`this.invoke(${JSON.stringify(method)}, ${argumentSource})`));
+		} else throw new Error("Unknown component caller backend");
+	} catch (error) {
+		errors.push(error);
+	} finally {
+		if (owner) try {
+			await owner.cleanup();
+		} catch (error) {
+			errors.push(error);
+			cleanupFailed = true;
+		}
+	}
+	if (cleanupFailed) blocked.set(connection, new Error("Component caller cleanup failed; reconnect before invoking another component", { cause: errors[0] }));
+	if (errors.length === 1) throw errors[0];
+	if (errors.length) throw new AggregateError(errors, "Component caller invocation and cleanup failed", { cause: errors[0] });
+	if (nativeBackend) {
+		if (!native) throw new Error("Native component backend requires the original protocol");
+		return await native();
+	}
+	return value;
+}
+/** 同一连接串行观察 resolver，避免多个组件误认彼此的桥接消息。 */
+async function invokeComponentMethod(connection, target, method, args, native) {
+	const pending = (queues.get(connection) ?? Promise.resolve()).then(async () => {
+		const failure = blocked.get(connection);
+		if (failure) throw failure;
+		return await invoke(connection, target, method, args, native);
+	});
+	const settled = pending.then(() => {}, () => {});
+	queues.set(connection, settled);
+	try {
+		return await pending;
+	} finally {
+		if (queues.get(connection) === settled) queues.delete(connection);
+	}
+}
+//#endregion
 //#region src/pageRouteSnapshot.ts
 const ROUTE_ELEMENT_SNAPSHOT_TIMEOUT = 5e3;
 const ROUTE_ELEMENT_SNAPSHOT_EMPTY_RETRIES = 2;
@@ -454,6 +753,14 @@ async function readRouteElementSnapshot(connection, route, query, selector, inde
 }
 //#endregion
 //#region src/Element.ts
+function normalizeTouchOptions(options) {
+	const { changeTouches, ...payload } = options;
+	const changedTouches = options.changedTouches ?? changeTouches;
+	return changedTouches === void 0 ? payload : {
+		...payload,
+		changedTouches
+	};
+}
 const ELEMENT_QUERY_TIMEOUT = 2500;
 const ELEMENT_WXML_TIMEOUT = 8e3;
 /** Element 的实现。 */
@@ -559,16 +866,26 @@ var Element = class Element {
 		await this.send("Element.triggerEvent", payload);
 	}
 	async touchstart(options = {}) {
-		await this.send("Element.touchstart", options);
+		await this.send("Element.touchstart", normalizeTouchOptions(options));
 	}
 	async touchmove(options = {}) {
-		await this.send("Element.touchmove", options);
+		await this.send("Element.touchmove", normalizeTouchOptions(options));
 	}
 	async touchend(options = {}) {
-		await this.send("Element.touchend", options);
+		await this.send("Element.touchend", normalizeTouchOptions(options));
 	}
 	async dispatchEvent(options) {
-		await this.send("Element.dispatchEvent", options);
+		const payload = normalizeTouchOptions(options);
+		if (!payload.$ && !payload.detail && (payload.eventName === "touchstart" || payload.eventName === "touchmove" || payload.eventName === "touchend") && (payload.touches !== void 0 || payload.changedTouches !== void 0)) {
+			const { eventName, ...touchOptions } = payload;
+			await this.send(`Element.${eventName}`, touchOptions);
+			return;
+		}
+		const { detail, ...event } = payload;
+		await this.send("Element.dispatchEvent", detail === void 0 ? event : {
+			...event,
+			eventData: detail
+		});
 	}
 	async _property(name) {
 		return await this.getter(name, "getProperties", "properties");
@@ -750,6 +1067,18 @@ var CustomElement = class extends Element {
 		return (await this.send("Element.getData", payload)).data;
 	}
 	async callMethod(method, ...args) {
+		if (this.connection.prefersComponentCallerBridge) {
+			const nodeId = this.nodeId === null ? NaN : Number(this.nodeId);
+			return await invokeComponentMethod(this.connection, {
+				nodeId,
+				pageId: this.pageId
+			}, method, args, async () => {
+				return (await this.send("Element.callMethod", {
+					method,
+					args
+				})).result;
+			});
+		}
 		return (await this.send("Element.callMethod", {
 			method,
 			args
@@ -828,6 +1157,9 @@ var ContextElement = class extends Element {
 /** Transport 的实现。 */
 var Transport = class extends EventEmitter {
 	ws;
+	closed = false;
+	terminating = false;
+	closing;
 	constructor(ws) {
 		super();
 		this.ws = ws;
@@ -835,6 +1167,7 @@ var Transport = class extends EventEmitter {
 			this.emit("message", typeof data === "string" ? data : data.toString());
 		});
 		ws.on("close", () => {
+			this.closed = true;
 			this.emit("close");
 		});
 	}
@@ -842,7 +1175,36 @@ var Transport = class extends EventEmitter {
 		this.ws.send(message);
 	}
 	close() {
-		this.ws.terminate();
+		if (this.closing) return this.closing;
+		if (this.closed || this.ws.readyState === 3) return this.closing = Promise.resolve();
+		this.closing = new Promise((resolve, reject) => {
+			let timer;
+			const finish = () => {
+				clearTimeout(timer);
+				this.off("close", finish);
+				resolve();
+			};
+			timer = setTimeout(() => {
+				this.off("close", finish);
+				reject(Object.assign(/* @__PURE__ */ new Error("DevTools websocket did not close within 2000ms"), { code: "DEVTOOLS_DISCONNECT_TIMEOUT" }));
+			}, 2e3);
+			this.once("close", finish);
+			try {
+				if (!this.terminating) {
+					this.terminating = true;
+					this.ws.terminate();
+				}
+			} catch (error) {
+				this.terminating = false;
+				clearTimeout(timer);
+				this.off("close", finish);
+				reject(error);
+			}
+		}).catch((error) => {
+			this.closing = void 0;
+			throw error;
+		});
+		return this.closing;
 	}
 };
 //#endregion
@@ -868,9 +1230,11 @@ const APP_SERVICE_PAGE_METHOD_VERSIONS = /* @__PURE__ */ new Set([
 var Connection = class Connection extends EventEmitter {
 	transport;
 	disposed = false;
+	disposing;
 	callbacks = /* @__PURE__ */ new Map();
 	useAppServicePageProtocol = false;
 	useAppServicePageMethod = false;
+	useComponentCallerBridge = false;
 	constructor(transport) {
 		super();
 		this.transport = transport;
@@ -910,18 +1274,51 @@ var Connection = class Connection extends EventEmitter {
 		});
 	}
 	dispose() {
-		if (this.disposed) return;
-		this.disposed = true;
-		this.onClose();
+		if (this.disposing) return this.disposing;
+		let resolve;
+		let reject;
+		this.disposing = new Promise((done, fail) => {
+			resolve = done;
+			reject = fail;
+		}).catch((error) => {
+			this.disposing = void 0;
+			throw error;
+		});
+		const cleanup = cleanupComponentCallers(this);
+		if (cleanup) cleanup.then(() => this.closeTransport(resolve, reject), reject);
+		else this.closeTransport(resolve, reject);
+		return this.disposing;
+	}
+	closeTransport(resolve, reject) {
+		const errors = [];
+		try {
+			this.onClose();
+		} catch (error) {
+			errors.push(error);
+		}
 		this.transport.off("message", this.onMessage);
 		this.transport.off("close", this.onClose);
-		this.transport.close();
+		const finish = () => {
+			if (errors.length === 1) reject(errors[0]);
+			else if (errors.length) reject(new AggregateError(errors, "Connection close notification and transport cleanup failed", { cause: errors[0] }));
+			else resolve();
+		};
+		try {
+			Promise.resolve(this.transport.close()).then(finish, (error) => {
+				errors.push(error);
+				finish();
+			});
+		} catch (error) {
+			errors.push(error);
+			finish();
+		}
 	}
 	/** 根据 DevTools 版本选择稳定的 Page 协议实现。 */
 	configureToolInfo(info) {
 		const version = String(info.version ?? "");
 		this.useAppServicePageProtocol = APP_SERVICE_PAGE_PROTOCOL_VERSIONS.has(version);
 		this.useAppServicePageMethod = this.useAppServicePageProtocol || APP_SERVICE_PAGE_METHOD_VERSIONS.has(version);
+		this.useComponentCallerBridge = version === "2.02.2608080" && info.SDKVersion === "3.17.5";
 	}
 	get prefersAppServicePageProtocol() {
 		return this.useAppServicePageProtocol;
@@ -930,6 +1327,10 @@ var Connection = class Connection extends EventEmitter {
 	get prefersAppServicePageMethod() {
 		return this.useAppServicePageMethod;
 	}
+	/** 仅为实测存在跨上下文 token 错绑的 IDE 与基础库启用真实 caller 桥接。 */
+	get prefersComponentCallerBridge() {
+		return this.useComponentCallerBridge;
+	}
 	onMessage = (message) => {
 		debugProtocol(`${dateFormat("yyyy-mm-dd HH:MM:ss:l")} ◀ RECV ${message}`);
 		const { id, method, error, result, params } = JSON.parse(message);
@@ -942,17 +1343,21 @@ var Connection = class Connection extends EventEmitter {
 		this.callbacks.delete(id);
 		clearTimeout(callback.timeout);
 		if (error) {
-			callback.reject(new Error(error.message || closeErrTip));
+			const message = typeof error.message === "string" ? error.message : error.message === void 0 ? closeErrTip : JSON.stringify(error.message);
+			callback.reject(new Error(message, { cause: error }));
 			return;
 		}
 		callback.resolve(result);
 	};
 	onClose = () => {
+		if (this.disposed) return;
+		this.disposed = true;
 		for (const callback of this.callbacks.values()) {
 			clearTimeout(callback.timeout);
 			callback.reject(/* @__PURE__ */ new Error(closeErrTip));
 		}
 		this.callbacks.clear();
+		this.emit("close");
 	};
 	static create(url, timeout = CONNECT_TIMEOUT, signal) {
 		signal?.throwIfAborted();
@@ -1000,7 +1405,25 @@ var Connection = class Connection extends EventEmitter {
 //#endregion
 //#region src/headless.ts
 async function launchHeadlessAutomator(options) {
-	return await (await import("./launch-anJvfi-6.mjs")).launch({ projectPath: options.projectPath });
+	return await (await import("./launch-ElaGbFxh.mjs")).launch({ projectPath: options.projectPath });
+}
+//#endregion
+//#region src/launcher/diagnostics.ts
+/** 将本次 CLI 的有界输出附到原始错误，避免泄露登录票据及账号参数。 */
+function attachCliDiagnostics(error, state, secrets = []) {
+	const original = error instanceof Error ? error : new Error("Failed to launch WeChat DevTools", { cause: error });
+	if (original.cliOutput !== void 0) return original;
+	let output = stripVTControlCharacters(state.output).trim();
+	for (const secret of secrets.filter(Boolean).sort((a, b) => b.length - a.length)) output = output.split(secret).join("[redacted]");
+	output = output.replace(/(authorization["']?\s*[:=]\s*["']?)(?:Bearer|Basic)\s+[^\s"',;}]+/gi, "$1[redacted]");
+	output = output.replace(/((?:--)?(?:auto-account|account|ticket|access[_-]?token|refresh[_-]?token|token|authorization)["']?\s*(?:[:=]\s*|\s))(["']?)([^\s"',;}]+)\2/gi, "$1[redacted]");
+	if (!output) return original;
+	const truncated = state.outputTruncated || output.length > 32768;
+	output = output.slice(-32768);
+	const target = Object.isExtensible(original) ? original : new Error(original.message, { cause: original });
+	target.cliOutput = output;
+	target.message += `\ncli output${truncated ? " (truncated; last 32768 characters)" : ""}:\n${output}`;
+	return target;
 }
 //#endregion
 //#region src/launcher/portLease.ts
@@ -1026,7 +1449,7 @@ function isProcessAlive(pid) {
 	}
 }
 async function removePortLock(leasePath) {
-	await fs.rm(leasePath, { force: true }).catch(() => {});
+	await fs.rm(leasePath, { force: true });
 }
 async function removeStalePortLock(leasePath) {
 	try {
@@ -1058,14 +1481,18 @@ async function createPortLock(port) {
 	return leasePath;
 }
 function createLease(port, leasePath) {
-	let released = false;
+	let releasing;
 	return {
 		path: leasePath,
 		port,
-		release: async () => {
-			if (released) return;
-			released = true;
-			if (leasePath) await removePortLock(leasePath);
+		release: () => {
+			releasing ??= (async () => {
+				if (leasePath) await removePortLock(leasePath);
+			})().catch((error) => {
+				releasing = void 0;
+				throw error;
+			});
+			return releasing;
 		}
 	};
 }
@@ -1185,7 +1612,8 @@ function spawnWechatCli(cliPath, args, cwd, scope) {
 		error: null,
 		success: false,
 		exited: false,
-		output: ""
+		output: "",
+		outputTruncated: false
 	};
 	const bootstrapArgs = resolveWechatDevtoolsBootstrapArgs(args);
 	const target = shouldUseWindowsCommandShell(cliPath) ? resolveWindowsBatchSpawn(cliPath, bootstrapArgs) : {
@@ -1221,7 +1649,9 @@ function spawnWechatCli(cliPath, args, cwd, scope) {
 		state.error = error;
 	});
 	const output = (chunk) => {
-		state.output = (state.output + String(chunk)).slice(-32768);
+		const combined = state.output + String(chunk);
+		state.outputTruncated ||= combined.length > 32768;
+		state.output = combined.slice(-32768);
 	};
 	child.stdout?.on("data", output);
 	child.stderr?.on("data", output);
@@ -1236,7 +1666,7 @@ function spawnWechatCli(cliPath, args, cwd, scope) {
 }
 //#endregion
 //#region package.json
-var version = "1.3.0";
+var version = "1.4.0";
 //#endregion
 //#region src/appServiceHeap.ts
 function isRecord$1(value) {
@@ -1275,6 +1705,112 @@ async function readAppServiceHeapUsage(send, options = {}) {
 	};
 }
 //#endregion
+//#region src/cdp/index.ts
+/** 单个连接共享 CDP 启用状态与订阅；不创建额外 WebSocket。 */
+var CDPController = class {
+	connection;
+	send;
+	enabling;
+	enabled = false;
+	stopped = false;
+	subscriptions = /* @__PURE__ */ new Set();
+	session;
+	constructor(connection, send) {
+		this.connection = connection;
+		this.send = send;
+		connection.on("close", this.stop);
+		this.session = {
+			enable: (options) => this.enable(options),
+			sendCommand: (domain, method, params = {}, options) => this.request("App.CDPCommand", {
+				domain,
+				method,
+				params
+			}, options),
+			listProtocol: (options) => this.request("App.CDPListProtocol", {}, options),
+			onEvent: (listener) => this.onEvent(listener)
+		};
+	}
+	enable(options) {
+		if (this.stopped) return Promise.reject(/* @__PURE__ */ new Error("CDP connection closed"));
+		try {
+			this.validateTimeout(options);
+		} catch (error) {
+			return Promise.reject(error);
+		}
+		if (!this.enabling) {
+			let pending;
+			try {
+				pending = this.send("App.CDPEnable", {}, options);
+			} catch (error) {
+				pending = Promise.reject(error);
+			}
+			this.enabling = pending.then((result) => {
+				this.enabled = true;
+				return result;
+			}, (error) => {
+				this.enabling = void 0;
+				throw error;
+			});
+		}
+		if (options?.timeout === void 0) return this.enabling;
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Timed out enabling CDP within ${options.timeout}ms`)), options.timeout);
+			this.enabling.then(resolve, reject).finally(() => clearTimeout(timer));
+		});
+	}
+	/** 日志显式刷新时重新注册事件通道，兼容 AppService 重载。 */
+	refresh(options) {
+		if (this.enabled) {
+			this.enabled = false;
+			this.enabling = void 0;
+		}
+		return this.enable(options);
+	}
+	stop = () => {
+		this.stopped = true;
+		this.enabled = false;
+		this.enabling = void 0;
+		this.connection.off("close", this.stop);
+		for (const unsubscribe of this.subscriptions) unsubscribe();
+	};
+	async request(method, params, options) {
+		this.validateTimeout(options);
+		const startedAt = Date.now();
+		await this.enable(options);
+		if (this.stopped) throw new Error("CDP connection closed");
+		if (options?.timeout === void 0) return await this.send(method, params);
+		const timeout = options.timeout - (Date.now() - startedAt);
+		if (timeout <= 0) throw new Error(`Timed out executing ${method} within ${options.timeout}ms`);
+		return await this.send(method, params, { timeout });
+	}
+	validateTimeout(options) {
+		if (options?.timeout !== void 0 && (!Number.isFinite(options.timeout) || options.timeout <= 0)) throw new RangeError("CDP timeout must be finite and positive");
+	}
+	onEvent(listener) {
+		if (this.stopped) throw new Error("CDP connection closed");
+		const receive = (payload) => {
+			listener(payload.domain, payload.event, payload.params);
+		};
+		const unsubscribe = () => {
+			this.connection.off("App.CDPEvent", receive);
+			this.subscriptions.delete(unsubscribe);
+		};
+		this.subscriptions.add(unsubscribe);
+		this.connection.on("App.CDPEvent", receive);
+		return unsubscribe;
+	}
+};
+const controllers = /* @__PURE__ */ new WeakMap();
+/** 一个协议连接仅拥有一份 CDP 状态，包括被不同 MiniProgram 包装的连接。 */
+function getCDPController(connection, send) {
+	let controller = controllers.get(connection);
+	if (!controller) {
+		controller = new CDPController(connection, send);
+		controllers.set(connection, controller);
+	}
+	return controller;
+}
+//#endregion
 //#region src/Native.ts
 /** Native 的实现。 */
 var Native = class extends EventEmitter {
@@ -2641,16 +3177,21 @@ var MiniProgram = class extends EventEmitter {
 	logEnabling;
 	structuredLogs = false;
 	structuredConsole;
+	cdp;
 	pageMap = /* @__PURE__ */ new Map();
 	nativeIns;
+	disconnecting;
+	closing;
 	constructor(connection) {
 		super();
 		this.connection = connection;
+		this.cdp = getCDPController(connection, (method, params, options) => this.send(method, params, options));
 		this.structuredConsole = new StructuredConsole((method, params, options) => this.send(method, params, options), (entry) => this.emit("console", entry));
 		connection.on("App.CDPEvent", this.structuredConsole.receive);
 		connection.on("App.logAdded", this.onLogAdded);
 		connection.on("App.bindingCalled", this.onBindingCalled);
 		connection.on("App.exceptionThrown", this.onExceptionThrown);
+		connection.on("close", this.stopSubscriptions);
 	}
 	async pageStack() {
 		const { pageStack } = await this.send("App.getPageStack");
@@ -2795,16 +3336,24 @@ var MiniProgram = class extends EventEmitter {
 			duration: 0
 		});
 	}
-	async close() {
-		try {
-			await withTimeout(this.send("App.exit"), CLOSE_STEP_TIMEOUT);
-		} catch {}
-		await sleep(1e3);
-		try {
-			await withTimeout(this.send("Tool.close"), CLOSE_STEP_TIMEOUT);
-		} catch {} finally {
-			this.disconnect();
-		}
+	close() {
+		this.closing ??= (async () => {
+			try {
+				try {
+					await withTimeout(this.send("App.exit"), CLOSE_STEP_TIMEOUT);
+				} catch {}
+				await sleep(1e3);
+				try {
+					await withTimeout(this.send("Tool.close"), CLOSE_STEP_TIMEOUT);
+				} catch {}
+			} finally {
+				await this.disconnect();
+			}
+		})().catch((error) => {
+			this.closing = void 0;
+			throw error;
+		});
+		return this.closing;
 	}
 	async remote(auto = false) {
 		const { qrCode } = await this.send("Tool.enableRemoteDebug", { auto });
@@ -2817,9 +3366,23 @@ var MiniProgram = class extends EventEmitter {
 		});
 	}
 	disconnect() {
-		this.structuredConsole.stop();
-		this.connection.dispose();
+		if (this.disconnecting) return this.disconnecting;
+		this.stopSubscriptions();
+		this.disconnecting = Promise.resolve(this.connection.dispose()).catch((error) => {
+			this.disconnecting = void 0;
+			throw error;
+		});
+		return this.disconnecting;
 	}
+	stopSubscriptions = () => {
+		this.structuredConsole.stop();
+		this.cdp.stop();
+		this.connection.off("App.CDPEvent", this.structuredConsole.receive);
+		this.connection.off("App.logAdded", this.onLogAdded);
+		this.connection.off("App.bindingCalled", this.onBindingCalled);
+		this.connection.off("App.exceptionThrown", this.onExceptionThrown);
+		this.connection.off("close", this.stopSubscriptions);
+	};
 	/** 等待已接收的结构化日志完成 Error 属性检查并发布。 */
 	async flushConsole() {
 		await this.structuredConsole.flush();
@@ -2844,7 +3407,12 @@ var MiniProgram = class extends EventEmitter {
 			let cdpMethod = this.structuredLogs ? "App.CDPEnable" : "App.CDPCommand";
 			try {
 				if (this.structuredLogs) {
-					await request(cdpMethod);
+					if (timeout === void 0) await this.cdp.refresh();
+					else {
+						const remaining = timeout - (Date.now() - startedAt);
+						if (remaining <= 0) throw new Error(`Timed out enabling console logging within ${timeout}ms`);
+						await this.cdp.refresh({ timeout: remaining });
+					}
 					cdpMethod = "App.CDPCommand";
 				}
 				await request("App.CDPCommand", {
@@ -3112,6 +3680,11 @@ var MiniProgram = class extends EventEmitter {
 		}
 		throw lastError;
 	}
+	/** 返回当前连接共享的 CDP 调试入口。 */
+	CDP() {
+		return this.cdp.session;
+	}
+	/** 发送原始自动化协议，沿用连接的请求超时及清理契约。 */
 	async send(method, params = {}, options) {
 		return options ? await this.connection.send(method, params, options) : await this.connection.send(method, params);
 	}
@@ -3315,7 +3888,7 @@ var SmartappApp = class {
 		return [];
 	}
 	async close() {
-		this.miniProgram?.disconnect();
+		await this.miniProgram?.disconnect();
 	}
 };
 //#endregion
@@ -3393,8 +3966,8 @@ var SmartappDevice = class {
 		return false;
 	}
 	async close() {
-		await this.driver.close?.();
-		this.driver.miniProgram?.disconnect();
+		const errors = (await Promise.allSettled([Promise.resolve().then(() => this.driver.close?.()), Promise.resolve().then(() => this.driver.miniProgram?.disconnect())])).filter((result) => result.status === "rejected").map((result) => result.reason);
+		if (errors.length) throw new AggregateError(errors, "Smartapp device cleanup failed");
 	}
 };
 //#endregion
@@ -3561,29 +4134,34 @@ const DEFAULT_RUNTIME_PROVIDER_ENV = "WEAPP_VITE_AUTOMATOR_RUNTIME_PROVIDER";
 const LEGACY_RUNTIME_PROVIDER_ENV = "WEAPP_VITE_E2E_RUNTIME_PROVIDER";
 let localhostListenPatched = false;
 function retainPortLeaseUntilSessionClose(miniProgram, portLease) {
-	let released = false;
+	let released;
 	const release = async () => {
-		if (released) return;
-		released = true;
-		await portLease.release();
+		released ??= portLease.release().catch((error) => {
+			released = void 0;
+			throw error;
+		});
+		await released;
 	};
 	const target = miniProgram;
 	const rawClose = target.close;
 	const rawDisconnect = target.disconnect;
 	if (typeof rawClose !== "function" && typeof rawDisconnect !== "function") return false;
-	if (typeof rawDisconnect === "function") target.disconnect = function disconnectWithPortLeaseRelease() {
-		try {
-			return rawDisconnect.call(this);
-		} finally {
-			release();
-		}
-	};
+	if (typeof rawDisconnect === "function") {
+		let disconnecting;
+		target.disconnect = function disconnectWithPortLeaseRelease() {
+			disconnecting ??= (async () => {
+				await rawDisconnect.call(this);
+				await release();
+			})().catch((error) => {
+				disconnecting = void 0;
+				throw error;
+			});
+			return disconnecting;
+		};
+	}
 	if (typeof rawClose === "function") target.close = async function closeWithPortLeaseRelease() {
-		try {
-			return await rawClose.call(this);
-		} finally {
-			await release();
-		}
+		await rawClose.call(this);
+		await release();
 	};
 	return true;
 }
@@ -3625,7 +4203,7 @@ var Launcher = class {
 				} catch (error) {
 					scope.recordFailure(error);
 					scope.throwIfAborted();
-					if (!isRecoverableOperationError(error) || attempt >= attempts) throw error;
+					if (error instanceof AggregateError || !isRecoverableOperationError(error) || attempt >= attempts) throw error;
 				}
 			}
 		});
@@ -3639,10 +4217,35 @@ var Launcher = class {
 		});
 		const rawReleaseLease = portLease.release.bind(portLease);
 		let releasedLease;
-		portLease.release = () => releasedLease ??= rawReleaseLease();
-		const disownLease = scope.own(() => portLease.release(), "port-lease");
+		portLease.release = () => releasedLease ??= rawReleaseLease().catch((error) => {
+			releasedLease = void 0;
+			throw error;
+		});
+		const connectionTasks = [];
+		const disconnectingConnections = /* @__PURE__ */ new WeakMap();
+		const disconnectConnection = (program) => {
+			const pending = disconnectingConnections.get(program);
+			if (pending) return pending;
+			const closing = Promise.resolve(program.disconnect?.()).catch((error) => {
+				disconnectingConnections.delete(program);
+				throw error;
+			});
+			disconnectingConnections.set(program, closing);
+			return closing;
+		};
+		const releaseConnectionsAndLease = async () => {
+			const results = await Promise.allSettled(connectionTasks);
+			const errors = (await Promise.allSettled(results.map((result) => result.status === "fulfilled" ? disconnectConnection(result.value) : Promise.resolve()))).filter((result) => result.status === "rejected").map((result) => result.reason);
+			if (errors.length) throw new AggregateError(errors, "Automator connections did not finish closing; port lease retained");
+			await portLease.release();
+		};
+		const disownLease = scope.own(releaseConnectionsAndLease, "port-lease");
 		let releasePortLeaseOnExit = true;
 		let releaseChild = async () => {};
+		let diagnoseFailure = (error) => error;
+		let failure;
+		let failed = false;
+		let result;
 		try {
 			const port = portLease.port;
 			if (!cliPath) throw new Error("Wechat web devTools not found, please specify cliPath option");
@@ -3656,6 +4259,7 @@ var Launcher = class {
 			let httpFallbackError = null;
 			let targetPort = port;
 			const cli = spawnWechatCli(cliPath, args, cwd, scope);
+			diagnoseFailure = (error) => attachCliDiagnostics(error, cli, [ticket, account]);
 			releaseChild = cli.release;
 			let miniProgram = null;
 			let lastConnectError = null;
@@ -3687,40 +4291,49 @@ var Launcher = class {
 					}
 					const connectTimeout = resolveRemainingTimeout();
 					if (connectTimeout <= 0) return false;
-					const candidate = await scope.step(() => this.connectTool({
-						signal: scope.signal,
-						timeout: Math.min(3e3, connectTimeout),
-						wsEndpoint: `ws://127.0.0.1:${targetPort}`
-					}), {
+					const candidate = await scope.step(() => {
+						const connecting = this.connectTool({
+							signal: scope.signal,
+							timeout: Math.min(3e3, connectTimeout),
+							wsEndpoint: `ws://127.0.0.1:${targetPort}`
+						});
+						connectionTasks.push(connecting);
+						return connecting;
+					}, {
 						stage: "websocket",
-						disposeLate: (program) => program.disconnect()
+						disposeLate: disconnectConnection
 					});
-					let releasedCandidate = false;
+					let releasedCandidate;
 					const releaseCandidate = () => {
-						if (!releasedCandidate) {
-							releasedCandidate = true;
-							candidate.disconnect();
-						}
+						return releasedCandidate ??= disconnectConnection(candidate).catch((error) => {
+							releasedCandidate = void 0;
+							throw error;
+						});
 					};
 					const disownCandidate = scope.own(releaseCandidate, "websocket");
 					try {
 						const checkVersionTimeout = resolveRemainingTimeout();
 						if (checkVersionTimeout <= 0) {
-							releaseCandidate();
+							await scope.step(releaseCandidate);
 							return false;
 						}
 						await scope.step(() => candidate.checkVersion(Math.min(VERSION_CHECK_TIMEOUT, checkVersionTimeout)), { stage: "version" });
 						if (typeof candidate.waitForAppReady === "function") {
 							const appReadyTimeout = resolveRemainingTimeout();
 							if (appReadyTimeout <= 0) {
-								releaseCandidate();
+								await scope.step(releaseCandidate);
 								return false;
 							}
 							await scope.step(() => candidate.waitForAppReady(appReadyTimeout), { stage: "app-ready" });
 						}
 					} catch (error) {
+						try {
+							await scope.step(releaseCandidate);
+						} catch (cleanupError) {
+							if (cleanupError !== error) throw new AggregateError([error, cleanupError], "Automator validation and connection cleanup failed", { cause: error });
+							throw error;
+						}
 						disownCandidate();
-						releaseCandidate();
 						lastConnectError = error;
 						if (isRecoverableOperationError(error)) return false;
 						throw error;
@@ -3731,7 +4344,7 @@ var Launcher = class {
 					lastConnectError = error;
 					scope.recordFailure(error);
 					scope.throwIfAborted();
-					if (!isRecoverableOperationError(error)) throw error;
+					if (error instanceof AggregateError || !isRecoverableOperationError(error)) throw error;
 					return false;
 				}
 			}, scope.remainingMs(), 1e3, scope.signal), { stage: "readiness" });
@@ -3749,15 +4362,30 @@ var Launcher = class {
 				wsEndpoint: `ws://127.0.0.1:${targetPort}`
 			});
 			releasePortLeaseOnExit = !retainPortLeaseUntilSessionClose(resolvedMiniProgram, portLease);
+			if (!releasePortLeaseOnExit) disownLease();
+			result = resolvedMiniProgram;
+		} catch (error) {
+			failed = true;
+			failure = diagnoseFailure(error);
+		}
+		const cleanupErrors = [];
+		try {
+			await scope.step(releaseChild);
+		} catch (error) {
+			if (!failed || error !== failure) cleanupErrors.push(error);
+		}
+		if (releasePortLeaseOnExit) try {
+			await scope.step(releaseConnectionsAndLease);
 			disownLease();
-			return resolvedMiniProgram;
-		} finally {
-			await releaseChild();
-			if (releasePortLeaseOnExit) {
-				disownLease();
-				await portLease.release();
-			}
+		} catch (error) {
+			if ((!failed || error !== failure) && !cleanupErrors.includes(error)) cleanupErrors.push(error);
 		}
+		if (cleanupErrors.length) {
+			if (failed) throw new AggregateError([failure, ...cleanupErrors], "Automator launch and resource cleanup failed", { cause: failure });
+			throw new AggregateError(cleanupErrors, "Automator launch resource cleanup failed");
+		}
+		if (failed) throw failure;
+		return result;
 	}
 	async connect(options) {
 		if (normalizePlatform(options.platform) === "swan") return await new SwanLauncher().connect(options);