@yume-chan/adb 0.0.23 → 0.0.24

package/esm/server/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/server/client.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/server/client.ts"],"names":[],"mappings":"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"}

package/esm/server/client.js

@@ -1,95 +1,144 @@
 // cspell:ignore tport
 import { PromiseResolver } from "@yume-chan/async";
-import { BufferedReadableStream, UnwrapConsumableStream, WrapWritableStream, } from "@yume-chan/stream-extra";
-import { BigIntFieldType, EMPTY_UINT8_ARRAY, SyncPromise, decodeUtf8, encodeUtf8, } from "@yume-chan/struct";
+import { getUint64LittleEndian } from "@yume-chan/no-data-view";
+import { BufferedReadableStream, MaybeConsumable, WrapWritableStream, } from "@yume-chan/stream-extra";
+import { EMPTY_UINT8_ARRAY, SyncPromise, decodeUtf8, encodeUtf8, } from "@yume-chan/struct";
 import { AdbBanner } from "../banner.js";
-import { NOOP, hexToNumber, numberToHex, unreachable } from "../utils/index.js";
+import { NOOP, hexToNumber, sequenceEqual, write4HexDigits, } from "../utils/index.js";
 import { AdbServerTransport } from "./transport.js";
-export class AdbServerClient {
-    static VERSION = 41;
-    connection;
+const OKAY = encodeUtf8("OKAY");
+const FAIL = encodeUtf8("FAIL");
+class AdbServerStream {
+    #connection;
+    #buffered;
+    #writer;
     constructor(connection) {
-        this.connection = connection;
+        this.#connection = connection;
+        this.#buffered = new BufferedReadableStream(connection.readable);
+        this.#writer = connection.writable.getWriter();
+    }
+    readExactly(length) {
+        return this.#buffered.readExactly(length);
     }
-    static readString(stream) {
-        return SyncPromise.try(() => stream.readExactly(4))
+    readString() {
+        return SyncPromise.try(() => this.readExactly(4))
             .then((buffer) => {
             const length = hexToNumber(buffer);
             if (length === 0) {
                 return EMPTY_UINT8_ARRAY;
             }
             else {
-                return stream.readExactly(length);
+                return this.readExactly(length);
             }
         })
-            .then((valueBuffer) => {
-            return decodeUtf8(valueBuffer);
+            .then((buffer) => {
+            // TODO: Investigate using stream mode `TextDecoder` for long strings.
+            // Because concatenating strings uses rope data structure,
+            // which only points to the original strings and doesn't copy the data,
+            // it's more efficient than concatenating `Uint8Array`s.
+            //
+            // ```
+            // const decoder = new TextDecoder();
+            // let result = '';
+            // for await (const chunk of stream.iterateExactly(length)) {
+            //     result += decoder.decode(chunk, { stream: true });
+            // }
+            // result += decoder.decode();
+            // return result;
+            // ```
+            //
+            // Although, it will be super complex to use `SyncPromise` with async iterator,
+            // `stream.iterateExactly` need to return an
+            // `Iterator<Uint8Array | Promise<Uint8Array>>` instead of a true async iterator.
+            // Maybe `SyncPromise` should support async iterators directly.
+            return decodeUtf8(buffer);
         })
             .valueOrPromise();
     }
-    static async writeString(writer, value) {
-        const valueBuffer = encodeUtf8(value);
-        const buffer = new Uint8Array(4 + valueBuffer.length);
-        buffer.set(numberToHex(valueBuffer.length));
-        buffer.set(valueBuffer, 4);
-        await writer.write(buffer);
+    async writeString(value) {
+        // TODO: investigate using `encodeUtf8("0000" + value)` then modifying the length
+        // That way allocates a new string (hopefully only a rope) instead of a new buffer
+        const encoded = encodeUtf8(value);
+        const buffer = new Uint8Array(4 + encoded.length);
+        write4HexDigits(buffer, 0, encoded.length);
+        buffer.set(encoded, 4);
+        await this.#writer.write(buffer);
     }
-    static async readOkay(stream) {
-        const response = decodeUtf8(await stream.readExactly(4));
-        if (response === "OKAY") {
+    async readOkay() {
+        const response = await this.readExactly(4);
+        if (sequenceEqual(response, OKAY)) {
+            // `OKAY` is followed by data length and data
+            // But different services want to parse the data differently
+            // So don't read the data here
             return;
         }
-        if (response === "FAIL") {
-            const reason = await AdbServerClient.readString(stream);
+        if (sequenceEqual(response, FAIL)) {
+            const reason = await this.readString();
             throw new Error(reason);
         }
-        throw new Error(`Unexpected response: ${response}`);
+        throw new Error(`Unexpected response: ${decodeUtf8(response)}`);
+    }
+    release() {
+        this.#writer.releaseLock();
+        return {
+            readable: this.#buffered.release(),
+            writable: this.#connection.writable,
+            closed: this.#connection.closed,
+            close: () => this.#connection.close(),
+        };
     }
-    async connect(request, options) {
-        const connection = await this.connection.connect(options);
+    async dispose() {
+        await this.#buffered.cancel().catch(NOOP);
+        await this.#writer.close().catch(NOOP);
         try {
-            const writer = connection.writable.getWriter();
-            await AdbServerClient.writeString(writer, request);
-            writer.releaseLock();
+            await this.#connection.close();
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+export class AdbServerClient {
+    static VERSION = 41;
+    connector;
+    wireless = new AdbServerClient.WirelessCommands(this);
+    mDns = new AdbServerClient.MDnsCommands(this);
+    constructor(connection) {
+        this.connector = connection;
+    }
+    async createConnection(request, options) {
+        const connection = await this.connector.connect(options);
+        const stream = new AdbServerStream(connection);
+        try {
+            await stream.writeString(request);
         }
         catch (e) {
-            await connection.readable.cancel();
-            await connection.close();
+            await stream.dispose();
             throw e;
         }
-        const readable = new BufferedReadableStream(connection.readable);
         try {
             // `raceSignal` throws when the signal is aborted,
             // so the `catch` block can close the connection.
-            await raceSignal(() => AdbServerClient.readOkay(readable), options?.signal);
-            return {
-                readable: readable.release(),
-                writable: connection.writable,
-                get closed() {
-                    return connection.closed;
-                },
-                async close() {
-                    await connection.close();
-                },
-            };
+            await raceSignal(() => stream.readOkay(), options?.signal);
+            return stream;
         }
         catch (e) {
-            await readable.cancel().catch(NOOP);
-            await connection.close();
+            await stream.dispose();
             throw e;
         }
     }
+    /**
+     * `adb version`
+     */
     async getVersion() {
-        const connection = await this.connect("host:version");
-        const readable = new BufferedReadableStream(connection.readable);
+        const connection = await this.createConnection("host:version");
         try {
-            const length = hexToNumber(await readable.readExactly(4));
-            const version = hexToNumber(await readable.readExactly(length));
+            const length = hexToNumber(await connection.readExactly(4));
+            const version = hexToNumber(await connection.readExactly(length));
             return version;
         }
         finally {
-            connection.writable.close().catch(NOOP);
-            readable.cancel().catch(NOOP);
+            await connection.dispose();
         }
     }
     async validateVersion() {
@@ -98,21 +147,24 @@ export class AdbServerClient {
             throw new Error(`adb server version (${version}) doesn't match this client (${AdbServerClient.VERSION})`);
         }
     }
+    /**
+     * `adb kill-server`
+     */
     async killServer() {
-        const connection = await this.connect("host:kill");
-        connection.writable.close().catch(NOOP);
-        connection.readable.cancel().catch(NOOP);
+        const connection = await this.createConnection("host:kill");
+        await connection.dispose();
     }
+    /**
+     * `adb host-features`
+     */
     async getServerFeatures() {
-        const connection = await this.connect("host:host-features");
-        const readable = new BufferedReadableStream(connection.readable);
+        const connection = await this.createConnection("host:host-features");
         try {
-            const response = await AdbServerClient.readString(readable);
+            const response = await connection.readString();
             return response.split(",");
         }
         finally {
-            connection.writable.close().catch(NOOP);
-            readable.cancel().catch(NOOP);
+            await connection.dispose();
         }
     }
     parseDeviceList(value) {
@@ -124,7 +176,7 @@ export class AdbServerClient {
             const parts = line.split(" ").filter(Boolean);
             const serial = parts[0];
             const status = parts[1];
-            if (status !== "device") {
+            if (status !== "device" && status !== "unauthorized") {
                 continue;
             }
             let product;
@@ -153,6 +205,7 @@ export class AdbServerClient {
             }
             devices.push({
                 serial,
+                authenticating: status === "unauthorized",
                 product,
                 model,
                 device,
@@ -161,39 +214,43 @@ export class AdbServerClient {
         }
         return devices;
     }
+    /**
+     * `adb devices -l`
+     */
     async getDevices() {
-        const connection = await this.connect("host:devices-l");
-        const readable = new BufferedReadableStream(connection.readable);
+        const connection = await this.createConnection("host:devices-l");
         try {
-            const response = await AdbServerClient.readString(readable);
+            const response = await connection.readString();
             return this.parseDeviceList(response);
         }
         finally {
-            connection.writable.close().catch(NOOP);
-            readable.cancel().catch(NOOP);
+            await connection.dispose();
         }
     }
-    async trackDevices(callback) {
-        const connection = await this.connect("host:track-devices-l");
-        const readable = new BufferedReadableStream(connection.readable);
-        let running = true;
-        (async () => {
-            try {
-                while (running) {
-                    const response = await AdbServerClient.readString(readable);
-                    const devices = this.parseDeviceList(response);
-                    callback(devices);
-                }
+    /**
+     * Track the device list.
+     *
+     * @param signal An optional `AbortSignal` to stop tracking
+     *
+     * When `signal` is aborted, `trackDevices` will return normally, instead of throwing `signal.reason`.
+     */
+    async *trackDevices(signal) {
+        const connection = await this.createConnection("host:track-devices-l");
+        try {
+            while (true) {
+                const response = await raceSignal(async () => await connection.readString(), signal);
+                const devices = this.parseDeviceList(response);
+                yield devices;
             }
-            catch {
-                // ignore
+        }
+        catch (e) {
+            if (e === signal?.reason) {
+                return;
             }
-        })().catch(unreachable);
-        return () => {
-            running = false;
-            readable.cancel().catch(NOOP);
-            Promise.resolve(connection.close()).catch(NOOP);
-        };
+        }
+        finally {
+            await connection.dispose();
+        }
     }
     formatDeviceService(device, command) {
         if (!device) {
@@ -211,7 +268,21 @@ export class AdbServerClient {
         if ("tcp" in device) {
             return `host-local:${command}`;
         }
-        throw new Error("Invalid device selector");
+        throw new TypeError("Invalid device selector");
+    }
+    /**
+     * `adb -s <device> reconnect` or `adb reconnect offline`
+     */
+    async reconnectDevice(device) {
+        const connection = await this.createConnection(device === "offline"
+            ? "host:reconnect-offline"
+            : this.formatDeviceService(device, "reconnect"));
+        try {
+            await connection.readString();
+        }
+        finally {
+            await connection.dispose();
+        }
     }
     /**
      * Gets the features supported by the device.
@@ -221,31 +292,41 @@ export class AdbServerClient {
      * @returns The transport ID of the selected device, and the features supported by the device.
      */
     async getDeviceFeatures(device) {
-        // Usually the client sends a device command using `connectDevice`,
-        // so the command got forwarded and handled by ADB daemon.
-        // However, in fact, `connectDevice` only forwards unknown services to device,
-        // if the service is a host command, it will still be handled by ADB server.
-        // Also, if the command is about a device, but didn't specify a selector,
-        // it will be executed against the device selected previously by `connectDevice`.
-        // Using this method, we can get the transport ID and device features in one connection.
-        const socket = await this.connectDevice(device, "host:features");
+        // On paper, `host:features` is a host service (device features are cached in host),
+        // so it shouldn't use `createDeviceConnection`,
+        // which is used to forward the service to the device.
+        //
+        // However, `createDeviceConnection` is a two step process:
+        //
+        //    1. Send a switch device service to host, to switch the connection to the device.
+        //    2. Send the actual service to host, let it forward the service to the device.
+        //
+        // In step 2, the host only forward the service to device if the service is unknown to host.
+        // If the service is a host service, it's still handled by host.
+        //
+        // Even better, if the service needs a device selector, but the selector is not provided,
+        // the service will be executed against the device selected by the switch device service.
+        // So we can use all device selector formats for the host service,
+        // and get the transport ID in the same time.
+        const connection = await this.createDeviceConnection(device, "host:features");
+        // Luckily `AdbServerClient.Socket` is compatible with `AdbServerClient.ServerConnection`
+        const stream = new AdbServerStream(connection);
         try {
-            const readable = new BufferedReadableStream(socket.readable);
-            const featuresString = await AdbServerClient.readString(readable);
+            const featuresString = await stream.readString();
             const features = featuresString.split(",");
-            return { transportId: socket.transportId, features };
+            return { transportId: connection.transportId, features };
         }
         finally {
-            await socket.close();
+            await stream.dispose();
         }
     }
     /**
      * Creates a connection that will forward the service to device.
      * @param device The device selector
      * @param service The service to forward
-     * @returns An `AdbServerSocket` that can be used to communicate with the service
+     * @returns An `AdbServerClient.Socket` that can be used to communicate with the service
      */
-    async connectDevice(device, service) {
+    async createDeviceConnection(device, service) {
         await this.validateVersion();
         let switchService;
         let transportId;
@@ -266,49 +347,46 @@ export class AdbServerClient {
             switchService = `host:tport:local`;
         }
         else {
-            throw new Error("Invalid device selector");
+            throw new TypeError("Invalid device selector");
         }
-        const connection = await this.connect(switchService);
+        const connection = await this.createConnection(switchService);
         try {
-            const writer = connection.writable.getWriter();
-            await AdbServerClient.writeString(writer, service);
-            writer.releaseLock();
+            await connection.writeString(service);
         }
         catch (e) {
-            await connection.readable.cancel();
-            await connection.close();
+            await connection.dispose();
             throw e;
         }
-        const readable = new BufferedReadableStream(connection.readable);
         try {
             if (transportId === undefined) {
-                const array = await readable.readExactly(8);
-                // TODO: switch to a more performant algorithm.
-                const dataView = new DataView(array.buffer, array.byteOffset, array.byteLength);
-                transportId = BigIntFieldType.Uint64.getter(dataView, 0, true);
+                const array = await connection.readExactly(8);
+                transportId = getUint64LittleEndian(array, 0);
             }
-            await AdbServerClient.readOkay(readable);
+            await connection.readOkay();
+            const socket = connection.release();
             return {
                 transportId,
                 service,
-                readable: readable.release(),
-                writable: new WrapWritableStream(connection.writable).bePipedThroughFrom(new UnwrapConsumableStream()),
+                readable: socket.readable,
+                writable: new WrapWritableStream(socket.writable).bePipedThroughFrom(new MaybeConsumable.UnwrapStream()),
                 get closed() {
-                    return connection.closed;
+                    return socket.closed;
                 },
                 async close() {
-                    await connection.close();
+                    await socket.close();
                 },
             };
         }
         catch (e) {
-            await readable.cancel().catch(NOOP);
-            await connection.close();
+            await connection.dispose();
             throw e;
         }
     }
     /**
      * Wait for a device to be connected or disconnected.
+     *
+     * `adb wait-for-<state>`
+     *
      * @param device The device selector
      * @param state The state to wait for
      * @param options The options
@@ -332,16 +410,18 @@ export class AdbServerClient {
             type = "local";
         }
         else {
-            throw new Error("Invalid device selector");
+            throw new TypeError("Invalid device selector");
         }
         // `waitFor` can't use `connectDevice`, because the device
         // might not be available yet.
         const service = this.formatDeviceService(device, `wait-for-${type}-${state}`);
-        const socket = await this.connect(service, options);
-        const readable = new BufferedReadableStream(socket.readable);
-        await AdbServerClient.readOkay(readable);
-        await readable.cancel();
-        await socket.close();
+        const connection = await this.createConnection(service, options);
+        try {
+            await connection.readOkay();
+        }
+        finally {
+            await connection.dispose();
+        }
     }
     async createTransport(device) {
         const { transportId, features } = await this.getDeviceFeatures(device);
@@ -377,4 +457,125 @@ export async function raceSignal(callback, ...signals) {
         }
     }
 }
+(function (AdbServerClient) {
+    class NetworkError extends Error {
+        constructor(message) {
+            super(message);
+            this.name = "NetworkError";
+        }
+    }
+    AdbServerClient.NetworkError = NetworkError;
+    class UnauthorizedError extends Error {
+        constructor(message) {
+            super(message);
+            this.name = "UnauthorizedError";
+        }
+    }
+    AdbServerClient.UnauthorizedError = UnauthorizedError;
+    class AlreadyConnectedError extends Error {
+        constructor(message) {
+            super(message);
+            this.name = "AlreadyConnectedError";
+        }
+    }
+    AdbServerClient.AlreadyConnectedError = AlreadyConnectedError;
+    class WirelessCommands {
+        #client;
+        constructor(client) {
+            this.#client = client;
+        }
+        /**
+         * `adb pair <password> <address>`
+         */
+        async pair(address, password) {
+            const connection = await this.#client.createConnection(`host:pair:${password}:${address}`);
+            try {
+                const response = await connection.readExactly(4);
+                // `response` is either `FAIL`, or 4 hex digits for length of the string
+                if (sequenceEqual(response, FAIL)) {
+                    throw new Error(await connection.readString());
+                }
+                const length = hexToNumber(response);
+                // Ignore the string as it's always `Successful ...`
+                await connection.readExactly(length);
+            }
+            finally {
+                await connection.dispose();
+            }
+        }
+        /**
+         * `adb connect <address>`
+         */
+        async connect(address) {
+            const connection = await this.#client.createConnection(`host:connect:${address}`);
+            try {
+                const response = await connection.readString();
+                switch (response) {
+                    case `already connected to ${address}`:
+                        throw new AdbServerClient.AlreadyConnectedError(response);
+                    case `failed to connect to ${address}`: // `adb pair` mode not authorized
+                    case `failed to authenticate to ${address}`: // `adb tcpip` mode not authorized
+                        throw new AdbServerClient.UnauthorizedError(response);
+                    case `connected to ${address}`:
+                        return;
+                    default:
+                        throw new AdbServerClient.NetworkError(response);
+                }
+            }
+            finally {
+                await connection.dispose();
+            }
+        }
+        /**
+         * `adb disconnect <address>`
+         */
+        async disconnect(address) {
+            const connection = await this.#client.createConnection(`host:disconnect:${address}`);
+            try {
+                await connection.readString();
+            }
+            finally {
+                await connection.dispose();
+            }
+        }
+    }
+    AdbServerClient.WirelessCommands = WirelessCommands;
+    class MDnsCommands {
+        #client;
+        constructor(client) {
+            this.#client = client;
+        }
+        async check() {
+            const connection = await this.#client.createConnection("host:mdns:check");
+            try {
+                const response = await connection.readString();
+                return !response.startsWith("ERROR:");
+            }
+            finally {
+                await connection.dispose();
+            }
+        }
+        async getServices() {
+            const connection = await this.#client.createConnection("host:mdns:services");
+            try {
+                const response = await connection.readString();
+                return response
+                    .split("\n")
+                    .filter(Boolean)
+                    .map((line) => {
+                    const parts = line.split("\t");
+                    return {
+                        name: parts[0],
+                        service: parts[1],
+                        address: parts[2],
+                    };
+                });
+            }
+            finally {
+                await connection.dispose();
+            }
+        }
+    }
+    AdbServerClient.MDnsCommands = MDnsCommands;
+})(AdbServerClient || (AdbServerClient = {}));
 //# sourceMappingURL=client.js.map