@xopcai/xopc 0.0.415 → 0.0.417

package/dist/src/personal-agent/service.js

@@ -1,14 +1,14 @@
 import { getSessionMetadata } from "../storage/sqlite/session-read-repository.js";
 import { init_session_repository, patchSessionMetadata } from "../storage/sqlite/session-repository.js";
-import { init_config_repository, setSessionConfig } from "../storage/sqlite/config-repository.js";
+import { setSessionConfig } from "../storage/sqlite/config-repository.js";
 import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
-import { AgentCatalogService } from "../agent-catalog/service.js";
 import { createConversation, init_conversation_repository } from "../storage/sqlite/conversation-repository.js";
 import { getAvailableModels, init_providers } from "../providers/index.js";
 import { getPersonalAgent, personalAgentId } from "./repository.js";
 import { PERSONAL_MAIN_TOOL_IDS, PERSONAL_READ_TOOL_ALIASES } from "./policy.js";
 import { getModelThinking } from "../providers/model-thinking.js";
 import { personalInstructions } from "./prompts.js";
+import { AgentCatalogService } from "../agent-catalog/service.js";
 import { completePersonalOnboarding } from "./onboarding.js";
 import { z } from "zod";
 //#region src/personal-agent/service.ts
@@ -16,7 +16,6 @@ init_repository();
 init_providers();
 init_conversation_repository();
 init_session_repository();
-init_config_repository();
 const PersonalAppearanceSchema = z.enum([
 	"loopi",
 	"loopi-curious",

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

@@ -0,0 +1 @@
+export declare function runAdb(path: string, args: string[], signal?: AbortSignal, timeout?: number): Promise<Buffer>;

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

@@ -0,0 +1,12 @@
+import { PhoneError, init_contracts } from "./contracts.js";
+import { runPhoneCommandBuffer } from "../process/phone-process.js";
+//#region src/phone/adb-command.ts
+init_contracts();
+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.`);
+	});
+}
+//#endregion
+export { runAdb };

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

@@ -1,6 +1,7 @@
 import { type PhoneApplication, type PhoneTextInputStatus, type DiscoveredPhone, type PhoneAction, type PhoneElement, type PhoneObservation } from './contracts.js';
+import { runAdb } from './adb-command.js';
+export { runAdb } from './adb-command.js';
 export declare function resolveAdbPath(configured?: string, stateDir?: string): string;
-export declare function runAdb(path: string, args: string[], signal?: AbortSignal, timeout?: number): Promise<Buffer>;
 export declare function parseAdbDevices(text: string): DiscoveredPhone[];
 export declare function parsePhoneUi(xml: string): PhoneElement[];
 export declare function parseAndroidLayout(raw: string): PhoneElement[];
@@ -14,6 +15,7 @@ export interface PhoneDriver {
     execute(serial: string, action: PhoneAction, observation: PhoneObservation, signal: AbortSignal, options?: {
         settleMs: number;
         resetTask?: boolean;
+        settingsPage?: 'about-phone';
     }): Promise<void>;
 }
 /** Read only the active native editor, never historical input-method entries. */
@@ -24,7 +26,8 @@ export declare class AdbPhoneDriver implements PhoneDriver {
     private readonly useAndroidCli;
     private readonly readApplications?;
     private readonly pasteText?;
-    constructor(adbPath?: string, command?: typeof runAdb, useAndroidCli?: boolean, readApplications?: (signal: AbortSignal) => Promise<PhoneApplication[]>, pasteText?: (text: string, signal: AbortSignal) => Promise<void>);
+    private readonly readHierarchy?;
+    constructor(adbPath?: string, command?: typeof runAdb, useAndroidCli?: boolean, readApplications?: (signal: AbortSignal) => Promise<PhoneApplication[]>, pasteText?: (text: string, signal: AbortSignal) => Promise<void>, readHierarchy?: (signal: AbortSignal) => Promise<string>);
     textInputStatus(serial: string, signal: AbortSignal): Promise<PhoneTextInputStatus>;
     discover(signal?: AbortSignal): Promise<DiscoveredPhone[]>;
     applications(serial: string, signal: AbortSignal): Promise<PhoneApplication[]>;
@@ -38,5 +41,6 @@ export declare class AdbPhoneDriver implements PhoneDriver {
     execute(serial: string, action: PhoneAction, observation: PhoneObservation, signal: AbortSignal, options?: {
         settleMs: number;
         resetTask?: boolean;
+        settingsPage?: 'about-phone';
     }): Promise<void>;
 }

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

@@ -1,15 +1,17 @@
 import { PhoneError, init_contracts } from "./contracts.js";
-import { runPhoneCommandBuffer, runPhoneCommandText } from "../process/phone-process.js";
+import { runPhoneCommandText } from "../process/phone-process.js";
 import { managedPhoneAdbPath } from "../runtime-tools/phone-dependency-catalog.js";
 import { readScrcpyServer, scrcpyServerPath } from "./scrcpy-assets.js";
+import { runAdb } from "./adb-command.js";
+import { readPhoneForeground } from "./foreground.js";
 import { parsePhoneApplications, phoneApplicationsCommand } from "./applications.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";
+import { DOMParser } from "linkedom";
 //#region src/phone/adb-driver.ts
 init_contracts();
 function resolveAdbPath(configured, stateDir) {
@@ -27,12 +29,6 @@ function resolveAdbPath(configured, stateDir) {
 	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());
@@ -136,12 +132,13 @@ function sameTextEditor(target, node) {
 	return node.focused && Boolean(node.editable) && !node.password && (target.resourceId ? node.resourceId === target.resourceId : node.bounds.every((value, index) => value === target.bounds[index]));
 }
 var AdbPhoneDriver = class {
-	constructor(adbPath = resolveAdbPath(), command = runAdb, useAndroidCli = true, readApplications, pasteText) {
+	constructor(adbPath = resolveAdbPath(), command = runAdb, useAndroidCli = true, readApplications, pasteText, readHierarchy) {
 		this.adbPath = adbPath;
 		this.command = command;
 		this.useAndroidCli = useAndroidCli;
 		this.readApplications = readApplications;
 		this.pasteText = pasteText;
+		this.readHierarchy = readHierarchy;
 	}
 	async textInputStatus(serial, signal) {
 		const androidSdk = Number((await this.shell(serial, ["getprop", "ro.build.version.sdk"], signal)).trim()) || 0;
@@ -184,14 +181,7 @@ var AdbPhoneDriver = class {
 		}
 	}
 	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;
+		return readPhoneForeground(this.command, this.adbPath, serial, signal);
 	}
 	async shell(serial, args, signal) {
 		return (await this.command(this.adbPath, [
@@ -202,6 +192,20 @@ var AdbPhoneDriver = class {
 		], signal)).toString();
 	}
 	async observe(serial, signal) {
+		if (this.readHierarchy) {
+			const xml = await this.readHierarchy(signal);
+			const elements = parsePhoneUi(xml);
+			const app = new DOMParser().parseFromString(xml, "text/xml").querySelector("node")?.getAttribute("package");
+			const observation = await this.capture(serial, signal);
+			if (!app || app !== observation.package) {
+				observation.frame.fill(0);
+				throw new PhoneError("PHONE_FRAME_CHANGED", "Application changed between the UI hierarchy and screenshot; retry");
+			}
+			return {
+				...observation,
+				elements
+			};
+		}
 		let elements = [];
 		const android = this.useAndroidCli ? androidCliPath() : void 0;
 		if (android && process.platform !== "win32") for (let attempt = 0; attempt < 3 && !elements.length; attempt++) {
@@ -218,15 +222,18 @@ var AdbPhoneDriver = class {
 			}
 			if (!elements.length) await setTimeout(350, void 0, { signal });
 		}
-		if (!elements.length) try {
+		if (!elements.length) for (let attempt = 0; attempt < 3; attempt++) try {
 			const path = `/data/local/tmp/xopc-phone-${randomUUID()}.xml`;
 			try {
-				await this.shell(serial, [
+				if (!(await this.shell(serial, [
 					"uiautomator",
 					"dump",
+					"--compressed",
 					path
-				], signal);
-				elements = parsePhoneUi(await this.shell(serial, ["cat", path], signal));
+				], signal)).includes(path)) throw new Error("UI hierarchy dump did not complete");
+				const xml = await this.shell(serial, ["cat", path], signal);
+				if (!xml.includes("<hierarchy") || !xml.includes("</hierarchy>") && !/<hierarchy\b[^>]*\/>/.test(xml)) throw new Error("UI hierarchy dump is incomplete");
+				elements = parsePhoneUi(xml);
 			} finally {
 				await this.shell(serial, [
 					"rm",
@@ -234,9 +241,12 @@ var AdbPhoneDriver = class {
 					path
 				], signal).catch(() => {});
 			}
+			break;
 		} catch (error) {
 			signal.throwIfAborted();
 			if (error instanceof Error && error.message === "PHONE_UI_INVALID") throw error;
+			if (attempt === 2) throw new PhoneError("PHONE_UI_UNAVAILABLE", "Unable to capture the phone UI hierarchy; retry observation before controlling the phone", 502);
+			await setTimeout(1e3, void 0, { signal });
 		}
 		return {
 			...await this.capture(serial, signal),
@@ -324,7 +334,21 @@ var AdbPhoneDriver = class {
 		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 "tapElement": throw new PhoneError("PHONE_SEMANTIC_UNRESOLVED", "Resolve the native element against a fresh observation before dispatch", 409);
 			case "launch": {
+				if (options?.settingsPage) {
+					if (action.package !== "com.android.settings") throw new PhoneError("PHONE_APP_DENIED", "About phone requires the Settings application");
+					const output = await this.shell(serial, [
+						"am",
+						"start",
+						"-a",
+						"android.settings.DEVICE_INFO_SETTINGS",
+						"-p",
+						action.package
+					], signal);
+					if (/Error|Exception/.test(output)) throw new PhoneError("PHONE_LAUNCH_FAILED", "Unable to open About phone");
+					break;
+				}
 				const component = (await this.shell(serial, [
 					"cmd",
 					"package",

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

@@ -0,0 +1,34 @@
+import { Adb } from '@yume-chan/adb';
+/** 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;
+    protected key: Buffer;
+    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>;
+    hierarchy(signal: AbortSignal): Promise<string>;
+    applications(signal: AbortSignal): Promise<import("./contracts.js").PhoneApplication[]>;
+}

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

@@ -0,0 +1,324 @@
+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 { observeAdbConsumption } from "./cloud-adb-writable.js";
+import { protectPhoneCredential } from "./cloud-key-permissions.js";
+import { PHONE_UI_DEX } from "./ui-dump-binary.js";
+import { join } from "node:path";
+import { createPrivateKey, randomUUID } from "node:crypto";
+import { lstat, 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-connection.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 protectPhoneCredential(this.root, true);
+		const id = randomUUID();
+		const path = this.path(id);
+		await writeFile(path, key, {
+			mode: 384,
+			flag: "wx"
+		});
+		try {
+			await protectPhoneCredential(path, false);
+			return id;
+		} catch (error) {
+			await rm(path, { force: true });
+			throw error;
+		}
+	}
+	async load(id) {
+		try {
+			const path = this.path(id);
+			await lstat(path);
+			await protectPhoneCredential(this.root, true);
+			await protectPhoneCredential(path, false);
+			return await readFile(path);
+		} catch (error) {
+			if (error instanceof PhoneError && error.code === "PHONE_KEY_PERMISSIONS") throw error;
+			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: observeAdbConsumption(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 hierarchy(signal) {
+		const combined = AbortSignal.any([signal, AbortSignal.timeout(2e4)]);
+		const abort = () => this.close();
+		combined.addEventListener("abort", abort, { once: true });
+		const remote = `/data/local/tmp/xopc-ui-${randomUUID()}.dex`;
+		try {
+			combined.throwIfAborted();
+			const adb = await this.client();
+			combined.throwIfAborted();
+			const sync = await adb.sync();
+			try {
+				const binary = Buffer.from(PHONE_UI_DEX, "base64");
+				await sync.write({
+					filename: remote,
+					permission: 384,
+					file: new ReadableStream({ start(controller) {
+						controller.enqueue(binary);
+						controller.close();
+					} })
+				});
+			} finally {
+				await sync.dispose();
+			}
+			const result = (await this.command("", [
+				"-s",
+				this.endpoint,
+				"shell",
+				"env",
+				`CLASSPATH=${remote}`,
+				"app_process",
+				"/",
+				"ai.xopc.phone.PhoneUiDump"
+			], combined)).toString();
+			if (!result.includes("<hierarchy") || !result.includes("</hierarchy>")) throw new PhoneError("PHONE_UI_UNAVAILABLE", "Unable to capture the active phone UI hierarchy", 502);
+			return result;
+		} finally {
+			combined.removeEventListener("abort", abort);
+			await this.command("", [
+				"-s",
+				this.endpoint,
+				"shell",
+				"rm",
+				"-f",
+				remote
+			], void 0, 3e3).catch(() => {});
+		}
+	}
+	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(() => {});
+		}
+	}
+};
+//#endregion
+export { CloudAdbConnection, PhoneCloudKeyStore, parseCloudEndpoint, parseCloudPrivateKey };

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

@@ -0,0 +1,3 @@
+import { Consumable, WritableStream } from '@yume-chan/stream-extra';
+/** Observe consumption even when a failed write prevents the producer from awaiting it. */
+export declare function observeAdbConsumption<T>(stream: WritableStream<Consumable<T>>): WritableStream<Consumable<T>>;

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

@@ -0,0 +1,21 @@
+import { WritableStream } from "@yume-chan/stream-extra";
+//#region src/phone/cloud-adb-writable.ts
+/** Observe consumption even when a failed write prevents the producer from awaiting it. */
+function observeAdbConsumption(stream) {
+	const writer = stream.getWriter();
+	writer.closed.catch(() => {});
+	return new WritableStream({
+		write(chunk) {
+			chunk.consumed.catch(() => {});
+			return writer.write(chunk);
+		},
+		close() {
+			return writer.close();
+		},
+		abort(reason) {
+			return writer.abort(reason);
+		}
+	});
+}
+//#endregion
+export { observeAdbConsumption };

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

@@ -1,35 +1,6 @@
-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[]>;
+import { CloudAdbConnection as CloudAdbTransport } from './cloud-adb-connection.js';
+export { parseCloudEndpoint, parseCloudPrivateKey, PhoneCloudKeyStore } from './cloud-adb-connection.js';
+export declare class CloudAdbConnection extends CloudAdbTransport {
     driver(): AdbPhoneDriver;
 }