@xopcai/xopc 0.0.412 → 0.0.414

package/dist/src/phone/app-access.d.ts

@@ -0,0 +1,10 @@
+export type PhoneAppAccess = {
+    appAccess?: 'all' | 'selected';
+    allowedApps: string[];
+};
+/** Preserve legacy allowlists while new connections default to all applications. */
+export declare function phoneAppAccess(device: PhoneAppAccess): 'all' | 'selected';
+export declare function phoneAllowsApp(device: PhoneAppAccess, application: string): boolean;
+export declare function normalizePhoneAppAccess<T extends PhoneAppAccess>(device: T): T & {
+    appAccess: 'all' | 'selected';
+};

package/dist/src/phone/app-access.js

@@ -0,0 +1,21 @@
+import { PhoneError, init_contracts } from "./contracts.js";
+//#region src/phone/app-access.ts
+init_contracts();
+/** Preserve legacy allowlists while new connections default to all applications. */
+function phoneAppAccess(device) {
+	return device.appAccess ?? (device.allowedApps.length ? "selected" : "all");
+}
+function phoneAllowsApp(device, application) {
+	return phoneAppAccess(device) === "all" || device.allowedApps.includes(application);
+}
+function normalizePhoneAppAccess(device) {
+	const appAccess = phoneAppAccess(device);
+	if (appAccess === "selected" && !device.allowedApps.length) throw new PhoneError("PHONE_APPS_REQUIRED", "Select at least one application");
+	return {
+		...device,
+		appAccess,
+		allowedApps: appAccess === "all" ? [] : [...new Set(device.allowedApps)]
+	};
+}
+//#endregion
+export { normalizePhoneAppAccess, phoneAllowsApp, phoneAppAccess };

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

@@ -0,0 +1,4 @@
+import { type PhoneApplication } from './contracts.js';
+export declare function phoneApplicationsCommand(remote: string): string[];
+/** Parse the pinned scrcpy server's app list, including wrapped long labels. */
+export declare function parsePhoneApplications(raw: string): PhoneApplication[];

package/dist/src/phone/applications.js

@@ -0,0 +1,49 @@
+import { PhoneError, init_contracts } from "./contracts.js";
+import { SCRCPY_VERSION } from "../runtime-tools/phone-dependency-catalog.js";
+//#region src/phone/applications.ts
+init_contracts();
+const packageName = /^[a-zA-Z]\w*(?:\.\w+)+$/;
+function phoneApplicationsCommand(remote) {
+	return [
+		"env",
+		`CLASSPATH=${remote}`,
+		"app_process",
+		"/",
+		"com.genymobile.scrcpy.Server",
+		SCRCPY_VERSION,
+		"list_apps=true",
+		"video=false",
+		"audio=false",
+		"control=false"
+	];
+}
+/** Parse the pinned scrcpy server's app list, including wrapped long labels. */
+function parsePhoneApplications(raw) {
+	const text = raw.replace(/\u001b\[[\d;]*m/g, "");
+	if (text.length > 1024 * 1024 || !text.includes("List of apps:")) throw new PhoneError("PHONE_APPS_UNAVAILABLE", "Unable to read the phone application list. Check the phone connection and scrcpy dependency.");
+	const apps = /* @__PURE__ */ new Map();
+	let pending;
+	for (const line of text.split(/\r?\n/)) {
+		const entry = /^\s*[*-]\s+(.+)$/.exec(line);
+		if (entry) {
+			const match = /^(.*?)\s+([a-zA-Z]\w*(?:\.\w+)+)$/.exec(entry[1].trim());
+			if (match) {
+				pending = void 0;
+				apps.set(match[2], {
+					packageName: match[2],
+					label: match[1].trim().slice(0, 120) || match[2]
+				});
+			} else pending = entry[1].trim().slice(0, 120);
+		} else if (pending && packageName.test(line.trim())) {
+			apps.set(line.trim(), {
+				packageName: line.trim(),
+				label: pending
+			});
+			pending = void 0;
+		}
+		if (apps.size > 500) throw new PhoneError("PHONE_APPS_LIMIT", "Phone application list exceeds 500 entries");
+	}
+	return [...apps.values()].sort((a, b) => a.label.localeCompare(b.label));
+}
+//#endregion
+export { parsePhoneApplications, phoneApplicationsCommand };

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

@@ -0,0 +1,35 @@
+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>;
+    applications(signal: AbortSignal): Promise<import("./contracts.js").PhoneApplication[]>;
+    driver(): AdbPhoneDriver;
+}

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

@@ -0,0 +1,273 @@
+import { init_paths, resolveCredentialsDir } from "../config/paths.js";
+import { PhoneError, init_contracts } from "./contracts.js";
+import { readScrcpyServer } from "./scrcpy-assets.js";
+import { parsePhoneApplications, phoneApplicationsCommand } from "./applications.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 CloudAdbConnection {
+	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();
+		}
+	}
+	async applications(signal) {
+		const combined = AbortSignal.any([signal, AbortSignal.timeout(3e4)]);
+		const abort = () => this.close();
+		combined.addEventListener("abort", abort, { once: true });
+		const remote = `/data/local/tmp/xopc-apps-${randomUUID()}.jar`;
+		try {
+			combined.throwIfAborted();
+			const binary = await readScrcpyServer();
+			const adb = await this.client();
+			combined.throwIfAborted();
+			const sync = await adb.sync();
+			try {
+				await sync.write({
+					filename: remote,
+					permission: 384,
+					file: new ReadableStream({ start(controller) {
+						controller.enqueue(binary);
+						controller.close();
+					} })
+				});
+			} finally {
+				await sync.dispose();
+			}
+			return parsePhoneApplications((await this.command("", [
+				"-s",
+				this.endpoint,
+				"shell",
+				...phoneApplicationsCommand(remote)
+			], combined)).toString());
+		} finally {
+			combined.removeEventListener("abort", abort);
+			await this.command("", [
+				"-s",
+				this.endpoint,
+				"shell",
+				"rm",
+				"-f",
+				remote
+			], void 0, 3e3).catch(() => {});
+		}
+	}
+	driver() {
+		return new AdbPhoneDriver("", this.command.bind(this), false, async (signal) => {
+			const listing = new CloudAdbConnection(this.endpoint, Buffer.from(this.key));
+			try {
+				return await listing.applications(signal);
+			} finally {
+				listing.dispose();
+			}
+		});
+	}
+};
+//#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;
+}

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

@@ -0,0 +1,142 @@
+import { PhoneError, init_contracts } from "./contracts.js";
+import { CloudAdbConnection, PhoneCloudKeyStore, parseCloudEndpoint, parseCloudPrivateKey } from "./cloud-adb.js";
+import { CloudScrcpyProvider } from "./cloud-scrcpy.js";
+import { randomUUID } from "node:crypto";
+import sharp from "sharp";
+//#region src/phone/cloud-phones.ts
+init_contracts();
+var CloudPhones = class {
+	drafts = /* @__PURE__ */ new Map();
+	connections = /* @__PURE__ */ new Map();
+	constructor(repository, keys = new PhoneCloudKeyStore(), connect = (endpoint, key) => new CloudAdbConnection(endpoint, key)) {
+		this.repository = repository;
+		this.keys = keys;
+		this.connect = connect;
+	}
+	discard(token) {
+		const draft = this.drafts.get(token);
+		if (draft) {
+			clearTimeout(draft.timer);
+			draft.key.fill(0);
+			this.drafts.delete(token);
+		}
+	}
+	async test(owner, address, pem, signal) {
+		if (this.drafts.size >= 10) throw new PhoneError("PHONE_SETUP_BUSY", "Too many pending phone connections. Try again later.", 409);
+		const { endpoint } = parseCloudEndpoint(address);
+		const key = parseCloudPrivateKey(pem);
+		let lease;
+		try {
+			lease = this.repository.acquire(endpoint);
+		} catch (error) {
+			key.fill(0);
+			throw error;
+		}
+		const connection = this.connect(endpoint, Buffer.from(key));
+		try {
+			const command = (...args) => connection.command("", [
+				"-s",
+				endpoint,
+				...args
+			], signal, 2e4);
+			const model = (await command("shell", "getprop", "ro.product.model")).toString().trim().slice(0, 100);
+			const androidVersion = (await command("shell", "getprop", "ro.build.version.release")).toString().trim().slice(0, 50);
+			const pixels = await command("exec-out", "screencap", "-p");
+			let screenshot;
+			try {
+				screenshot = `data:image/jpeg;base64,${(await sharp(pixels, { limitInputPixels: 16e6 }).resize({
+					width: 360,
+					withoutEnlargement: true
+				}).jpeg({ quality: 70 }).toBuffer()).toString("base64")}`;
+			} finally {
+				pixels.fill(0);
+			}
+			signal.throwIfAborted();
+			const token = randomUUID();
+			const expiresAt = Date.now() + 6e5;
+			const timer = setTimeout(() => this.discard(token), 6e5);
+			timer.unref();
+			this.drafts.set(token, {
+				owner,
+				endpoint,
+				key: Buffer.from(key),
+				expiresAt,
+				timer
+			});
+			return {
+				token,
+				expiresAt,
+				model,
+				androidVersion,
+				screenshot,
+				endpoint,
+				media: "snapshot"
+			};
+		} finally {
+			key.fill(0);
+			connection.dispose();
+			this.repository.release(endpoint, lease);
+		}
+	}
+	async add(owner, token, name, makeDefault) {
+		const draft = this.drafts.get(token);
+		if (!draft || draft.owner !== owner || draft.expiresAt < Date.now()) throw new PhoneError("PHONE_SETUP_EXPIRED", "Connection test expired. Test the connection again.", 409);
+		this.drafts.delete(token);
+		clearTimeout(draft.timer);
+		let credentialId;
+		try {
+			credentialId = await this.keys.save(draft.key);
+			const device = this.repository.save({
+				serial: draft.endpoint,
+				name,
+				enabled: true,
+				appAccess: "all",
+				allowedApps: [],
+				connection: {
+					kind: "aliyun-adb",
+					endpoint: draft.endpoint,
+					credentialId
+				}
+			});
+			if (makeDefault || !this.repository.defaultDevice()) this.repository.setDefault(device.id);
+			return device;
+		} catch (error) {
+			if (credentialId) await this.keys.remove(credentialId);
+			throw error;
+		} finally {
+			draft.key.fill(0);
+		}
+	}
+	cancel(owner, token) {
+		if (this.drafts.get(token)?.owner === owner) this.discard(token);
+	}
+	async driver(device) {
+		const binding = device.connection;
+		if (!binding) throw new PhoneError("PHONE_CONNECTION_INVALID", "Missing cloud connection");
+		let connection = this.connections.get(device.id);
+		if (!connection) {
+			connection = this.connect(binding.endpoint, await this.keys.load(binding.credentialId));
+			this.connections.set(device.id, connection);
+		}
+		return connection.driver();
+	}
+	async interactive(device, failed) {
+		const binding = device.connection;
+		if (!binding) throw new PhoneError("PHONE_CONNECTION_INVALID", "Missing cloud connection");
+		return new CloudScrcpyProvider(binding.endpoint, await this.keys.load(binding.credentialId), failed, this.connect);
+	}
+	disconnect(id) {
+		this.connections.get(id)?.dispose();
+		this.connections.delete(id);
+	}
+	async remove(device) {
+		this.disconnect(device.id);
+		if (device.connection) await this.keys.remove(device.connection.credentialId);
+	}
+	close() {
+		for (const token of this.drafts.keys()) this.discard(token);
+		for (const id of this.connections.keys()) this.disconnect(id);
+	}
+};
+//#endregion
+export { CloudPhones };

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

@@ -0,0 +1,20 @@
+import { CloudAdbConnection } from './cloud-adb.js';
+import { ScrcpyProvider } from './scrcpy.js';
+/** Dedicated authenticated ADB transport: no host ADB key, server or port forwarding. */
+export declare class CloudScrcpyProvider extends ScrcpyProvider {
+    private endpoint;
+    private connection;
+    private process?;
+    private video?;
+    private control?;
+    private writer?;
+    private remote;
+    private scid;
+    constructor(endpoint: string, key: Buffer, onFailure: () => void, connect?: (address: string, credential: Buffer) => CloudAdbConnection);
+    foreground(signal: AbortSignal): Promise<string>;
+    protected startTransport(): Promise<void>;
+    private drain;
+    private readVideo;
+    protected write(buffer: Buffer): Promise<void>;
+    protected cleanup(): Promise<void>;
+}