@xopcai/xopc 0.0.411 → 0.0.413

package/dist/src/phone/adb-driver.js

@@ -0,0 +1,368 @@
+import { PhoneError, init_contracts } from "./contracts.js";
+import { runPhoneCommandBuffer, runPhoneCommandText } from "../process/phone-process.js";
+import { managedPhoneAdbPath } from "../runtime-tools/phone-dependency-catalog.js";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+import { existsSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { setTimeout } from "node:timers/promises";
+import { DOMParser } from "linkedom";
+import sharp from "sharp";
+//#region src/phone/adb-driver.ts
+init_contracts();
+function resolveAdbPath(configured, stateDir) {
+	if (configured) return configured;
+	const roots = [
+		process.env.ANDROID_HOME,
+		process.env.ANDROID_SDK_ROOT,
+		join(homedir(), "Library/Android/sdk"),
+		join(homedir(), "Android/Sdk")
+	];
+	for (const root of roots) {
+		const candidate = root && join(root, "platform-tools", process.platform === "win32" ? "adb.exe" : "adb");
+		if (candidate && existsSync(candidate)) return candidate;
+	}
+	const managed = managedPhoneAdbPath(stateDir);
+	return existsSync(managed) ? managed : "adb";
+}
+function runAdb(path, args, signal, timeout = 15e3) {
+	signal?.throwIfAborted();
+	return runPhoneCommandBuffer(path, args, signal, timeout).catch(() => {
+		throw new PhoneError(signal?.aborted ? "PHONE_CANCELLED" : "PHONE_ADB_FAILED", signal?.aborted ? "Phone operation stopped" : `ADB command failed (${args.includes("screencap") ? "screenshot" : args.includes("devices") ? "discovery" : "device operation"}). Check ADB, device authorization and connection.`);
+	});
+}
+function parseAdbDevices(text) {
+	return text.split(/\r?\n/).slice(1).flatMap((line) => {
+		const match = /^(\S+)\s+(device|offline|unauthorized|recovery|sideload)\b(.*)$/.exec(line.trim());
+		if (!match) return [];
+		return [{
+			serial: match[1],
+			state: match[2],
+			name: /model:(\S+)/.exec(match[3])?.[1]?.replaceAll("_", " ") ?? match[1],
+			emulator: /^emulator-\d+$/.test(match[1])
+		}];
+	});
+}
+function parsePhoneUi(xml) {
+	const document = new DOMParser().parseFromString(xml.slice(xml.indexOf("<?xml") >= 0 ? xml.indexOf("<?xml") : xml.indexOf("<hierarchy")), "text/xml");
+	return Array.from(document.querySelectorAll("node")).slice(0, 500).flatMap((node) => {
+		const bounds = /^\[(\d+),(\d+)\]\[(\d+),(\d+)\]$/.exec(node.getAttribute("bounds") ?? "");
+		if (!bounds || node.getAttribute("visible-to-user") === "false") return [];
+		const password = node.getAttribute("password") === "true";
+		return [{
+			text: password ? "" : (node.getAttribute("text") ?? "").slice(0, 500),
+			description: password ? "" : (node.getAttribute("content-desc") ?? "").slice(0, 300),
+			resourceId: node.getAttribute("resource-id") ?? "",
+			clickable: node.getAttribute("clickable") === "true",
+			focused: node.getAttribute("focused") === "true",
+			password,
+			editable: /(?:EditText|AutoCompleteTextView)$/.test(node.getAttribute("class") ?? ""),
+			bounds: bounds.slice(1).map(Number)
+		}];
+	});
+}
+function parseAndroidLayout(raw) {
+	const windows = JSON.parse(raw);
+	if (!Array.isArray(windows)) return [];
+	const window = windows.find((item) => item.type === "APPLICATION" && item.focused);
+	if (!window || !Array.isArray(window.content)) return [];
+	return window.content.slice(0, 500).flatMap((node) => {
+		const bounds = /^\[(\d+),(\d+)\]\[(\d+),(\d+)\]$/.exec(String(node.bounds ?? ""));
+		if (!bounds || node.hidden || node["off-screen"]) return [];
+		const interactions = Array.isArray(node.interactions) ? node.interactions.map((value) => String(value).toUpperCase()) : [];
+		const state = Array.isArray(node.state) ? node.state.map((value) => String(value).toUpperCase()) : [];
+		const password = interactions.includes("PASSWORD");
+		return [{
+			text: password ? "" : String(node.text ?? "").slice(0, 500),
+			description: password ? "" : String(node["content-desc"] ?? "").slice(0, 300),
+			resourceId: String(node["resource-id"] ?? ""),
+			clickable: interactions.includes("CLICKABLE"),
+			focused: state.includes("FOCUSED"),
+			password,
+			editable: /(?:EditText|AutoCompleteTextView)$/.test(String(node.class ?? "")),
+			bounds: bounds.slice(1).map(Number)
+		}];
+	});
+}
+function androidCliPath() {
+	const filename = process.platform === "win32" ? "android.cmd" : "android";
+	return (process.env.PATH ?? "").split(delimiter).map((path) => join(path, filename)).find((path) => existsSync(path));
+}
+/** Read only the active native editor, never historical input-method entries. */
+function parseAndroidFocusedEditor(raw, app) {
+	for (const section of raw.split("Input method client state for ").slice(1)) {
+		const client = section.split("Input method service state for ")[0];
+		if (!/\bmActive=true\b/.test(client) || !/\bmServedConnecting=false\b/.test(client)) continue;
+		const view = /^\s*mServedView=((?:[\w.]+\.)?(?:EditText|AutoCompleteTextView))\{([^\s}]+)/m.exec(client);
+		const connection = /^\s*mServedInputConnectionWrapper=([^\n]+)/m.exec(client)?.[1];
+		if (!view || !connection?.includes("finished=false") || !connection.includes("isActive()=true") || !connection.includes(`mServedView=${view[1]}{${view[2]} `)) continue;
+		const editor = /mCurrentTextBoxAttribute:\s*([\s\S]*?)(?=\n\s{0,2}\w|$)/.exec(client)?.[1];
+		const packageName = /\bpackageName=([\w.]+)/.exec(editor ?? "")?.[1];
+		const value = /\binputType=0x([0-9a-f]+)/i.exec(editor ?? "")?.[1];
+		if (packageName !== app || !value) continue;
+		const inputType = Number.parseInt(value, 16);
+		const kind = inputType & 15;
+		const variation = inputType & 4080;
+		if (![
+			1,
+			2,
+			3,
+			4
+		].includes(kind)) continue;
+		return {
+			text: "",
+			description: "",
+			resourceId: "android:active-editor",
+			bounds: [
+				0,
+				0,
+				0,
+				0
+			],
+			clickable: false,
+			focused: true,
+			editable: true,
+			password: kind === 1 ? [
+				128,
+				144,
+				224
+			].includes(variation) : kind === 2 && variation === 16
+		};
+	}
+}
+var AdbPhoneDriver = class {
+	constructor(adbPath = resolveAdbPath(), command = runAdb, useAndroidCli = true) {
+		this.adbPath = adbPath;
+		this.command = command;
+		this.useAndroidCli = useAndroidCli;
+	}
+	async discover(signal) {
+		return parseAdbDevices((await this.command(this.adbPath, ["devices", "-l"], signal)).toString());
+	}
+	async foreground(serial, signal) {
+		const activity = await this.shell(serial, [
+			"sh",
+			"-c",
+			"dumpsys activity activities | grep -m 1 -E \"mResumedActivity|topResumedActivity\""
+		], signal);
+		const app = /(?:mResumedActivity|topResumedActivity)[^\n]*?\s([\w.]+)\//.exec(activity)?.[1];
+		if (!app) throw new PhoneError("PHONE_APP_UNKNOWN", "Unable to identify the foreground app");
+		return app;
+	}
+	async shell(serial, args, signal) {
+		return (await this.command(this.adbPath, [
+			"-s",
+			serial,
+			"shell",
+			...args
+		], signal)).toString();
+	}
+	async observe(serial, signal) {
+		let elements = [];
+		const android = this.useAndroidCli ? androidCliPath() : void 0;
+		if (android && process.platform !== "win32") for (let attempt = 0; attempt < 3 && !elements.length; attempt++) {
+			try {
+				elements = parseAndroidLayout(await runPhoneCommandText(android, [
+					"layout",
+					"--device",
+					serial,
+					"--no-idle",
+					"--flat"
+				], signal));
+			} catch {
+				signal.throwIfAborted();
+			}
+			if (!elements.length) await setTimeout(350, void 0, { signal });
+		}
+		if (!elements.length) try {
+			const path = `/data/local/tmp/xopc-phone-${randomUUID()}.xml`;
+			try {
+				await this.shell(serial, [
+					"uiautomator",
+					"dump",
+					path
+				], signal);
+				elements = parsePhoneUi(await this.shell(serial, ["cat", path], signal));
+			} finally {
+				await this.shell(serial, [
+					"rm",
+					"-f",
+					path
+				], signal).catch(() => {});
+			}
+		} catch (error) {
+			signal.throwIfAborted();
+			if (error instanceof Error && error.message === "PHONE_UI_INVALID") throw error;
+		}
+		return {
+			...await this.capture(serial, signal),
+			elements
+		};
+	}
+	async observeForText(serial, signal) {
+		const observation = await this.capture(serial, signal);
+		try {
+			const editor = parseAndroidFocusedEditor(await this.shell(serial, ["dumpsys", "input_method"], signal), observation.package);
+			if (await this.foreground(serial, signal) !== observation.package) throw new PhoneError("PHONE_FRAME_CHANGED", "Application changed before text input");
+			if (editor) return {
+				...observation,
+				elements: [editor]
+			};
+		} catch (error) {
+			observation.frame.fill(0);
+			throw error;
+		}
+		observation.frame.fill(0);
+		return this.observe(serial, signal);
+	}
+	/** Pixel capture avoids accessibility dumps on the human interaction path. */
+	async capture(serial, signal) {
+		const foreground = async () => {
+			const activity = await this.shell(serial, [
+				"dumpsys",
+				"activity",
+				"activities"
+			], signal);
+			const app = /(?:mResumedActivity|topResumedActivity)[^\n]*?\s([\w.]+)\//.exec(activity)?.[1];
+			if (!app) throw new PhoneError("PHONE_APP_UNKNOWN", "Unable to identify the foreground app");
+			return app;
+		};
+		const app = await foreground();
+		const capturedAt = Date.now();
+		const results = await Promise.allSettled([this.command(this.adbPath, [
+			"-s",
+			serial,
+			"exec-out",
+			"screencap",
+			"-p"
+		], signal), this.shell(serial, ["dumpsys", "input"], signal)]);
+		const pixels = results[0];
+		const display = results[1];
+		if (pixels.status === "rejected") throw pixels.reason;
+		const frame = pixels.value;
+		try {
+			if (display.status === "rejected") throw display.reason;
+			if (await foreground() !== app) throw new PhoneError("PHONE_FRAME_CHANGED", "Application changed while capturing the screen; retry");
+			const info = await sharp(frame, { limitInputPixels: 16e6 }).metadata();
+			if (info.format !== "png" || !info.width || !info.height) throw new Error("Invalid frame");
+			const rotation = Number(/SurfaceOrientation:\s*(\d)/.exec(display.value)?.[1] ?? 0);
+			return {
+				frameId: randomUUID(),
+				capturedAt,
+				width: info.width,
+				height: info.height,
+				rotation,
+				package: app,
+				frame,
+				elements: []
+			};
+		} catch (error) {
+			frame.fill(0);
+			throw error;
+		}
+	}
+	async execute(serial, action, observation, signal, options) {
+		const point = ([x, y]) => [String(Math.min(observation.width - 1, Math.round(x * observation.width / 1e3))), String(Math.min(observation.height - 1, Math.round(y * observation.height / 1e3)))];
+		const input = (args) => this.shell(serial, ["input", ...args], signal);
+		switch (action.type) {
+			case "launch": {
+				const component = (await this.shell(serial, [
+					"cmd",
+					"package",
+					"resolve-activity",
+					"--brief",
+					action.package
+				], signal)).trim().split(/\r?\n/).find((line) => /^[\w.]+\/[\w.$]+$/.test(line));
+				if (!component) throw new PhoneError("PHONE_APP_UNAVAILABLE", "The selected application has no launchable activity");
+				const output = await this.shell(serial, [
+					"am",
+					"start",
+					...options?.resetTask ? ["--activity-clear-top", "--activity-single-top"] : [],
+					"-n",
+					component
+				], signal);
+				if (/Error|Exception/.test(output)) throw new PhoneError("PHONE_LAUNCH_FAILED", "Unable to launch application");
+				break;
+			}
+			case "tap":
+				await input(["tap", ...point(action.point)]);
+				break;
+			case "doubleTap":
+				await input(["tap", ...point(action.point)]);
+				signal.throwIfAborted();
+				await input(["tap", ...point(action.point)]);
+				break;
+			case "longPress": {
+				const p = point(action.point);
+				await input([
+					"swipe",
+					...p,
+					...p,
+					String(action.durationMs)
+				]);
+				break;
+			}
+			case "swipe":
+				await input([
+					"swipe",
+					...point(action.start),
+					...point(action.end),
+					String(action.durationMs)
+				]);
+				break;
+			case "typeText":
+				if (!observation.elements.some((node) => node.focused && node.editable && !node.password)) throw new PhoneError("PHONE_INPUT_NOT_FOCUSED", "Focus a non-password editable field before typing");
+				if (/^[a-zA-Z0-9 .,_@+-]+$/.test(action.text) && !action.text.includes("%")) await input(["text", action.text.replaceAll(" ", "%s")]);
+				else {
+					const previous = (await this.shell(serial, [
+						"settings",
+						"get",
+						"secure",
+						"default_input_method"
+					], signal)).trim();
+					const keyboard = "com.android.adbkeyboard/.AdbIME";
+					if (!(await this.shell(serial, [
+						"ime",
+						"list",
+						"-s"
+					], signal)).split(/\s+/).includes(keyboard)) throw new PhoneError("PHONE_KEYBOARD_REQUIRED", "Unicode input requires ADB Keyboard. Install and enable it on the device first.");
+					try {
+						await this.shell(serial, [
+							"ime",
+							"set",
+							keyboard
+						], signal);
+						const result = await this.shell(serial, [
+							"am",
+							"broadcast",
+							"-a",
+							"ADB_INPUT_B64",
+							"--es",
+							"msg",
+							Buffer.from(action.text).toString("base64")
+						], signal);
+						if (!/Broadcast completed/.test(result)) throw new PhoneError("PHONE_INPUT_FAILED", "Keyboard input was not acknowledged");
+					} finally {
+						if (/^[\w.]+\/[\w.$]+$/.test(previous)) await this.shell(serial, [
+							"ime",
+							"set",
+							previous
+						], AbortSignal.timeout(3e3));
+					}
+				}
+				break;
+			case "home":
+				await input(["keyevent", "KEYCODE_HOME"]);
+				break;
+			case "back":
+				await input(["keyevent", "KEYCODE_BACK"]);
+				break;
+			case "wait":
+				await setTimeout(action.durationMs, void 0, { signal });
+				return;
+		}
+		if (options?.settleMs !== 0) await setTimeout(options?.settleMs ?? 350, void 0, { signal });
+	}
+};
+//#endregion
+export { AdbPhoneDriver, parseAdbDevices, parseAndroidFocusedEditor, parseAndroidLayout, parsePhoneUi, resolveAdbPath, runAdb };

package/dist/src/phone/cloud-adb.d.ts

@@ -0,0 +1,34 @@
+import { Adb } from '@yume-chan/adb';
+import { AdbPhoneDriver } from './adb-driver.js';
+/** Accept only an explicit TCP endpoint, never URLs, paths or ADB commands. */
+export declare function parseCloudEndpoint(value: string): {
+    host: string;
+    port: number;
+    endpoint: string;
+};
+export declare function parseCloudPrivateKey(pem: string): Buffer;
+export declare class PhoneCloudKeyStore {
+    private root;
+    constructor(root?: string);
+    private path;
+    save(key: Buffer): Promise<string>;
+    load(id: string): Promise<Buffer>;
+    remove(id: string): Promise<void>;
+}
+/** Direct daemon transport never starts or modifies the host ADB server. */
+export declare class CloudAdbConnection {
+    readonly endpoint: string;
+    private key;
+    private socket?;
+    private adb?;
+    private pending?;
+    private idle?;
+    constructor(endpoint: string, key: Buffer);
+    close(): void;
+    dispose(): void;
+    /** A dedicated media connection can multiplex sync, video and control sockets. */
+    client(): Promise<Adb>;
+    private open;
+    command(_path: string, args: string[], signal?: AbortSignal, timeout?: number): Promise<Buffer>;
+    driver(): AdbPhoneDriver;
+}

package/dist/src/phone/cloud-adb.js

@@ -0,0 +1,223 @@
+import { init_paths, resolveCredentialsDir } from "../config/paths.js";
+import { PhoneError, init_contracts } from "./contracts.js";
+import { AdbPhoneDriver } from "./adb-driver.js";
+import { join } from "node:path";
+import { createPrivateKey, randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { connect } from "node:net";
+import { Adb, AdbDaemonTransport, AdbPacket, AdbPacketSerializeStream, AdbSignatureAuthenticator } from "@yume-chan/adb";
+import { Consumable, ReadableStream, StructDeserializeStream } from "@yume-chan/stream-extra";
+//#region src/phone/cloud-adb.ts
+init_paths();
+init_contracts();
+/** Accept only an explicit TCP endpoint, never URLs, paths or ADB commands. */
+function parseCloudEndpoint(value) {
+	const match = /^(\[[a-fA-F0-9:]+\]|[a-zA-Z0-9](?:[a-zA-Z0-9.-]*[a-zA-Z0-9])?):([0-9]{1,5})$/.exec(value.trim());
+	if (!match || Number(match[2]) < 1 || Number(match[2]) > 65535) throw new PhoneError("PHONE_ENDPOINT_INVALID", "Enter the cloud ADB address as host:port");
+	return {
+		host: match[1].replace(/^\[|\]$/g, ""),
+		port: Number(match[2]),
+		endpoint: `${match[1].toLowerCase()}:${Number(match[2])}`
+	};
+}
+function parseCloudPrivateKey(pem) {
+	try {
+		if (Buffer.byteLength(pem) > 16384) throw new Error();
+		const key = createPrivateKey(pem);
+		if (key.asymmetricKeyType !== "rsa" || key.asymmetricKeyDetails?.modulusLength !== 2048 || key.asymmetricKeyDetails?.publicExponent !== 65537n) throw new Error();
+		return key.export({
+			format: "der",
+			type: "pkcs8"
+		});
+	} catch {
+		throw new PhoneError("PHONE_KEY_INVALID", "Upload the unencrypted RSA 2048 private adbkey downloaded from the cloud console");
+	}
+}
+var PhoneCloudKeyStore = class {
+	constructor(root = join(resolveCredentialsDir(), "phone-adb")) {
+		this.root = root;
+	}
+	path(id) {
+		if (!/^[0-9a-f-]{36}$/i.test(id)) throw new PhoneError("PHONE_KEY_INVALID", "Invalid phone credential reference");
+		return join(this.root, `${id}.der`);
+	}
+	async save(key) {
+		await mkdir(this.root, {
+			recursive: true,
+			mode: 448
+		});
+		await chmod(this.root, 448);
+		const id = randomUUID();
+		await writeFile(this.path(id), key, {
+			mode: 384,
+			flag: "wx"
+		});
+		return id;
+	}
+	async load(id) {
+		try {
+			return await readFile(this.path(id));
+		} catch {
+			throw new PhoneError("PHONE_KEY_MISSING", "Phone private key is unavailable. Remove this connection and add it again.");
+		}
+	}
+	async remove(id) {
+		await rm(this.path(id), { force: true });
+	}
+};
+/** Direct daemon transport never starts or modifies the host ADB server. */
+var CloudAdbConnection = class {
+	socket;
+	adb;
+	pending;
+	idle;
+	constructor(endpoint, key) {
+		this.endpoint = endpoint;
+		this.key = key;
+		parseCloudEndpoint(endpoint);
+	}
+	close() {
+		clearTimeout(this.idle);
+		this.socket?.destroy();
+		this.socket = void 0;
+		this.adb = void 0;
+	}
+	dispose() {
+		this.close();
+		this.key.fill(0);
+	}
+	/** A dedicated media connection can multiplex sync, video and control sockets. */
+	async client() {
+		if (this.adb) return this.adb;
+		if (this.pending) return this.pending;
+		const opening = this.open();
+		this.pending = opening;
+		try {
+			return await opening;
+		} finally {
+			if (this.pending === opening) this.pending = void 0;
+		}
+	}
+	async open() {
+		const { host, port } = parseCloudEndpoint(this.endpoint);
+		const socket = connect({
+			host,
+			port
+		});
+		this.socket = socket;
+		socket.setNoDelay(true);
+		socket.on("error", () => {});
+		try {
+			await new Promise((resolve, reject) => {
+				socket.once("connect", resolve);
+				socket.once("error", reject);
+				socket.once("close", () => reject(/* @__PURE__ */ new Error("closed")));
+			});
+			const iterator = socket[Symbol.asyncIterator]();
+			const raw = new ReadableStream({
+				async pull(controller) {
+					const next = await iterator.next();
+					if (next.done) controller.close();
+					else controller.enqueue(next.value);
+				},
+				cancel() {
+					socket.destroy();
+				}
+			});
+			const serializer = new AdbPacketSerializeStream();
+			serializer.readable.pipeTo(new Consumable.WritableStream({
+				write(chunk) {
+					return new Promise((resolve, reject) => socket.write(chunk, (error) => error ? reject(error) : resolve()));
+				},
+				close() {
+					socket.destroy();
+				},
+				abort() {
+					socket.destroy();
+				}
+			})).catch(() => {
+				socket.destroy();
+			});
+			const key = this.key;
+			const transport = await AdbDaemonTransport.authenticate({
+				serial: this.endpoint,
+				connection: {
+					readable: raw.pipeThrough(new StructDeserializeStream(AdbPacket)),
+					writable: serializer.writable
+				},
+				credentialStore: {
+					*iterateKeys() {
+						yield {
+							buffer: key,
+							name: "xopc-cloud-phone"
+						};
+					},
+					generateKey() {
+						throw new Error("Key generation disabled");
+					}
+				},
+				authenticators: [AdbSignatureAuthenticator]
+			});
+			if (socket.destroyed) {
+				await transport.close();
+				throw new Error("closed");
+			}
+			const adb = new Adb(transport);
+			this.adb = adb;
+			adb.disconnected.catch(() => {}).finally(() => {
+				if (this.adb === adb) this.close();
+			});
+			return adb;
+		} catch {
+			socket.destroy();
+			throw new PhoneError("PHONE_CLOUD_AUTH_FAILED", "Cloud ADB connection failed. Check address, network access and the bound private key.", 502);
+		}
+	}
+	async command(_path, args, signal, timeout = 15e3) {
+		const combined = AbortSignal.any([...signal ? [signal] : [], AbortSignal.timeout(timeout)]);
+		combined.throwIfAborted();
+		let abort;
+		const cancelled = new Promise((_resolve, reject) => {
+			abort = () => {
+				this.close();
+				reject(new PhoneError("PHONE_CLOUD_TIMEOUT", "Cloud phone connection stopped or timed out. Check its ADB address and network.", 502));
+			};
+			combined.addEventListener("abort", abort, { once: true });
+		});
+		try {
+			return await Promise.race([cancelled, (async () => {
+				const adb = await this.client();
+				if (args[0] === "devices") return Buffer.from(`List of devices attached\n${this.endpoint}\tdevice model:${adb.banner.model ?? "Cloud_Phone"}\n`);
+				if (args[0] !== "-s" || args[1] !== this.endpoint || !["shell", "exec-out"].includes(args[2])) throw new PhoneError("PHONE_CLOUD_COMMAND_INVALID", "Unsupported cloud ADB command");
+				const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+				const channel = await adb.createSocket(`${args[2] === "exec-out" ? "exec" : "shell"}:${args.slice(3).map(quote).join(" ")}`);
+				const chunks = [];
+				let length = 0;
+				try {
+					for await (const chunk of channel.readable) {
+						length += chunk.length;
+						if (length > 16 * 1024 * 1024) throw new Error("Output exceeded");
+						chunks.push(Buffer.from(chunk));
+					}
+					return Buffer.concat(chunks);
+				} finally {
+					await channel.close();
+				}
+			})()]);
+		} catch (error) {
+			this.close();
+			if (error instanceof PhoneError) throw error;
+			throw new PhoneError("PHONE_CLOUD_ADB_FAILED", "Cloud phone operation failed. Reconnect or run diagnostics.", 502);
+		} finally {
+			combined.removeEventListener("abort", abort);
+			clearTimeout(this.idle);
+			this.idle = setTimeout(() => this.close(), 3e4);
+			this.idle.unref();
+		}
+	}
+	driver() {
+		return new AdbPhoneDriver("", this.command.bind(this), false);
+	}
+};
+//#endregion
+export { CloudAdbConnection, PhoneCloudKeyStore, parseCloudEndpoint, parseCloudPrivateKey };

package/dist/src/phone/cloud-phones.d.ts

@@ -0,0 +1,29 @@
+import { CloudAdbConnection, PhoneCloudKeyStore } from './cloud-adb.js';
+import { CloudScrcpyProvider } from './cloud-scrcpy.js';
+import { type PhoneDevice } from './contracts.js';
+import type { PhoneRepository } from './repository.js';
+export declare class CloudPhones {
+    private repository;
+    private keys;
+    private connect;
+    private drafts;
+    private connections;
+    constructor(repository: PhoneRepository, keys?: PhoneCloudKeyStore, connect?: (endpoint: string, key: Buffer) => CloudAdbConnection);
+    private discard;
+    test(owner: string, address: string, pem: string, signal: AbortSignal): Promise<{
+        token: `${string}-${string}-${string}-${string}-${string}`;
+        expiresAt: number;
+        model: string;
+        androidVersion: string;
+        screenshot: string;
+        endpoint: string;
+        media: "snapshot";
+    }>;
+    add(owner: string, token: string, name: string, makeDefault: boolean): Promise<PhoneDevice>;
+    cancel(owner: string, token: string): void;
+    driver(device: PhoneDevice): Promise<import("./adb-driver.js").AdbPhoneDriver>;
+    interactive(device: PhoneDevice, failed: () => void): Promise<CloudScrcpyProvider>;
+    disconnect(id: string): void;
+    remove(device: PhoneDevice): Promise<void>;
+    close(): void;
+}