@weapp-vite/miniprogram-automator 1.2.23 → 1.3.0

package/dist/operation.d.mts

@@ -0,0 +1,64 @@
+//#region src/operation/errors.d.ts
+export declare const OPERATION_TIMEOUT_CODE = "DEVTOOLS_OPERATION_TIMEOUT";
+export type OperationErrorCategory = 'invalid-path' | 'login-required' | 'service-unavailable' | 'connection-transient' | 'protocol-rejected' | 'timeout' | 'canceled' | 'unknown';
+/** 根据原始错误链分类；未知错误默认不重试，路径和登录错误优先。 */
+export declare function classifyOperationError(error: unknown): OperationErrorCategory;
+export declare function isRecoverableOperationError(error: unknown): boolean;
+//#endregion
+//#region src/operation/login.d.ts
+/** 只采用原生 CLI 明确且不矛盾的 login 布尔字段，不推断日志语义。 */
+export declare function readWechatLoginState(stdout: string): boolean | undefined;
+//#endregion
+//#region src/operation/index.d.ts
+export interface OperationStepOptions<T> {
+  stage?: string;
+  waitForExit?: boolean;
+  disposeLate?: (value: T) => void | Promise<void>;
+}
+export interface OperationDiagnostics {
+  version: 1;
+  inner?: OperationDiagnostics;
+  category?: OperationErrorCategory;
+  stage: string;
+  lastSuccessfulStage?: string;
+  elapsedMs: number;
+  remainingMs: number;
+  attempts: number;
+  pendingOperations: number;
+  cleanup: Array<{
+    resource: string;
+    status: 'released' | 'failed' | 'pending';
+  }>;
+}
+/** 一次操作共享绝对截止时间；超时取消底层 I/O，并隔离迟到结果。 */
+export declare class OperationLifecycle {
+  readonly controller: AbortController;
+  readonly signal: AbortSignal;
+  readonly deadlineAt: number;
+  private cleanupDeadlineAt;
+  private readonly startedAt;
+  private readonly pendingExits;
+  private readonly cleanups;
+  private readonly cleanupResults;
+  private readonly timeoutError;
+  private stage;
+  private lastSuccessfulStage?;
+  private attempts;
+  private lastFailure;
+  constructor(timeoutMs: number, label: string, signal?: AbortSignal);
+  private detachParent;
+  get timedOut(): boolean;
+  get diagnostics(): OperationDiagnostics;
+  attempt(): void;
+  recordFailure(error: unknown): void;
+  throwIfAborted(): void;
+  remainingMs(cap?: number): number;
+  own(cleanup: () => void | Promise<void>, resource?: string): () => boolean;
+  private release;
+  step<T>(factory: () => Promise<T>, options?: OperationStepOptions<T>): Promise<T>;
+  phase<T>(timeoutMs: number, label: string, factory: (phase: OperationLifecycle) => Promise<T>): Promise<T>;
+  pause(ms: number): Promise<void>;
+  private cleanup;
+  run<T>(factory: (lifecycle: OperationLifecycle) => Promise<T>): Promise<T>;
+}
+//#endregion

package/dist/operation.mjs

@@ -0,0 +1,233 @@
+import { stripVTControlCharacters } from "node:util";
+//#region src/operation/errors.ts
+const OPERATION_TIMEOUT_CODE = "DEVTOOLS_OPERATION_TIMEOUT";
+/** 根据原始错误链分类；未知错误默认不重试，路径和登录错误优先。 */
+function classifyOperationError(error) {
+	const seen = /* @__PURE__ */ new Set();
+	const parts = [];
+	let originalText = "";
+	let current = error;
+	while (current && typeof current === "object" && !seen.has(current)) {
+		seen.add(current);
+		const item = current;
+		const values = [
+			item.name,
+			item.code === 10 ? "code: 10" : item.code,
+			item.message,
+			item.stderr,
+			item.stdout
+		].filter((part) => typeof part === "string");
+		parts.push(...values);
+		originalText = values.join("\n");
+		current = item.cause;
+	}
+	const text = parts.join("\n");
+	if (/ENOENT|EACCES|not found|doesn't exist|cliPath is not correct|projectPath is not provided/i.test(text)) return "invalid-path";
+	if (/DEVTOOLS_LOGIN_REQUIRED|需要重新登录|need\s+re-?login|code\s*[:=]\s*10\b/i.test(text)) return "login-required";
+	if (/unexpected server response|requires at least version|protocol.*reject|unsupported response|invalid JSON|invalid autoPort/i.test(text)) return "protocol-rejected";
+	if (/DEVTOOLS_OPERATION_TIMEOUT|DEVTOOLS_PROTOCOL_TIMEOUT|timed? ?out/i.test(text)) return "timeout";
+	if (/ECONNREFUSED|service port.*disabled|http port is open/i.test(text)) return "service-unavailable";
+	if (/ECONNRESET|EPIPE|Extension context invalidated|Failed connecting to|closed before handshake/i.test(originalText)) return "connection-transient";
+	if (/AbortError|ABORT_ERR|cancel(?:led|ed)/i.test(text)) return "canceled";
+	return "unknown";
+}
+function isRecoverableOperationError(error) {
+	const category = classifyOperationError(error);
+	return category === "connection-transient" || category === "service-unavailable" || category === "timeout";
+}
+//#endregion
+//#region src/operation/login.ts
+/** 只采用原生 CLI 明确且不矛盾的 login 布尔字段，不推断日志语义。 */
+function readWechatLoginState(stdout) {
+	const results = /* @__PURE__ */ new Set();
+	for (const line of stripVTControlCharacters(stdout).split(/\r?\n/)) try {
+		const value = JSON.parse(line);
+		if (value && typeof value === "object" && "login" in value && typeof value.login === "boolean") results.add(value.login);
+	} catch {}
+	return results.size === 1 ? [...results][0] : void 0;
+}
+//#endregion
+//#region src/operation/index.ts
+const errorDiagnostics = /* @__PURE__ */ new WeakMap();
+/** 一次操作共享绝对截止时间；超时取消底层 I/O，并隔离迟到结果。 */
+var OperationLifecycle = class OperationLifecycle {
+	controller = new AbortController();
+	signal = this.controller.signal;
+	deadlineAt;
+	cleanupDeadlineAt;
+	startedAt = performance.now();
+	pendingExits = /* @__PURE__ */ new Set();
+	cleanups = /* @__PURE__ */ new Map();
+	cleanupResults = [];
+	timeoutError;
+	stage = "initialization";
+	lastSuccessfulStage;
+	attempts = 0;
+	lastFailure;
+	constructor(timeoutMs, label, signal) {
+		if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) throw new RangeError("Operation timeout must be a positive finite number");
+		this.deadlineAt = this.startedAt + timeoutMs;
+		this.cleanupDeadlineAt = this.deadlineAt;
+		this.timeoutError = Object.assign(/* @__PURE__ */ new Error(`Timeout in ${label} after ${timeoutMs}ms`), { code: OPERATION_TIMEOUT_CODE });
+		if (signal) {
+			const abort = () => this.controller.abort(signal.reason);
+			if (signal.aborted) abort();
+			else {
+				signal.addEventListener("abort", abort, { once: true });
+				this.detachParent = () => signal.removeEventListener("abort", abort);
+			}
+		}
+	}
+	detachParent = () => {};
+	get timedOut() {
+		return this.signal.aborted && this.signal.reason === this.timeoutError;
+	}
+	get diagnostics() {
+		return {
+			version: 1,
+			stage: this.stage,
+			lastSuccessfulStage: this.lastSuccessfulStage,
+			elapsedMs: Math.max(0, performance.now() - this.startedAt),
+			remainingMs: Math.max(0, this.deadlineAt - performance.now()),
+			attempts: this.attempts,
+			pendingOperations: this.pendingExits.size,
+			cleanup: this.cleanupResults.map((entry) => ({ ...entry }))
+		};
+	}
+	attempt() {
+		this.throwIfAborted();
+		this.attempts += 1;
+	}
+	recordFailure(error) {
+		if (error !== this.timeoutError) this.lastFailure = error;
+	}
+	throwIfAborted() {
+		if (!this.signal.aborted && performance.now() >= this.deadlineAt) this.controller.abort(this.timeoutError);
+		this.signal.throwIfAborted();
+	}
+	remainingMs(cap = Number.POSITIVE_INFINITY) {
+		this.throwIfAborted();
+		return Math.max(1, Math.min(cap, Math.ceil(this.deadlineAt - performance.now())));
+	}
+	own(cleanup, resource = "resource") {
+		this.cleanups.set(cleanup, resource);
+		if (this.signal.aborted) this.release(cleanup, resource);
+		this.throwIfAborted();
+		return () => this.cleanups.delete(cleanup);
+	}
+	release(cleanup, resource) {
+		this.cleanups.delete(cleanup);
+		const entry = {
+			resource,
+			status: "pending"
+		};
+		this.cleanupResults.push(entry);
+		try {
+			const result = cleanup();
+			return Promise.resolve(result).then(() => {
+				entry.status = "released";
+			}, () => {
+				entry.status = "failed";
+			});
+		} catch {
+			entry.status = "failed";
+			return Promise.resolve();
+		}
+	}
+	async step(factory, options = {}) {
+		this.throwIfAborted();
+		const stage = options.stage;
+		if (stage) this.stage = stage;
+		let removeAbort = () => {};
+		const aborted = new Promise((_resolve, reject) => {
+			const onAbort = () => reject(this.signal.reason);
+			this.signal.addEventListener("abort", onAbort, { once: true });
+			removeAbort = () => this.signal.removeEventListener("abort", onAbort);
+		});
+		const operation = (async () => {
+			this.throwIfAborted();
+			return await factory();
+		})().then(async (value) => {
+			try {
+				this.throwIfAborted();
+			} catch (error) {
+				await options.disposeLate?.(value);
+				throw error;
+			}
+			if (stage) this.lastSuccessfulStage = stage;
+			return value;
+		});
+		if (options.waitForExit) this.pendingExits.add(operation);
+		operation.finally(() => this.pendingExits.delete(operation)).catch(() => {});
+		try {
+			return await Promise.race([operation, aborted]);
+		} finally {
+			removeAbort();
+		}
+	}
+	async phase(timeoutMs, label, factory) {
+		const phase = new OperationLifecycle(this.remainingMs(timeoutMs), label, this.signal);
+		phase.cleanupDeadlineAt = Math.min(this.deadlineAt, phase.deadlineAt + 250);
+		return await this.step(() => phase.run(() => phase.step(() => factory(phase), { waitForExit: true })), {
+			stage: label,
+			waitForExit: true
+		});
+	}
+	async pause(ms) {
+		let timer;
+		try {
+			await this.step(() => new Promise((resolve) => {
+				timer = setTimeout(resolve, Math.min(ms, this.remainingMs()));
+			}));
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	async cleanup() {
+		const pending = [...this.pendingExits, ...[...this.cleanups].map(([cleanup, resource]) => this.release(cleanup, resource))];
+		if (!pending.length) return;
+		if (performance.now() >= this.cleanupDeadlineAt) {
+			await Promise.resolve();
+			return;
+		}
+		let timer;
+		try {
+			await Promise.race([Promise.allSettled(pending), new Promise((resolve) => {
+				timer = setTimeout(resolve, Math.max(0, Math.min(250, this.cleanupDeadlineAt - performance.now())));
+			})]);
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	async run(factory) {
+		let timer;
+		try {
+			timer = setTimeout(() => this.controller.abort(this.timeoutError), this.remainingMs());
+			return await this.step(() => factory(this));
+		} catch (error) {
+			this.controller.abort(error);
+			await this.cleanup();
+			if (error === this.timeoutError && this.lastFailure !== void 0) Object.defineProperty(error, "cause", {
+				value: this.lastFailure,
+				configurable: true
+			});
+			if (error instanceof Error && Object.isExtensible(error)) {
+				const inner = errorDiagnostics.get(error);
+				const operation = {
+					...this.diagnostics,
+					category: classifyOperationError(error),
+					...inner ? { inner } : {}
+				};
+				errorDiagnostics.set(error, operation);
+				Object.assign(error, { operation });
+			}
+			throw error;
+		} finally {
+			clearTimeout(timer);
+			this.detachParent();
+			this.cleanups.clear();
+		}
+	}
+};
+//#endregion
+export { OPERATION_TIMEOUT_CODE, OperationLifecycle, classifyOperationError, isRecoverableOperationError, readWechatLoginState };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@weapp-vite/miniprogram-automator",
   "type": "module",
-  "version": "1.2.23",
+  "version": "1.3.0",
   "description": "完全兼容微信 miniprogram-automator 的现代化替代实现",
   "author": "ice breaker <1324318532@qq.com>",
   "license": "MIT",
@@ -31,6 +31,10 @@
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs"
     },
+    "./operation": {
+      "types": "./dist/operation.d.mts",
+      "import": "./dist/operation.mjs"
+    },
     "./package.json": "./package.json"
   },
   "main": "./dist/index.mjs",
@@ -44,7 +48,7 @@
     "node": "^20.19.0 || >=22.12.0"
   },
   "dependencies": {
-    "@weapp-vite/qr": "1.1.8",
+    "@weapp-vite/qr": "1.1.9",
     "obug": "^3.0.0",
     "ws": "^8.22.0"
   },
@@ -53,15 +57,22 @@
     "registry": "https://registry.npmjs.org"
   },
   "devDependencies": {
-    "@types/ws": "^8.18.1",
+    "@types/ws": "^8.18.2",
     "sharp": "^0.35.5"
   },
+  "tsd": {
+    "compilerOptions": {
+      "module": "NodeNext",
+      "moduleResolution": "NodeNext"
+    }
+  },
   "scripts": {
     "dev": "tsdown -w --sourcemap",
     "build": "tsdown",
     "test": "vitest run --config ./vitest.config.ts",
     "test:dev": "vitest --config ./vitest.config.ts",
-    "test:types": "pnpm build && tsd --files \"test-d/**/*.test-d.ts\"",
+    "test:types": "pnpm build && pnpm run test:types:check",
+    "test:types:check": "tsd --files \"test-d/**/*.test-d.ts\"",
     "typecheck": "tsc --noEmit -p ./tsconfig.json",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix"