@yume-chan/adb 0.0.20 → 0.0.22

package/src/daemon/transport.ts

@@ -27,19 +27,34 @@ import { AdbCommand, calculateChecksum } from "./packet.js";
 
 export const ADB_DAEMON_VERSION_OMIT_CHECKSUM = 0x01000001;
 
+export type AdbDaemonConnection = ReadableWritablePair<
+    AdbPacketData,
+    Consumable<AdbPacketInit>
+>;
+
 interface AdbDaemonAuthenticationOptions {
     serial: string;
-    connection: ReadableWritablePair<AdbPacketData, Consumable<AdbPacketInit>>;
+    connection: AdbDaemonConnection;
     credentialStore: AdbCredentialStore;
     authenticators?: AdbAuthenticator[];
+    /**
+     * Whether to preserve the connection open after the `AdbDaemonTransport` is closed.
+     */
+    preserveConnection?: boolean | undefined;
+    debugSlowRead?: boolean | undefined;
 }
 
 interface AdbDaemonSocketConnectorConstructionOptions {
     serial: string;
-    connection: ReadableWritablePair<AdbPacketData, Consumable<AdbPacketInit>>;
+    connection: AdbDaemonConnection;
     version: number;
     maxPayloadSize: number;
     banner: string;
+    /**
+     * Whether to preserve the connection open after the `AdbDaemonTransport` is closed.
+     */
+    preserveConnection?: boolean | undefined;
+    debugSlowRead?: boolean | undefined;
 }
 
 export class AdbDaemonTransport implements AdbTransport {
@@ -51,11 +66,12 @@ export class AdbDaemonTransport implements AdbTransport {
      * on the same connection. Because every time the device receives a `CNXN` packet,
      * it resets all internal state, and starts a new authentication process.
      */
-    public static async authenticate({
+    static async authenticate({
         serial,
         connection,
         credentialStore,
         authenticators = ADB_DEFAULT_AUTHENTICATORS,
+        ...options
     }: AdbDaemonAuthenticationOptions): Promise<AdbDaemonTransport> {
         // Initially, set to highest-supported version and payload size.
         let version = 0x01000001;
@@ -65,7 +81,7 @@ export class AdbDaemonTransport implements AdbTransport {
         const resolver = new PromiseResolver<string>();
         const authProcessor = new AdbAuthenticationProcessor(
             authenticators,
-            credentialStore
+            credentialStore,
         );
 
         // Here is similar to `AdbPacketDispatcher`,
@@ -80,14 +96,13 @@ export class AdbDaemonTransport implements AdbTransport {
                                 version = Math.min(version, packet.arg0);
                                 maxPayloadSize = Math.min(
                                     maxPayloadSize,
-                                    packet.arg1
+                                    packet.arg1,
                                 );
                                 resolver.resolve(decodeUtf8(packet.payload));
                                 break;
                             case AdbCommand.Auth: {
-                                const response = await authProcessor.process(
-                                    packet
-                                );
+                                const response =
+                                    await authProcessor.process(packet);
                                 await sendPacket(response);
                                 break;
                             }
@@ -105,19 +120,19 @@ export class AdbDaemonTransport implements AdbTransport {
                     // Don't cancel the source ReadableStream on AbortSignal abort.
                     preventCancel: true,
                     signal: abortController.signal,
-                }
+                },
             )
             .then(
                 () => {
                     if (resolver.state === "running") {
                         resolver.reject(
-                            new Error("Connection closed unexpectedly")
+                            new Error("Connection closed unexpectedly"),
                         );
                     }
                 },
                 (e) => {
                     resolver.reject(e);
-                }
+                },
             );
 
         const writer = connection.writable.getWriter();
@@ -147,7 +162,7 @@ export class AdbDaemonTransport implements AdbTransport {
                 AdbFeature.AbbExec,
                 "remount_shell",
                 "track_app",
-                "sendrecv_v2",
+                AdbFeature.SendReceiveV2,
                 "sendrecv_v2_brotli",
                 "sendrecv_v2_lz4",
                 "sendrecv_v2_zstd",
@@ -180,43 +195,49 @@ export class AdbDaemonTransport implements AdbTransport {
             version,
             maxPayloadSize,
             banner,
+            ...options,
         });
     }
 
+    #connection: AdbDaemonConnection;
+    get connection() {
+        return this.#connection;
+    }
+
     readonly #dispatcher: AdbPacketDispatcher;
 
     #serial: string;
-    public get serial() {
+    get serial() {
         return this.#serial;
     }
 
     #protocolVersion: number;
-    public get protocolVersion() {
+    get protocolVersion() {
         return this.#protocolVersion;
     }
 
-    #maxPayloadSize: number;
-    public get maxPayloadSize() {
-        return this.#maxPayloadSize;
+    get maxPayloadSize() {
+        return this.#dispatcher.options.maxPayloadSize;
     }
 
     #banner: AdbBanner;
-    public get banner() {
+    get banner() {
         return this.#banner;
     }
 
-    public get disconnected() {
+    get disconnected() {
         return this.#dispatcher.disconnected;
     }
 
-    public constructor({
+    constructor({
         serial,
         connection,
         version,
-        maxPayloadSize,
         banner,
+        ...options
     }: AdbDaemonSocketConnectorConstructionOptions) {
         this.#serial = serial;
+        this.#connection = connection;
         this.#banner = AdbBanner.parse(banner);
 
         let calculateChecksum: boolean;
@@ -232,20 +253,19 @@ export class AdbDaemonTransport implements AdbTransport {
         this.#dispatcher = new AdbPacketDispatcher(connection, {
             calculateChecksum,
             appendNullToServiceString,
-            maxPayloadSize,
+            ...options,
         });
 
         this.#protocolVersion = version;
-        this.#maxPayloadSize = maxPayloadSize;
     }
 
-    public connect(service: string): ValueOrPromise<AdbSocket> {
+    connect(service: string): ValueOrPromise<AdbSocket> {
         return this.#dispatcher.createSocket(service);
     }
 
-    public addReverseTunnel(
+    addReverseTunnel(
         handler: AdbIncomingSocketHandler,
-        address?: string
+        address?: string,
     ): string {
         if (!address) {
             const id = Math.random().toString().substring(2);
@@ -255,15 +275,15 @@ export class AdbDaemonTransport implements AdbTransport {
         return address;
     }
 
-    public removeReverseTunnel(address: string): void {
+    removeReverseTunnel(address: string): void {
         this.#dispatcher.removeReverseTunnel(address);
     }
 
-    public clearReverseTunnels(): void {
+    clearReverseTunnels(): void {
         this.#dispatcher.clearReverseTunnels();
     }
 
-    public close(): ValueOrPromise<void> {
+    close(): ValueOrPromise<void> {
         return this.#dispatcher.close();
     }
 }

package/src/server/client.ts

@@ -3,13 +3,11 @@
 import { PromiseResolver } from "@yume-chan/async";
 import type {
     AbortSignal,
-    Consumable,
     ReadableWritablePair,
     WritableStreamDefaultWriter,
 } from "@yume-chan/stream-extra";
 import {
     BufferedReadableStream,
-    DuplexStreamFactory,
     UnwrapConsumableStream,
     WrapWritableStream,
 } from "@yume-chan/stream-extra";
@@ -25,7 +23,7 @@ import {
     encodeUtf8,
 } from "@yume-chan/struct";
 
-import type { AdbIncomingSocketHandler, AdbSocket } from "../adb.js";
+import type { AdbIncomingSocketHandler, AdbSocket, Closeable } from "../adb.js";
 import { AdbBanner } from "../banner.js";
 import type { AdbFeature } from "../features.js";
 import { NOOP, hexToNumber, numberToHex } from "../utils/index.js";
@@ -37,14 +35,20 @@ export interface AdbServerConnectionOptions {
     signal?: AbortSignal | undefined;
 }
 
-export interface AdbServerConnection {
+export interface AdbServerConnection
+    extends ReadableWritablePair<Uint8Array, Uint8Array>,
+        Closeable {
+    get closed(): Promise<void>;
+}
+
+export interface AdbServerConnector {
     connect(
-        options?: AdbServerConnectionOptions
-    ): ValueOrPromise<ReadableWritablePair<Uint8Array, Uint8Array>>;
+        options?: AdbServerConnectionOptions,
+    ): ValueOrPromise<AdbServerConnection>;
 
     addReverseTunnel(
         handler: AdbIncomingSocketHandler,
-        address?: string
+        address?: string,
     ): ValueOrPromise<string>;
 
     removeReverseTunnel(address: string): ValueOrPromise<void>;
@@ -57,10 +61,8 @@ export interface AdbServerSocket extends AdbSocket {
 }
 
 export type AdbServerDeviceSelector =
-    | {
-          serial: string;
-      }
     | { transportId: bigint }
+    | { serial: string }
     | { usb: true }
     | { tcp: true }
     | undefined;
@@ -74,18 +76,18 @@ export interface AdbServerDevice {
 }
 
 export class AdbServerClient {
-    public static readonly VERSION = 41;
+    static readonly VERSION = 41;
 
-    public readonly connection: AdbServerConnection;
+    readonly connection: AdbServerConnector;
 
-    public constructor(connection: AdbServerConnection) {
+    constructor(connection: AdbServerConnector) {
         this.connection = connection;
     }
 
-    public static readString(stream: ExactReadable): string;
-    public static readString(stream: AsyncExactReadable): PromiseLike<string>;
-    public static readString(
-        stream: ExactReadable | AsyncExactReadable
+    static readString(stream: ExactReadable): string;
+    static readString(stream: AsyncExactReadable): PromiseLike<string>;
+    static readString(
+        stream: ExactReadable | AsyncExactReadable,
     ): string | PromiseLike<string> {
         return SyncPromise.try(() => stream.readExactly(4))
             .then((buffer) => {
@@ -98,9 +100,9 @@ export class AdbServerClient {
             .valueOrPromise();
     }
 
-    public static async writeString(
+    static async writeString(
         writer: WritableStreamDefaultWriter<Uint8Array>,
-        value: string
+        value: string,
     ): Promise<void> {
         const valueBuffer = encodeUtf8(value);
         const buffer = new Uint8Array(4 + valueBuffer.length);
@@ -109,8 +111,8 @@ export class AdbServerClient {
         await writer.write(buffer);
     }
 
-    public static async readOkay(
-        stream: ExactReadable | AsyncExactReadable
+    static async readOkay(
+        stream: ExactReadable | AsyncExactReadable,
     ): Promise<void> {
         const response = decodeUtf8(await stream.readExactly(4));
         if (response === "OKAY") {
@@ -125,38 +127,49 @@ export class AdbServerClient {
         throw new Error(`Unexpected response: ${response}`);
     }
 
-    public async connect(
+    async connect(
         request: string,
-        options?: AdbServerConnectionOptions
-    ): Promise<ReadableWritablePair<Uint8Array, Uint8Array>> {
+        options?: AdbServerConnectionOptions,
+    ): Promise<AdbServerConnection> {
         const connection = await this.connection.connect(options);
 
-        const writer = connection.writable.getWriter();
-        await AdbServerClient.writeString(writer, request);
+        try {
+            const writer = connection.writable.getWriter();
+            await AdbServerClient.writeString(writer, request);
+            writer.releaseLock();
+        } catch (e) {
+            await connection.readable.cancel();
+            await connection.close();
+            throw e;
+        }
 
         const readable = new BufferedReadableStream(connection.readable);
-
         try {
-            // `raceSignal` throws if the signal is aborted,
+            // `raceSignal` throws when the signal is aborted,
             // so the `catch` block can close the connection.
             await raceSignal(
                 () => AdbServerClient.readOkay(readable),
-                options?.signal
+                options?.signal,
             );
 
-            writer.releaseLock();
             return {
                 readable: readable.release(),
                 writable: connection.writable,
+                get closed() {
+                    return connection.closed;
+                },
+                async close() {
+                    await connection.close();
+                },
             };
         } catch (e) {
-            writer.close().catch(NOOP);
-            readable.cancel().catch(NOOP);
+            await readable.cancel().catch(NOOP);
+            await connection.close();
             throw e;
         }
     }
 
-    public async getVersion(): Promise<number> {
+    async getVersion(): Promise<number> {
         const connection = await this.connect("host:version");
         const readable = new BufferedReadableStream(connection.readable);
         try {
@@ -169,22 +182,22 @@ export class AdbServerClient {
         }
     }
 
-    public async validateVersion() {
+    async validateVersion() {
         const version = await this.getVersion();
         if (version !== AdbServerClient.VERSION) {
             throw new Error(
-                `adb server version (${version}) doesn't match this client (${AdbServerClient.VERSION})`
+                `adb server version (${version}) doesn't match this client (${AdbServerClient.VERSION})`,
             );
         }
     }
 
-    public async killServer(): Promise<void> {
+    async killServer(): Promise<void> {
         const connection = await this.connect("host:kill");
         connection.writable.close().catch(NOOP);
         connection.readable.cancel().catch(NOOP);
     }
 
-    public async getServerFeatures(): Promise<AdbFeature[]> {
+    async getServerFeatures(): Promise<AdbFeature[]> {
         const connection = await this.connect("host:host-features");
         const readable = new BufferedReadableStream(connection.readable);
         try {
@@ -196,7 +209,7 @@ export class AdbServerClient {
         }
     }
 
-    public async getDevices(): Promise<AdbServerDevice[]> {
+    async getDevices(): Promise<AdbServerDevice[]> {
         const connection = await this.connect("host:devices-l");
         const readable = new BufferedReadableStream(connection.readable);
         try {
@@ -253,10 +266,7 @@ export class AdbServerClient {
         }
     }
 
-    public formatDeviceService(
-        device: AdbServerDeviceSelector,
-        command: string
-    ) {
+    formatDeviceService(device: AdbServerDeviceSelector, command: string) {
         if (!device) {
             return `host:${command}`;
         }
@@ -282,8 +292,8 @@ export class AdbServerClient {
      * @param device The device selector
      * @returns The transport ID of the selected device, and the features supported by the device.
      */
-    public async getDeviceFeatures(
-        device: AdbServerDeviceSelector
+    async getDeviceFeatures(
+        device: AdbServerDeviceSelector,
     ): Promise<{ transportId: bigint; features: AdbFeature[] }> {
         // Usually the client sends a device command using `connectDevice`,
         // so the command got forwarded and handled by ADB daemon.
@@ -309,9 +319,9 @@ export class AdbServerClient {
      * @param service The service to forward
      * @returns An `AdbServerSocket` that can be used to communicate with the service
      */
-    public async connectDevice(
+    async connectDevice(
         device: AdbServerDeviceSelector,
-        service: string
+        service: string,
     ): Promise<AdbServerSocket> {
         await this.validateVersion();
 
@@ -333,8 +343,18 @@ export class AdbServerClient {
         }
 
         const connection = await this.connect(switchService);
+
+        try {
+            const writer = connection.writable.getWriter();
+            await AdbServerClient.writeString(writer, service);
+            writer.releaseLock();
+        } catch (e) {
+            await connection.readable.cancel();
+            await connection.close();
+            throw e;
+        }
+
         const readable = new BufferedReadableStream(connection.readable);
-        const writer = connection.writable.getWriter();
         try {
             if (transportId === undefined) {
                 const array = await readable.readExactly(8);
@@ -342,39 +362,30 @@ export class AdbServerClient {
                 const dataView = new DataView(
                     array.buffer,
                     array.byteOffset,
-                    array.byteLength
+                    array.byteLength,
                 );
                 transportId = BigIntFieldType.Uint64.getter(dataView, 0, true);
             }
 
-            await AdbServerClient.writeString(writer, service);
             await AdbServerClient.readOkay(readable);
 
-            writer.releaseLock();
-
-            const duplex = new DuplexStreamFactory<
-                Uint8Array,
-                Consumable<Uint8Array>
-            >();
-            const wrapReadable = duplex.wrapReadable(readable.release());
-            const wrapWritable = duplex.createWritable(
-                new WrapWritableStream(connection.writable).bePipedThroughFrom(
-                    new UnwrapConsumableStream()
-                )
-            );
-
             return {
                 transportId,
                 service,
-                readable: wrapReadable,
-                writable: wrapWritable,
-                close() {
-                    return duplex.close();
+                readable: readable.release(),
+                writable: new WrapWritableStream(
+                    connection.writable,
+                ).bePipedThroughFrom(new UnwrapConsumableStream()),
+                get closed() {
+                    return connection.closed;
+                },
+                async close() {
+                    await connection.close();
                 },
             };
         } catch (e) {
-            writer.close().catch(NOOP);
-            readable.cancel().catch(NOOP);
+            await readable.cancel().catch(NOOP);
+            await connection.close();
             throw e;
         }
     }
@@ -386,10 +397,10 @@ export class AdbServerClient {
      * @param options The options
      * @returns A promise that resolves when the condition is met.
      */
-    public async waitFor(
+    async waitFor(
         device: AdbServerDeviceSelector,
         state: "device" | "disconnect",
-        options?: AdbServerConnectionOptions
+        options?: AdbServerConnectionOptions,
     ): Promise<void> {
         let type: string;
         if (!device) {
@@ -410,7 +421,7 @@ export class AdbServerClient {
         // might not be available yet.
         const service = this.formatDeviceService(
             device,
-            `wait-for-${type}-${state}`
+            `wait-for-${type}-${state}`,
         );
 
         // `connect` resolves when server writes `OKAY`,
@@ -418,33 +429,33 @@ export class AdbServerClient {
         await this.connect(service, options);
     }
 
-    public async createTransport(
-        device: AdbServerDeviceSelector
+    async createTransport(
+        device: AdbServerDeviceSelector,
     ): Promise<AdbServerTransport> {
         const { transportId, features } = await this.getDeviceFeatures(device);
 
         const devices = await this.getDevices();
         const info = devices.find(
-            (device) => device.transportId === transportId
+            (device) => device.transportId === transportId,
         );
 
         const banner = new AdbBanner(
             info?.product,
             info?.model,
             info?.device,
-            features
+            features,
         );
 
         return new AdbServerTransport(
             this,
             info?.serial ?? "",
             banner,
-            transportId
+            transportId,
         );
     }
 }
 
-async function raceSignal<T>(
+export async function raceSignal<T>(
     callback: () => Promise<T>,
     ...signals: (AbortSignal | undefined)[]
 ): Promise<T> {

package/src/server/transport.ts

@@ -14,23 +14,23 @@ import type { AdbServerClient } from "./client.js";
 export class AdbServerTransport implements AdbTransport {
     #client: AdbServerClient;
 
-    public readonly serial: string;
+    readonly serial: string;
 
-    public readonly transportId: bigint;
+    readonly transportId: bigint;
 
-    public readonly maxPayloadSize: number = 1 * 1024 * 1024;
+    readonly maxPayloadSize: number = 1 * 1024 * 1024;
 
-    public readonly banner: AdbBanner;
+    readonly banner: AdbBanner;
 
     #closed = new PromiseResolver<void>();
     #waitAbortController = new AbortController();
-    public readonly disconnected: Promise<void>;
+    readonly disconnected: Promise<void>;
 
-    public constructor(
+    constructor(
         client: AdbServerClient,
         serial: string,
         banner: AdbBanner,
-        transportId: bigint
+        transportId: bigint,
     ) {
         this.#client = client;
         this.serial = serial;
@@ -46,27 +46,27 @@ export class AdbServerTransport implements AdbTransport {
         ]);
     }
 
-    public async connect(service: string): Promise<AdbSocket> {
+    async connect(service: string): Promise<AdbSocket> {
         return await this.#client.connectDevice(
             {
                 transportId: this.transportId,
             },
-            service
+            service,
         );
     }
 
-    public async addReverseTunnel(
+    async addReverseTunnel(
         handler: AdbIncomingSocketHandler,
-        address?: string
+        address?: string,
     ): Promise<string> {
         return await this.#client.connection.addReverseTunnel(handler, address);
     }
 
-    public async removeReverseTunnel(address: string): Promise<void> {
+    async removeReverseTunnel(address: string): Promise<void> {
         await this.#client.connection.removeReverseTunnel(address);
     }
 
-    public async clearReverseTunnels(): Promise<void> {
+    async clearReverseTunnels(): Promise<void> {
         await this.#client.connection.clearReverseTunnels();
     }
 

package/src/utils/auto-reset-event.ts

@@ -5,11 +5,11 @@ export class AutoResetEvent implements Disposable {
     #set: boolean;
     readonly #queue: PromiseResolver<void>[] = [];
 
-    public constructor(initialSet = false) {
+    constructor(initialSet = false) {
         this.#set = initialSet;
     }
 
-    public wait(): Promise<void> {
+    wait(): Promise<void> {
         if (!this.#set) {
             this.#set = true;
 
@@ -23,7 +23,7 @@ export class AutoResetEvent implements Disposable {
         return resolver.promise;
     }
 
-    public notifyOne() {
+    notifyOne() {
         if (this.#queue.length !== 0) {
             this.#queue.pop()!.resolve();
         } else {
@@ -31,7 +31,7 @@ export class AutoResetEvent implements Disposable {
         }
     }
 
-    public dispose() {
+    dispose() {
         for (const item of this.#queue) {
             item.reject(new Error("The AutoResetEvent has been disposed"));
         }