@yume-chan/adb 2.6.2 → 3.0.0-beta.1

package/src/daemon/crypto.ts

@@ -48,11 +48,14 @@ export function setBigUint(
     littleEndian?: boolean,
 ) {
     if (littleEndian) {
+        const end = byteOffset + length;
         while (value > 0n) {
             setInt64LittleEndian(array, byteOffset, value);
             byteOffset += 8;
             value >>= 64n;
         }
+        // Clear the trailing bytes
+        array.subarray(byteOffset, end).fill(0);
     } else {
         let position = byteOffset + length - 8;
         while (value > 0n) {
@@ -60,9 +63,16 @@ export function setBigUint(
             position -= 8;
             value >>= 64n;
         }
+        // Clear the leading bytes
+        array.subarray(byteOffset, position + 8).fill(0);
     }
 }
 
+export interface SimpleRsaPrivateKey {
+    n: bigint;
+    d: bigint;
+}
+
 // These values are correct only if
 // modulus length is 2048 and
 // public exponent (e) is 65537
@@ -89,10 +99,16 @@ const RsaPrivateKeyNLength = 2048 / 8;
 const RsaPrivateKeyDOffset = 303;
 const RsaPrivateKeyDLength = 2048 / 8;
 
-export function rsaParsePrivateKey(key: Uint8Array): [n: bigint, d: bigint] {
+export function rsaParsePrivateKey(key: Uint8Array): SimpleRsaPrivateKey {
+    if (key.length < RsaPrivateKeyDOffset + RsaPrivateKeyDLength) {
+        throw new Error(
+            "RSA private key is too short. Expecting a PKCS#8 formatted RSA private key with modulus length 2048 bits and public exponent 65537.",
+        );
+    }
+
     const n = getBigUint(key, RsaPrivateKeyNOffset, RsaPrivateKeyNLength);
     const d = getBigUint(key, RsaPrivateKeyDOffset, RsaPrivateKeyDLength);
-    return [n, d];
+    return { n, d };
 }
 
 function nonNegativeMod(m: number, d: number) {
@@ -133,97 +149,6 @@ export function modInverse(a: number, m: number) {
     return nonNegativeMod(y, m);
 }
 
-const ModulusLengthInBytes = 2048 / 8;
-const ModulusLengthInWords = ModulusLengthInBytes / 4;
-
-export function adbGetPublicKeySize() {
-    return 4 + 4 + ModulusLengthInBytes + ModulusLengthInBytes + 4;
-}
-
-export function adbGeneratePublicKey(
-    privateKey: Uint8Array,
-): Uint8Array<ArrayBuffer>;
-export function adbGeneratePublicKey(
-    privateKey: Uint8Array,
-    output: Uint8Array,
-): number;
-export function adbGeneratePublicKey(
-    privateKey: Uint8Array,
-    output?: Uint8Array,
-): Uint8Array | number {
-    // cspell: ignore: mincrypt
-    // Android 6 and earlier has its own encryption library called mincrypt
-    // This is the RSA public key format used by mincrypt:
-    // https://android.googlesource.com/platform/system/core/+/bb0c180e62703c2068a1b2c9f8ba6d634bf1553c/include/mincrypt/rsa.h#46
-    // `n0inv` and `rr` are pre-calculated to speed up RSA operations
-
-    // Android 7 switched its encryption library to BoringSSL, but still keeps the key format:
-    // https://android.googlesource.com/platform/system/core.git/+/91784040db2b9273687f88d8b95f729d4a61ecc2/libcrypto_utils/android_pubkey.cpp#38
-    // Except when reading a key, `n0inv` and `rr` are ignored (they are still populated when generating a key):
-    // https://android.googlesource.com/platform/system/core.git/+/91784040db2b9273687f88d8b95f729d4a61ecc2/libcrypto_utils/android_pubkey.cpp#55
-
-    // The public key is a struct (in little endian) of:
-    //
-    // [
-    //   modulusLengthInWords, // 32-bit integer, a "word" is 32-bit so it must be 2048 / 8 / 4
-    //                         // (the comment in Android source code is incorrect saying "This must be ANDROID_PUBKEY_MODULUS_SIZE")
-    //   n0inv,                // 32-bit integer, the modular inverse of (lower 32 bits of `n`)
-    //   modulus,              // `n`
-    //   rr,                   // Montgomery parameter R^2
-    //   exponent,             // 32-bit integer, must be 3 or 65537
-    // ]
-
-    let outputType: "Uint8Array" | "number";
-    const outputLength = adbGetPublicKeySize();
-    if (!output) {
-        output = new Uint8Array(outputLength);
-        outputType = "Uint8Array";
-    } else {
-        if (output.length < outputLength) {
-            throw new TypeError("output buffer is too small");
-        }
-
-        outputType = "number";
-    }
-
-    const outputView = new DataView(
-        output.buffer,
-        output.byteOffset,
-        output.length,
-    );
-    let outputOffset = 0;
-
-    // modulusLengthInWords
-    outputView.setUint32(outputOffset, ModulusLengthInWords, true);
-    outputOffset += 4;
-
-    // extract `n` from private key
-    const [n] = rsaParsePrivateKey(privateKey);
-
-    // Calculate `n0inv`
-    const n0inv = -modInverse(Number(n % 2n ** 32n), 2 ** 32);
-    outputView.setInt32(outputOffset, n0inv, true);
-    outputOffset += 4;
-
-    // Write `n` (a.k.a. `modulus`)
-    setBigUint(output, outputOffset, ModulusLengthInBytes, n, true);
-    outputOffset += ModulusLengthInBytes;
-
-    // Calculate rr = (2 ** (rsa_size)) ** 2 % n
-    const rr = 2n ** 4096n % n;
-    setBigUint(output, outputOffset, ModulusLengthInBytes, rr, true);
-    outputOffset += ModulusLengthInBytes;
-
-    // exponent
-    outputView.setUint32(outputOffset, 65537, true);
-
-    if (outputType === "Uint8Array") {
-        return output;
-    } else {
-        return outputLength;
-    }
-}
-
 /**
  * Modular exponentiation.
  *
@@ -282,17 +207,27 @@ export const SHA1_DIGEST_INFO = new Uint8Array([
     SHA1_DIGEST_LENGTH,
 ]);
 
-// SubtleCrypto.sign() will hash the given data and sign the hash
-// But we don't need the hashing step
-// (In another word, ADB just requires the client to
-// encrypt the given data with its private key)
-// However SubtileCrypto.encrypt() doesn't accept 'RSASSA-PKCS1-v1_5' algorithm
-// So we need to implement the encryption by ourself
+// Standard `RSASSA-PKCS1-v1_5` algorithm will hash the given data
+// and sign the hash
+// https://datatracker.ietf.org/doc/html/rfc8017#section-8.2
+//
+// But ADB authentication passes 20 bytes of random value to
+// OpenSSL's `RSA_sign` method which treat the input as a hash
+// https://docs.openssl.org/1.0.2/man3/RSA_sign/
+//
+// Since it's non-standard and not supported by Web Crypto API,
+// we need to implement the signing by ourself
 export function rsaSign(
-    privateKey: Uint8Array,
+    privateKey: SimpleRsaPrivateKey,
     data: Uint8Array,
 ): Uint8Array<ArrayBuffer> {
-    const [n, d] = rsaParsePrivateKey(privateKey);
+    if (data.length !== SHA1_DIGEST_LENGTH) {
+        throw new Error(
+            `rsaSign expects ${SHA1_DIGEST_LENGTH} bytes (SHA-1 digest length) of data but got ${data.length} bytes`,
+        );
+    }
+
+    const { n, d } = privateKey;
 
     // PKCS#1 padding
     const padded = new Uint8Array(256);

package/src/daemon/dispatcher.ts

@@ -19,7 +19,7 @@ import {
 } from "@yume-chan/stream-extra";
 import { EmptyUint8Array, decodeUtf8, encodeUtf8 } from "@yume-chan/struct";
 
-import type { AdbIncomingSocketHandler, AdbSocket, Closeable } from "../adb.js";
+import type { Adb, Closeable } from "../adb.js";
 
 import type { AdbPacketData, AdbPacketInit } from "./packet.js";
 import { AdbCommand, calculateChecksum } from "./packet.js";
@@ -114,7 +114,7 @@ export class AdbPacketDispatcher implements Closeable {
 
     readonly #incomingSocketHandlers = new Map<
         string,
-        AdbIncomingSocketHandler
+        Adb.IncomingSocketHandler
     >();
     readonly #readAbortController = new AbortController();
 
@@ -146,13 +146,20 @@ export class AdbPacketDispatcher implements Closeable {
                                 this.#handleOkay(packet);
                                 break;
                             case AdbCommand.Open:
-                                await this.#handleOpen(packet);
+                                // Don't await
+                                // The handler may take a long time to accept the socket,
+                                // don't block other sockets' packet processing.
+                                this.#handleOpen(packet).catch((e) => {
+                                    // Propagate fatal errors to consumer
+                                    controller.error(e);
+                                });
                                 break;
                             case AdbCommand.Write:
-                                // Don't await - let each socket handle its own backpressure
-                                // without blocking other sockets' packet processing.
-                                // Fatal errors are propagated via WritableStream's controller.
+                                // Don't await
+                                // The socket might be stalled because of backpressure,
+                                // don't block other sockets' packet processing.
                                 this.#handleWrite(packet).catch((e) => {
+                                    // Propagate fatal errors to consumer
                                     controller.error(e);
                                 });
                                 break;
@@ -392,7 +399,7 @@ export class AdbPacketDispatcher implements Closeable {
         await Promise.race(promises);
     }
 
-    async createSocket(service: string): Promise<AdbSocket> {
+    async createSocket(service: string): Promise<Adb.Socket> {
         if (this.options.appendNullToServiceString) {
             service += "\0";
         }
@@ -421,7 +428,7 @@ export class AdbPacketDispatcher implements Closeable {
         return controller.socket;
     }
 
-    addReverseTunnel(service: string, handler: AdbIncomingSocketHandler) {
+    addReverseTunnel(service: string, handler: Adb.IncomingSocketHandler) {
         this.#incomingSocketHandlers.set(service, handler);
     }
 

package/src/daemon/index.ts

@@ -1,4 +1,4 @@
-export * from "./auth.js";
+export * from "./auth/index.js";
 export * from "./crypto.js";
 export * from "./device.js";
 export * from "./dispatcher.js";

package/src/daemon/socket.ts

@@ -9,7 +9,7 @@ import type {
 import { MaybeConsumable, PushReadableStream } from "@yume-chan/stream-extra";
 import { EmptyUint8Array } from "@yume-chan/struct";
 
-import type { AdbSocket } from "../adb.js";
+import type { Adb } from "../adb.js";
 
 import type { AdbPacketDispatcher } from "./dispatcher.js";
 import { AdbCommand } from "./packet.js";
@@ -34,7 +34,7 @@ export interface AdbDaemonSocketInit extends AdbDaemonSocketInfo {
 }
 
 export class AdbDaemonSocketController
-    implements AdbDaemonSocketInfo, AdbSocket, Disposable
+    implements AdbDaemonSocketInfo, Adb.Socket, Disposable
 {
     readonly #dispatcher!: AdbPacketDispatcher;
 
@@ -177,7 +177,7 @@ export class AdbDaemonSocketController
 /**
  * A duplex stream representing a socket to ADB daemon.
  */
-export class AdbDaemonSocket implements AdbDaemonSocketInfo, AdbSocket {
+export class AdbDaemonSocket implements AdbDaemonSocketInfo, Adb.Socket {
     readonly #controller: AdbDaemonSocketController;
 
     get localId(): number {

package/src/daemon/transport.ts

@@ -1,55 +1,14 @@
 import type { MaybePromiseLike } from "@yume-chan/async";
-import { PromiseResolver } from "@yume-chan/async";
-import type { ReadableWritablePair } from "@yume-chan/stream-extra";
-import {
-    AbortController,
-    Consumable,
-    WritableStream,
-} from "@yume-chan/stream-extra";
-import { decodeUtf8, encodeUtf8 } from "@yume-chan/struct";
+import type { Consumable, ReadableWritablePair } from "@yume-chan/stream-extra";
 
-import type {
-    AdbIncomingSocketHandler,
-    AdbSocket,
-    AdbTransport,
-} from "../adb.js";
+import type { Adb, AdbTransport } from "../adb.js";
 import { AdbBanner } from "../banner.js";
-import { AdbFeature } from "../features.js";
+import { AdbDeviceFeatures, AdbFeature } from "../features.js";
 
-import type { AdbAuthenticator, AdbCredentialStore } from "./auth.js";
-import {
-    ADB_DEFAULT_AUTHENTICATORS,
-    AdbAuthenticationProcessor,
-} from "./auth.js";
 import { AdbPacketDispatcher } from "./dispatcher.js";
 import type { AdbPacketData, AdbPacketInit } from "./packet.js";
-import { AdbCommand, calculateChecksum } from "./packet.js";
 
 export const ADB_DAEMON_VERSION_OMIT_CHECKSUM = 0x01000001;
-// https://android.googlesource.com/platform/packages/modules/adb/+/79010dc6d5ca7490c493df800d4421730f5466ca/transport.cpp#1252
-// There are some other feature constants, but some of them are only used by ADB server, not devices (daemons).
-export const ADB_DAEMON_DEFAULT_FEATURES = /* #__PURE__ */ (() =>
-    [
-        AdbFeature.ShellV2,
-        AdbFeature.Cmd,
-        AdbFeature.StatV2,
-        AdbFeature.ListV2,
-        AdbFeature.FixedPushMkdir,
-        "apex",
-        AdbFeature.Abb,
-        // only tells the client the symlink timestamp issue in `adb push --sync` has been fixed.
-        // No special handling required.
-        "fixed_push_symlink_timestamp",
-        AdbFeature.AbbExec,
-        "remount_shell",
-        "track_app",
-        AdbFeature.SendReceiveV2,
-        "sendrecv_v2_brotli",
-        "sendrecv_v2_lz4",
-        "sendrecv_v2_zstd",
-        "sendrecv_v2_dry_run_send",
-        AdbFeature.DelayedAck,
-    ] as readonly AdbFeature[])();
 export const ADB_DAEMON_DEFAULT_INITIAL_PAYLOAD_SIZE = 32 * 1024 * 1024;
 
 export type AdbDaemonConnection = ReadableWritablePair<
@@ -57,55 +16,7 @@ export type AdbDaemonConnection = ReadableWritablePair<
     Consumable<AdbPacketInit>
 >;
 
-export interface AdbDaemonAuthenticationOptions {
-    serial: string;
-    connection: AdbDaemonConnection;
-    credentialStore: AdbCredentialStore;
-    authenticators?: readonly AdbAuthenticator[];
-    features?: readonly AdbFeature[];
-
-    /**
-     * The number of bytes the device can send before receiving an ack packet.
-     * Using delayed ack can improve the throughput,
-     * especially when the device is connected over Wi-Fi (so the latency is higher).
-     *
-     * Set to 0 or any negative value to disable delayed ack in handshake.
-     * Otherwise the value must be in the range of unsigned 32-bit integer.
-     *
-     * Delayed ack was added in Android 14,
-     * this option will be ignored when the device doesn't support it.
-     *
-     * @default ADB_DAEMON_DEFAULT_INITIAL_PAYLOAD_SIZE
-     */
-    initialDelayedAckBytes?: number;
-
-    /**
-     * Whether to keep the `connection` open (don't call `writable.close` and `readable.cancel`)
-     * when `AdbDaemonTransport.close` is called.
-     *
-     * Note that when `authenticate` fails,
-     * no matter which value this option has,
-     * the `connection` is always kept open, so it can be used in another `authenticate` call.
-     *
-     * @default false
-     */
-    preserveConnection?: boolean | undefined;
-
-    /**
-     * When set, the transport will throw an error when
-     * one of the socket readable stalls for this amount of milliseconds.
-     *
-     * Because ADB is a multiplexed protocol, blocking one socket will also block all other sockets.
-     * It's important to always read from all sockets to prevent stalling.
-     *
-     * This option is helpful to detect bugs in the client code.
-     *
-     * @default undefined
-     */
-    readTimeLimit?: number | undefined;
-}
-
-interface AdbDaemonSocketConnectorConstructionOptions {
+export interface AdbDaemonTransportInit {
     serial: string;
     connection: AdbDaemonConnection;
     version: number;
@@ -116,16 +27,16 @@ interface AdbDaemonSocketConnectorConstructionOptions {
     /**
      * The number of bytes the device can send before receiving an ack packet.
      *
-     * On Android 14 and newer, the Delayed Acknowledgement feature is added to
-     * improve performance, especially for high-latency connections like ADB over Wi-Fi.
+     * Android 14 added the Delayed Acknowledgement feature to improve performance,
+     * especially for high-latency connections like ADB over Wi-Fi.
      *
-     * When `features` doesn't include `AdbFeature.DelayedAck`, it must be set to 0. Otherwise,
-     * the value must be in the range of unsigned 32-bit integer.
+     * Whether the feature is enabled is negotiated in the handshake process
+     * using the {@linkcode AdbFeature.DelayedAck} feature.
+     * If the feature is enabled, this parameter must be set to a positive integer.
      *
-     * If the device enabled delayed ack but the client didn't, the device will throw an error
-     * when the client sends the first data packet. And vice versa.
+     * If not specified, the default value is {@linkcode ADB_DAEMON_DEFAULT_INITIAL_PAYLOAD_SIZE}.
      */
-    initialDelayedAckBytes: number;
+    initialDelayedAckBytes?: number | undefined;
 
     /**
      * Whether to keep the `connection` open (don't call `writable.close` and `readable.cancel`)
@@ -153,135 +64,6 @@ interface AdbDaemonSocketConnectorConstructionOptions {
  * An ADB Transport that connects to ADB Daemons directly.
  */
 export class AdbDaemonTransport implements AdbTransport {
-    /**
-     * Authenticate with the ADB Daemon and create a new transport.
-     */
-    static async authenticate({
-        serial,
-        connection,
-        credentialStore,
-        authenticators = ADB_DEFAULT_AUTHENTICATORS,
-        features = ADB_DAEMON_DEFAULT_FEATURES,
-        initialDelayedAckBytes = ADB_DAEMON_DEFAULT_INITIAL_PAYLOAD_SIZE,
-        ...options
-    }: AdbDaemonAuthenticationOptions): Promise<AdbDaemonTransport> {
-        // Initially, set to highest-supported version and payload size.
-        let version = 0x01000001;
-        // Android 4: 4K, Android 7: 256K, Android 9: 1M
-        let maxPayloadSize = 1024 * 1024;
-
-        const resolver = new PromiseResolver<string>();
-        const authProcessor = new AdbAuthenticationProcessor(
-            authenticators,
-            credentialStore,
-        );
-
-        // Here is similar to `AdbPacketDispatcher`,
-        // But the received packet types and send packet processing are different.
-        const abortController = new AbortController();
-        const pipe = connection.readable
-            .pipeTo(
-                new WritableStream({
-                    async write(packet) {
-                        switch (packet.command) {
-                            case AdbCommand.Connect:
-                                version = Math.min(version, packet.arg0);
-                                maxPayloadSize = Math.min(
-                                    maxPayloadSize,
-                                    packet.arg1,
-                                );
-                                resolver.resolve(decodeUtf8(packet.payload));
-                                break;
-                            case AdbCommand.Auth: {
-                                const response =
-                                    await authProcessor.process(packet);
-                                await sendPacket(response);
-                                break;
-                            }
-                            default:
-                                // Maybe the previous ADB client exited without reading all packets,
-                                // so they are still waiting in OS internal buffer.
-                                // Just ignore them.
-                                // Because a `Connect` packet will reset the device,
-                                // Eventually there will be `Connect` and `Auth` response packets.
-                                break;
-                        }
-                    },
-                }),
-                {
-                    // Don't cancel the source ReadableStream on AbortSignal abort.
-                    preventCancel: true,
-                    signal: abortController.signal,
-                },
-            )
-            .then(
-                () => {
-                    // If `resolver` is already settled, call `reject` won't do anything.
-                    resolver.reject(
-                        new Error("Connection closed unexpectedly"),
-                    );
-                },
-                (e) => {
-                    resolver.reject(e);
-                },
-            );
-
-        const writer = connection.writable.getWriter();
-        async function sendPacket(init: AdbPacketData) {
-            // Always send checksum in auth steps
-            // Because we don't know if the device needs it or not.
-            (init as AdbPacketInit).checksum = calculateChecksum(init.payload);
-            (init as AdbPacketInit).magic = init.command ^ 0xffffffff;
-            await Consumable.WritableStream.write(
-                writer,
-                init as AdbPacketInit,
-            );
-        }
-
-        const actualFeatures = features.slice();
-        if (initialDelayedAckBytes <= 0) {
-            const index = features.indexOf(AdbFeature.DelayedAck);
-            if (index !== -1) {
-                actualFeatures.splice(index, 1);
-            }
-        }
-
-        let banner: string;
-        try {
-            await sendPacket({
-                command: AdbCommand.Connect,
-                arg0: version,
-                arg1: maxPayloadSize,
-                // The terminating `;` is required in formal definition
-                // But ADB daemon (all versions) can still work without it
-                payload: encodeUtf8(
-                    `host::features=${actualFeatures.join(",")}`,
-                ),
-            });
-
-            banner = await resolver.promise;
-        } finally {
-            // When failed, release locks on `connection` so the caller can try again.
-            // When success, also release locks so `AdbPacketDispatcher` can use them.
-            abortController.abort();
-            writer.releaseLock();
-
-            // Wait until pipe stops (`ReadableStream` lock released)
-            await pipe;
-        }
-
-        return new AdbDaemonTransport({
-            serial,
-            connection,
-            version,
-            maxPayloadSize,
-            banner,
-            features: actualFeatures,
-            initialDelayedAckBytes,
-            ...options,
-        });
-    }
-
     #connection: AdbDaemonConnection;
     get connection() {
         return this.#connection;
@@ -322,42 +104,42 @@ export class AdbDaemonTransport implements AdbTransport {
         connection,
         version,
         banner,
-        features = ADB_DAEMON_DEFAULT_FEATURES,
-        initialDelayedAckBytes,
+        features = AdbDeviceFeatures,
+        initialDelayedAckBytes = ADB_DAEMON_DEFAULT_INITIAL_PAYLOAD_SIZE,
         ...options
-    }: AdbDaemonSocketConnectorConstructionOptions) {
+    }: AdbDaemonTransportInit) {
         this.#serial = serial;
         this.#connection = connection;
         this.#banner = AdbBanner.parse(banner);
         this.#clientFeatures = features;
 
-        if (features.includes(AdbFeature.DelayedAck)) {
-            if (initialDelayedAckBytes <= 0) {
-                throw new TypeError(
-                    "`initialDelayedAckBytes` must be greater than 0 when DelayedAck feature is enabled.",
-                );
-            }
-
-            if (!this.#banner.features.includes(AdbFeature.DelayedAck)) {
-                initialDelayedAckBytes = 0;
-            }
-        } else {
+        if (
+            !this.#banner.features.includes(AdbFeature.DelayedAck) ||
+            !features.includes(AdbFeature.DelayedAck)
+        ) {
+            // For `AdbPacketDispatcher`, 0 means disabled
             initialDelayedAckBytes = 0;
+        } else if (initialDelayedAckBytes <= 0) {
+            // Delayed Ack is enabled in handshake process, we can't disable it here,
+            // so it must be a positive integer
+            throw new TypeError(
+                "`initialDelayedAckBytes` must be greater than 0 when DelayedAck feature is enabled.",
+            );
         }
 
-        let calculateChecksum: boolean;
-        let appendNullToServiceString: boolean;
+        let shouldCalculateChecksum: boolean;
+        let shouldAppendNullToServiceString: boolean;
         if (version >= ADB_DAEMON_VERSION_OMIT_CHECKSUM) {
-            calculateChecksum = false;
-            appendNullToServiceString = false;
+            shouldCalculateChecksum = false;
+            shouldAppendNullToServiceString = false;
         } else {
-            calculateChecksum = true;
-            appendNullToServiceString = true;
+            shouldCalculateChecksum = true;
+            shouldAppendNullToServiceString = true;
         }
 
         this.#dispatcher = new AdbPacketDispatcher(connection, {
-            calculateChecksum,
-            appendNullToServiceString,
+            calculateChecksum: shouldCalculateChecksum,
+            appendNullToServiceString: shouldAppendNullToServiceString,
             initialDelayedAckBytes,
             ...options,
         });
@@ -365,12 +147,12 @@ export class AdbDaemonTransport implements AdbTransport {
         this.#protocolVersion = version;
     }
 
-    connect(service: string): MaybePromiseLike<AdbSocket> {
+    connect(service: string): MaybePromiseLike<Adb.Socket> {
         return this.#dispatcher.createSocket(service);
     }
 
     addReverseTunnel(
-        handler: AdbIncomingSocketHandler,
+        handler: Adb.IncomingSocketHandler,
         address?: string,
     ): string {
         if (!address) {

package/src/device-observer.ts

@@ -1,10 +1,10 @@
-import type { MaybePromiseLike } from "@yume-chan/async";
 import type { Event } from "@yume-chan/event";
 
-export interface DeviceObserver<T> {
+import type { Closeable } from "./adb.js";
+
+export interface DeviceObserver<T> extends Closeable {
     readonly onDeviceAdd: Event<readonly T[]>;
     readonly onDeviceRemove: Event<readonly T[]>;
     readonly onListChange: Event<readonly T[]>;
     readonly current: readonly T[];
-    stop(): MaybePromiseLike<void>;
 }