@xopcai/xopc 0.0.411 → 0.0.413

package/dist/src/phone/scrcpy.d.ts

@@ -0,0 +1,62 @@
+import { SCRCPY_SHA256, SCRCPY_VERSION } from '../runtime-tools/phone-dependency-catalog.js';
+import type { PhoneInteractiveProvider, PhonePointer, PhoneVideoGeometry, PhoneVideoPacket } from './live-provider.js';
+export { SCRCPY_VERSION, SCRCPY_SHA256 };
+export declare const scrcpyServerPath: (stateDir?: string) => string;
+/** The pinned server sends codec metadata followed by bounded, length-prefixed packets. */
+export declare class ScrcpyVideoParser {
+    private buffer;
+    private metadata;
+    push(chunk: Buffer, packet: (packet: PhoneVideoPacket) => void): void;
+}
+export declare function scrcpyTouch(phase: PhonePointer['phase'], x: number, y: number, width: number, height: number): Buffer;
+export declare function readScrcpyServer(): Promise<Buffer>;
+/** Local and cloud transports share geometry, gesture sequencing and revocation. */
+export declare abstract class ScrcpyProvider implements PhoneInteractiveProvider {
+    private onFailure;
+    readonly descriptor: {
+        readonly kind: "scrcpy-h264";
+        readonly protocolVersion: 1;
+        readonly continuousTouch: true;
+        readonly maxPointers: 1;
+    };
+    geometry: PhoneVideoGeometry;
+    protected closing: boolean;
+    private touch?;
+    private listeners;
+    private config?;
+    private opening?;
+    private startResult?;
+    private closeResult?;
+    constructor(onFailure: () => void);
+    abstract foreground(signal: AbortSignal): Promise<string>;
+    protected abstract startTransport(): Promise<void>;
+    protected abstract write(buffer: Buffer): Promise<void>;
+    protected abstract cleanup(): Promise<void>;
+    start(): Promise<void>;
+    protected packet(packet: PhoneVideoPacket): void;
+    subscribe(listener: (packet: PhoneVideoPacket) => void): () => void;
+    pointer(input: PhonePointer): Promise<void>;
+    revoke(): Promise<void>;
+    protected fail(): void;
+    refresh(): void;
+    close(): Promise<void>;
+}
+export declare class LocalScrcpyProvider extends ScrcpyProvider {
+    private adb;
+    private serial;
+    private tuning;
+    private process?;
+    private video?;
+    private control?;
+    private port?;
+    private remote;
+    private scid;
+    constructor(adb: string, serial: string, onFailure: () => void, tuning?: {
+        maxSize: number;
+        bitRate: number;
+    });
+    foreground(signal: AbortSignal): Promise<string>;
+    protected startTransport(): Promise<void>;
+    protected write(buffer: Buffer): Promise<void>;
+    protected cleanup(): Promise<void>;
+}

package/dist/src/phone/scrcpy.js

@@ -0,0 +1,345 @@
+import { PhoneError, init_contracts } from "./contracts.js";
+import { spawnPhoneCommand } from "../process/phone-process.js";
+import { SCRCPY_SHA256, SCRCPY_VERSION, managedScrcpyServerPath } from "../runtime-tools/phone-dependency-catalog.js";
+import { AdbPhoneDriver, runAdb } from "./adb-driver.js";
+import { createHash, randomBytes } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { connect } from "node:net";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { h264ParseConfiguration } from "@yume-chan/scrcpy";
+//#region src/phone/scrcpy.ts
+init_contracts();
+const scrcpyServerPath = managedScrcpyServerPath;
+/** The pinned server sends codec metadata followed by bounded, length-prefixed packets. */
+var ScrcpyVideoParser = class {
+	buffer = Buffer.alloc(0);
+	metadata = false;
+	push(chunk, packet) {
+		if (chunk.length + this.buffer.length > 8 * 1024 * 1024) throw new Error("Scrcpy video buffer exceeded");
+		this.buffer = Buffer.concat([this.buffer, chunk]);
+		if (!this.metadata) {
+			if (this.buffer.length < 12) return;
+			if (this.buffer.readUInt32BE(0) !== 1748121140) throw new Error("Unsupported scrcpy codec");
+			this.buffer = this.buffer.subarray(12);
+			this.metadata = true;
+		}
+		while (this.buffer.length >= 12) {
+			const size = this.buffer.readUInt32BE(8);
+			if (!size || size > 4 * 1024 * 1024) throw new Error("Invalid scrcpy video packet");
+			if (this.buffer.length < size + 12) return;
+			const flags = this.buffer.readBigUInt64BE(0);
+			packet({
+				data: Buffer.from(this.buffer.subarray(12, size + 12)),
+				config: Boolean(flags & 1n << 63n),
+				key: Boolean(flags & 1n << 62n),
+				pts: Number(flags & (1n << 62n) - 1n)
+			});
+			this.buffer = this.buffer.subarray(size + 12);
+		}
+	}
+};
+function scrcpyTouch(phase, x, y, width, height) {
+	const buffer = Buffer.alloc(32);
+	buffer[0] = 2;
+	buffer[1] = {
+		down: 0,
+		up: 1,
+		move: 2,
+		cancel: 3
+	}[phase];
+	buffer.writeBigUInt64BE(0n, 2);
+	buffer.writeInt32BE(Math.min(width - 1, Math.round(x * width / 1e3)), 10);
+	buffer.writeInt32BE(Math.min(height - 1, Math.round(y * height / 1e3)), 14);
+	buffer.writeUInt16BE(width, 18);
+	buffer.writeUInt16BE(height, 20);
+	buffer.writeUInt16BE(phase === "up" || phase === "cancel" ? 0 : 65535, 22);
+	return buffer;
+}
+async function readScrcpyServer() {
+	const binary = await readFile(scrcpyServerPath()).catch(() => {
+		throw new PhoneError("PHONE_VIDEO_SETUP_REQUIRED", "Install scrcpy server in Settings → Phone Use → Dependencies");
+	});
+	if (createHash("sha256").update(binary).digest("hex") !== "7e70323ba7f259649dd4acce97ac4fefbae8102b2c6d91e2e7be613fd5354be0") throw new PhoneError("PHONE_VIDEO_HASH_MISMATCH", "Phone video server checksum mismatch");
+	return binary;
+}
+/** Local and cloud transports share geometry, gesture sequencing and revocation. */
+var ScrcpyProvider = class {
+	descriptor = {
+		kind: "scrcpy-h264",
+		protocolVersion: 1,
+		continuousTouch: true,
+		maxPointers: 1
+	};
+	geometry = {
+		width: 0,
+		height: 0,
+		version: 0,
+		codec: ""
+	};
+	closing = false;
+	touch;
+	listeners = /* @__PURE__ */ new Set();
+	config;
+	opening;
+	startResult;
+	closeResult;
+	constructor(onFailure) {
+		this.onFailure = onFailure;
+	}
+	start() {
+		if (this.closing) return Promise.reject(new PhoneError("PHONE_VIDEO_ENDED", "Phone video ended", 409));
+		if (!this.startResult) {
+			this.opening = this.startTransport();
+			this.startResult = this.opening.catch(async (error) => {
+				await this.close();
+				throw error;
+			});
+		}
+		return this.startResult;
+	}
+	packet(packet) {
+		if (packet.config) {
+			const info = h264ParseConfiguration(packet.data);
+			this.geometry = {
+				width: info.croppedWidth,
+				height: info.croppedHeight,
+				version: this.geometry.version + 1,
+				codec: `avc1.${[
+					info.profileIndex,
+					info.constraintSet,
+					info.levelIndex
+				].map((value) => value.toString(16).padStart(2, "0")).join("")}`
+			};
+			this.config = {
+				...packet,
+				geometry: this.geometry
+			};
+			if (this.touch) this.revoke().catch(() => this.fail());
+		}
+		for (const listener of this.listeners) listener({
+			...packet,
+			geometry: this.geometry
+		});
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		if (this.config) listener(this.config);
+		return () => this.listeners.delete(listener);
+	}
+	async pointer(input) {
+		const { width, height, version } = this.geometry;
+		if (!width || input.geometry !== version) throw new PhoneError("PHONE_GEOMETRY_CHANGED", "Phone geometry changed; start a new gesture", 409);
+		if (input.phase === "down" ? Boolean(this.touch) : !this.touch) throw new PhoneError("PHONE_POINTER_SEQUENCE", "Invalid pointer sequence", 409);
+		await this.write(scrcpyTouch(input.phase, input.x, input.y, width, height));
+		this.touch = input.phase === "up" || input.phase === "cancel" ? void 0 : {
+			x: input.x,
+			y: input.y
+		};
+	}
+	async revoke() {
+		if (!this.touch) return;
+		const point = this.touch;
+		this.touch = void 0;
+		await this.write(scrcpyTouch("cancel", point.x, point.y, this.geometry.width, this.geometry.height));
+	}
+	fail() {
+		if (this.closing) return;
+		this.onFailure();
+		this.close();
+	}
+	refresh() {
+		if (this.geometry.version) this.write(Buffer.from([17])).catch(() => this.fail());
+	}
+	close() {
+		this.closing = true;
+		return this.closeResult ??= (async () => {
+			await this.opening?.catch(() => {});
+			try {
+				await this.cleanup();
+			} finally {
+				this.listeners.clear();
+				this.config = void 0;
+			}
+		})();
+	}
+};
+var LocalScrcpyProvider = class extends ScrcpyProvider {
+	process;
+	video;
+	control;
+	port;
+	remote = "";
+	scid = "";
+	constructor(adb, serial, onFailure, tuning = {
+		maxSize: 960,
+		bitRate: 2e6
+	}) {
+		super(onFailure);
+		this.adb = adb;
+		this.serial = serial;
+		this.tuning = tuning;
+	}
+	foreground(signal) {
+		return new AdbPhoneDriver(this.adb).foreground(this.serial, signal);
+	}
+	async startTransport() {
+		await readScrcpyServer();
+		const scid = randomBytes(4).readUInt32BE() & 2147483647;
+		this.scid = scid.toString(16);
+		const socketName = `scrcpy_${scid.toString(16).padStart(8, "0")}`;
+		this.remote = `/data/local/tmp/xopc-scrcpy-${socketName}.jar`;
+		try {
+			await runAdb(this.adb, [
+				"-s",
+				this.serial,
+				"push",
+				scrcpyServerPath(),
+				this.remote
+			]);
+			if (this.closing) throw new Error("Video closed");
+			this.port = (await runAdb(this.adb, [
+				"-s",
+				this.serial,
+				"forward",
+				"tcp:0",
+				`localabstract:${socketName}`
+			])).toString().trim();
+			if (!/^\d+$/.test(this.port)) throw new Error("Invalid ADB forwarding port");
+			if (this.closing) throw new Error("Video closed");
+			this.process = spawnPhoneCommand(this.adb, [
+				"-s",
+				this.serial,
+				"shell",
+				`CLASSPATH=${this.remote}`,
+				"app_process",
+				"/",
+				"com.genymobile.scrcpy.Server",
+				SCRCPY_VERSION,
+				`scid=${scid.toString(16)}`,
+				"tunnel_forward=true",
+				"audio=false",
+				"control=true",
+				"cleanup=false",
+				`max_size=${this.tuning.maxSize}`,
+				"max_fps=30",
+				`video_bit_rate=${this.tuning.bitRate}`,
+				"video_codec=h264",
+				"video_codec_options=i-frame-interval=1",
+				"send_dummy_byte=true",
+				"send_device_meta=false",
+				"send_codec_meta=true",
+				"send_frame_meta=true",
+				"clipboard_autosync=false"
+			]);
+			this.process.once("error", () => this.fail());
+			this.process.once("exit", () => this.fail());
+			for (let attempt = 0; attempt < 60; attempt++) {
+				if (this.closing) throw new Error("Video closed");
+				const socket = connect({
+					host: "127.0.0.1",
+					port: Number(this.port)
+				});
+				if (await new Promise((resolve) => {
+					const timer = setTimeout(() => {
+						socket.destroy();
+						resolve(false);
+					}, 250);
+					socket.once("error", () => {
+						clearTimeout(timer);
+						resolve(false);
+					});
+					socket.once("end", () => {
+						clearTimeout(timer);
+						resolve(false);
+					});
+					socket.once("data", (data) => {
+						clearTimeout(timer);
+						if (data.length !== 1 || data[0] !== 0) {
+							socket.destroy();
+							resolve(false);
+						} else resolve(true);
+					});
+				})) {
+					this.video = socket;
+					break;
+				}
+				socket.destroy();
+				await setTimeout$1(50);
+			}
+			if (!this.video) throw new Error("Scrcpy connection timed out");
+			const parser = new ScrcpyVideoParser();
+			this.video.on("data", (data) => {
+				try {
+					parser.push(Buffer.from(data), (packet) => this.packet(packet));
+				} catch {
+					this.fail();
+				}
+			});
+			this.video.on("error", () => this.fail());
+			this.video.on("end", () => this.fail());
+			this.control = connect({
+				host: "127.0.0.1",
+				port: Number(this.port)
+			});
+			this.control.setNoDelay(true);
+			this.control.on("error", () => this.fail());
+			this.control.on("end", () => this.fail());
+			this.control.on("data", () => {});
+			await new Promise((resolve, reject) => {
+				this.control.once("connect", resolve);
+				this.control.once("error", reject);
+			});
+		} catch (error) {
+			throw error;
+		}
+	}
+	async write(buffer) {
+		if (!this.control || this.control.destroyed || this.control.writableLength > 64 * 1024) throw new PhoneError("PHONE_INPUT_DISCONNECTED", "Phone input channel unavailable");
+		await new Promise((resolve, reject) => this.control.write(buffer, (error) => error ? reject(error) : resolve()));
+	}
+	async cleanup() {
+		await this.revoke().catch(() => {});
+		this.video?.destroy();
+		this.control?.destroy();
+		this.process?.kill();
+		if (this.scid) {
+			const processes = await runAdb(this.adb, [
+				"-s",
+				this.serial,
+				"shell",
+				"ps",
+				"-A",
+				"-o",
+				"PID,ARGS"
+			]).catch(() => Buffer.alloc(0));
+			for (const line of processes.toString().split("\n")) {
+				const pid = /^\s*(\d+)\s+/.exec(line)?.[1];
+				if (pid && line.includes("com.genymobile.scrcpy.Server ") && new RegExp(`(?:^|\\s)scid=${this.scid}(?:\\s|$)`).test(line)) await runAdb(this.adb, [
+					"-s",
+					this.serial,
+					"shell",
+					"kill",
+					"-TERM",
+					pid
+				]).catch(() => {});
+			}
+		}
+		if (this.port) await runAdb(this.adb, [
+			"-s",
+			this.serial,
+			"forward",
+			"--remove",
+			`tcp:${this.port}`
+		]).catch(() => {});
+		if (this.remote) await runAdb(this.adb, [
+			"-s",
+			this.serial,
+			"shell",
+			"rm",
+			"-f",
+			this.remote
+		]).catch(() => {});
+	}
+};
+//#endregion
+export { LocalScrcpyProvider, SCRCPY_SHA256, SCRCPY_VERSION, ScrcpyProvider, ScrcpyVideoParser, readScrcpyServer, scrcpyServerPath, scrcpyTouch };

package/dist/src/phone/stream-gateway.d.ts

@@ -0,0 +1,26 @@
+import type { IncomingMessage } from 'node:http';
+import type { Socket } from 'node:net';
+import type { PhoneInteractiveSession } from './interactive-session.js';
+type Claim = {
+    origin: string;
+    principal: string;
+    expiresAt: number;
+    client: string;
+    connect: () => Promise<PhoneInteractiveSession>;
+    validate: () => Promise<void>;
+    disconnect: () => Promise<void>;
+};
+export declare class PhoneStreamGateway {
+    private principalActive;
+    private tickets;
+    private wss;
+    constructor(principalActive?: (principal: string) => boolean);
+    issue(claim: Omit<Claim, 'expiresAt'>): {
+        ticket: string;
+        path: string;
+    };
+    handleUpgrade(req: IncomingMessage, socket: Socket, head: Buffer): boolean;
+    private connection;
+    close(): void;
+}
+export {};

package/dist/src/phone/stream-gateway.js

@@ -0,0 +1,210 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { PhoneError, init_contracts } from "./contracts.js";
+import { PhonePointerSchema } from "./live-provider.js";
+import { createRequire } from "node:module";
+import { createHash, randomBytes } from "node:crypto";
+import { z } from "zod";
+//#region src/phone/stream-gateway.ts
+init_contracts();
+init_logger();
+const log = createLogger("PhoneStream");
+const { WebSocketServer } = createRequire(import.meta.url)("ws");
+const hash = (value) => createHash("sha256").update(value).digest("hex");
+const releaseSchema = z.object({
+	type: z.literal("cancelPointers"),
+	epoch: z.number().int().positive()
+}).strict();
+var PhoneStreamGateway = class {
+	tickets = /* @__PURE__ */ new Map();
+	wss = new WebSocketServer({
+		noServer: true,
+		maxPayload: 16 * 1024,
+		perMessageDeflate: false,
+		handleProtocols: (protocols) => protocols.has("xopc-phone-v1") ? "xopc-phone-v1" : false
+	});
+	constructor(principalActive = () => true) {
+		this.principalActive = principalActive;
+	}
+	issue(claim) {
+		for (const [key, value] of this.tickets) if (value.expiresAt < Date.now()) this.tickets.delete(key);
+		if (this.tickets.size >= 100) throw new PhoneError("PHONE_VIEW_BUSY", "Too many pending phone viewers", 409);
+		const ticket = randomBytes(32).toString("base64url");
+		this.tickets.set(hash(ticket), {
+			...claim,
+			expiresAt: Date.now() + 3e4
+		});
+		return {
+			ticket,
+			path: "/api/phone/live/v1/ws"
+		};
+	}
+	handleUpgrade(req, socket, head) {
+		if (new URL(req.url ?? "/", "http://gateway.local").pathname !== "/api/phone/live/v1/ws") return false;
+		const protocols = (req.headers["sec-websocket-protocol"] ?? "").split(",").map((value) => value.trim());
+		const key = hash(protocols.find((value) => /^[\w-]{43}$/.test(value)) ?? "");
+		const claim = this.tickets.get(key);
+		this.tickets.delete(key);
+		if (!protocols.includes("xopc-phone-v1") || !claim || claim.expiresAt < Date.now() || req.headers.origin !== claim.origin || !this.principalActive(claim.principal) || this.wss.clients.size >= 16) {
+			socket.destroy();
+			return true;
+		}
+		this.wss.handleUpgrade(req, socket, head, (ws) => {
+			this.connection(ws, claim);
+		});
+		return true;
+	}
+	async connection(ws, claim) {
+		let stream;
+		let unsubscribe;
+		let disposed = false;
+		let validating = false;
+		let lastSeen = Date.now();
+		let lastFault = "";
+		let packets = 0;
+		let windowAt = Date.now();
+		let events = 0;
+		const send = (body) => {
+			if (ws.readyState === ws.OPEN) ws.send(JSON.stringify(body));
+		};
+		const fail = (code) => {
+			if (code !== lastFault) send({
+				type: "fault",
+				code
+			});
+			lastFault = code;
+		};
+		const timer = setInterval(() => {
+			if (disposed) return;
+			if (!this.principalActive(claim.principal) || Date.now() - lastSeen > 12e3) {
+				ws.close(4401, "Viewer expired");
+				return;
+			}
+			if (ws.readyState === ws.OPEN) ws.ping();
+			if (!validating) {
+				validating = true;
+				claim.validate().catch(() => ws.close(4403, "Phone access changed")).finally(() => {
+					validating = false;
+				});
+			}
+		}, 2e3);
+		const cleanup = async () => {
+			if (disposed) return;
+			disposed = true;
+			clearInterval(timer);
+			unsubscribe?.();
+			await claim.disconnect().catch(() => {});
+		};
+		ws.on("error", () => ws.terminate());
+		ws.once("close", () => {
+			cleanup();
+		});
+		ws.on("pong", () => {
+			lastSeen = Date.now();
+		});
+		ws.on("message", (bytes, binary) => {
+			try {
+				if (binary) throw new Error("Unexpected binary input");
+				const input = JSON.parse(bytes.toString());
+				if (input.type === "ping") {
+					lastSeen = Date.now();
+					send({ type: "pong" });
+					return;
+				}
+				if (!stream || disposed) throw new Error("Phone video not ready");
+				const cancel = releaseSchema.safeParse(input);
+				if (cancel.success) {
+					stream.authorizeClient(claim.client, cancel.data.epoch);
+					stream.revoke().catch(() => ws.close(4411, "Touch release failed"));
+					return;
+				}
+				const pointer = PhonePointerSchema.parse(input);
+				if (Date.now() - windowAt > 1e3) {
+					windowAt = Date.now();
+					events = 0;
+				}
+				if (++events > 120) throw new Error("Input rate exceeded");
+				lastSeen = Date.now();
+				const startedAt = performance.now();
+				stream.input(claim.client, pointer).then(() => send({
+					type: "ack",
+					seq: pointer.seq,
+					phase: "transport-written",
+					durationMs: performance.now() - startedAt
+				}), (error) => {
+					const code = error instanceof PhoneError ? error.code : "PHONE_INPUT_FAILED";
+					log.warn({
+						phase: "input_dispatch",
+						errorCode: code
+					}, "Phone input channel closed after refused input");
+					fail(code);
+					ws.close(4409, "Input rejected");
+				});
+			} catch (error) {
+				const code = error instanceof PhoneError ? error.code : "PHONE_INVALID_INPUT";
+				log.info({
+					phase: "input_validation",
+					errorCode: code,
+					issues: error instanceof z.ZodError ? error.issues.map((issue) => ({
+						path: issue.path.join("."),
+						code: issue.code
+					})) : void 0
+				}, "Phone input refused");
+				fail(code);
+				ws.close(4400, "Invalid input");
+			}
+		});
+		try {
+			await claim.validate();
+			stream = await claim.connect();
+			if (disposed || ws.readyState !== ws.OPEN) {
+				await claim.disconnect();
+				return;
+			}
+			send({
+				type: "ready",
+				descriptor: stream.provider.descriptor
+			});
+			unsubscribe = stream.subscribe(claim.client, (packet) => {
+				if (ws.readyState !== ws.OPEN) return;
+				if (ws.bufferedAmount > 1024 * 1024) {
+					ws.close(4408, "Video consumer too slow");
+					return;
+				}
+				const geometry = packet.geometry ?? stream.provider.geometry;
+				if (packet.config) send({
+					type: "geometry",
+					...geometry
+				});
+				const header = Buffer.alloc(32);
+				header[0] = (packet.config ? 1 : 0) | (packet.key ? 2 : 0);
+				header.writeUInt32BE(geometry.version, 4);
+				header.writeUInt16BE(geometry.width, 8);
+				header.writeUInt16BE(geometry.height, 10);
+				header.writeBigUInt64BE(BigInt(packet.pts), 12);
+				header.writeDoubleBE(Date.now(), 20);
+				header.writeUInt32BE(++packets, 28);
+				lastFault = "";
+				ws.send(Buffer.concat([header, packet.data]));
+			}, (code) => {
+				fail(code);
+				if (code === "PHONE_VIDEO_ENDED") ws.close(1e3, "Phone session ended");
+			});
+		} catch (error) {
+			const code = error instanceof PhoneError ? error.code : "PHONE_VIDEO_FAILED";
+			fail(code);
+			log.info({
+				phase: "stream_start",
+				errorCode: code
+			}, "Phone video unavailable");
+			ws.close(4411, "Phone video unavailable");
+		}
+	}
+	close() {
+		this.tickets.clear();
+		for (const ws of this.wss.clients) ws.terminate();
+		this.wss.close();
+	}
+};
+//#endregion
+export { PhoneStreamGateway };

package/dist/src/process/phone-process.d.ts

@@ -0,0 +1,4 @@
+import { type ChildProcess } from 'node:child_process';
+export declare function runPhoneCommandBuffer(program: string, args: string[], signal?: AbortSignal, timeoutMs?: number): Promise<Buffer>;
+export declare function runPhoneCommandText(program: string, args: string[], signal: AbortSignal): Promise<string>;
+export declare function spawnPhoneCommand(program: string, args: string[]): ChildProcess;

package/dist/src/process/phone-process.js

@@ -0,0 +1,38 @@
+import { execFile, spawn } from "node:child_process";
+//#region src/process/phone-process.ts
+function runPhoneCommandBuffer(program, args, signal, timeoutMs = 15e3) {
+	signal?.throwIfAborted();
+	return new Promise((resolve, reject) => {
+		execFile(program, args, {
+			encoding: "buffer",
+			maxBuffer: 16 * 1024 * 1024,
+			timeout: timeoutMs,
+			signal,
+			windowsHide: true
+		}, (error, stdout) => error ? reject(error) : resolve(stdout));
+	});
+}
+function runPhoneCommandText(program, args, signal) {
+	signal.throwIfAborted();
+	return new Promise((resolve, reject) => {
+		execFile(program, args, {
+			encoding: "utf8",
+			maxBuffer: 1024 * 1024,
+			timeout: 1e4,
+			signal,
+			windowsHide: true
+		}, (error, stdout) => error ? reject(error) : resolve(stdout));
+	});
+}
+function spawnPhoneCommand(program, args) {
+	return spawn(program, args, {
+		stdio: [
+			"ignore",
+			"ignore",
+			"ignore"
+		],
+		windowsHide: true
+	});
+}
+//#endregion
+export { runPhoneCommandBuffer, runPhoneCommandText, spawnPhoneCommand };