@yume-chan/adb 0.0.19 → 0.0.21

package/CHANGELOG.json

@@ -1,6 +1,63 @@
 {
   "name": "@yume-chan/adb",
   "entries": [
+    {
+      "version": "0.0.21",
+      "tag": "@yume-chan/adb_v0.0.21",
+      "date": "Fri, 25 Aug 2023 14:05:18 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Change `AdbSync` to throws `AdbSyncError` for errors returned by ADB Daemon"
+          },
+          {
+            "comment": "Add name for public keys"
+          },
+          {
+            "comment": "Add typed errors for `framebuffer` command when current app disables screen capture"
+          },
+          {
+            "comment": "Change `AdbDaemonTransport` class to automatically close the connection, unless the new `preserveConnection` option is `true`"
+          },
+          {
+            "comment": "Add `recursive` and `force` options to `rm` method, allow deleting folders"
+          }
+        ]
+      }
+    },
+    {
+      "version": "0.0.20",
+      "tag": "@yume-chan/adb_v0.0.20",
+      "date": "Mon, 05 Jun 2023 02:51:41 GMT",
+      "comments": {
+        "none": [
+          {
+            "comment": "Use ECMAScript private class fields syntax (supported by Chrome 74, Firefox 90, Safari 14.1 and Node.js 12.0.0)."
+          },
+          {
+            "comment": "Refactor `AdbSubprocessShellProtocol` class, this should improve some performance."
+          },
+          {
+            "comment": "Split `mode` parameter in `AdbSync#write()` into `type` and `permission` for ease of use."
+          },
+          {
+            "comment": "Add `AdbReverseCommand#addExternal()`. This only register the reverse tunnel to the device, the handler should already exists (for example you are adding a reverse tunnel for an external program that's already listening on the port). In ADB direct connection, this should do nothing, because the reverse tunnel is handled by this library and there is no mean of \"external\" handler."
+          },
+          {
+            "comment": "Change `AdbTcpIpCommand#setPort` and `AdbTcpIpCommand#disable` to return or throw the response text. This can be displayed to the user to know what's wrong."
+          },
+          {
+            "comment": "Add support for connecting to ADB servers. Because a USB device can only be used by one process at a time, the ADB server is the process that manages all connected devices. The server proxies and multiplexes connections from ADB clients so multiple adb commands can be executed on one device at the same time. The `Adb` class is no longer responsible for connecting and authenticating with ADB daemons. The `AdbTransport` interface and its two implementations `AdbDaemonTransport` and `AdbServerTransport` was added to connect to either ADB daemons or servers in compatible environments. Read the PR for details, migration paths, and examples. ([#549](https://github.com/yume-chan/ya-webadb/pull/549))"
+          },
+          {
+            "comment": "Add `serial` field to `Adb` class."
+          },
+          {
+            "comment": "Group `product`, `model`, `device` and `features` fields on `Adb` class to the `banner` field with type of `AdbBanner`."
+          }
+        ]
+      }
+    },
     {
       "version": "0.0.19",
       "tag": "@yume-chan/adb_v0.0.19",

package/CHANGELOG.md

@@ -1,6 +1,31 @@
 # Change Log - @yume-chan/adb
 
-This log was last generated on Sun, 09 Apr 2023 05:55:33 GMT and should not be manually modified.
+This log was last generated on Fri, 25 Aug 2023 14:05:18 GMT and should not be manually modified.
+
+## 0.0.21
+Fri, 25 Aug 2023 14:05:18 GMT
+
+### Updates
+
+- Change `AdbSync` to throws `AdbSyncError` for errors returned by ADB Daemon
+- Add name for public keys
+- Add typed errors for `framebuffer` command when current app disables screen capture
+- Change `AdbDaemonTransport` class to automatically close the connection, unless the new `preserveConnection` option is `true`
+- Add `recursive` and `force` options to `rm` method, allow deleting folders
+
+## 0.0.20
+Mon, 05 Jun 2023 02:51:41 GMT
+
+### Updates
+
+- Use ECMAScript private class fields syntax (supported by Chrome 74, Firefox 90, Safari 14.1 and Node.js 12.0.0).
+- Refactor `AdbSubprocessShellProtocol` class, this should improve some performance.
+- Split `mode` parameter in `AdbSync#write()` into `type` and `permission` for ease of use.
+- Add `AdbReverseCommand#addExternal()`. This only register the reverse tunnel to the device, the handler should already exists (for example you are adding a reverse tunnel for an external program that's already listening on the port). In ADB direct connection, this should do nothing, because the reverse tunnel is handled by this library and there is no mean of "external" handler.
+- Change `AdbTcpIpCommand#setPort` and `AdbTcpIpCommand#disable` to return or throw the response text. This can be displayed to the user to know what's wrong.
+- Add support for connecting to ADB servers. Because a USB device can only be used by one process at a time, the ADB server is the process that manages all connected devices. The server proxies and multiplexes connections from ADB clients so multiple adb commands can be executed on one device at the same time. The `Adb` class is no longer responsible for connecting and authenticating with ADB daemons. The `AdbTransport` interface and its two implementations `AdbDaemonTransport` and `AdbServerTransport` was added to connect to either ADB daemons or servers in compatible environments. Read the PR for details, migration paths, and examples. ([#549](https://github.com/yume-chan/ya-webadb/pull/549))
+- Add `serial` field to `Adb` class.
+- Group `product`, `model`, `device` and `features` fields on `Adb` class to the `banner` field with type of `AdbBanner`.
 
 ## 0.0.19
 Sun, 09 Apr 2023 05:55:33 GMT

package/README.md

@@ -2,39 +2,41 @@
 
 TypeScript implementation of Android Debug Bridge (ADB) protocol.
 
-**WARNING:** The public API is UNSTABLE. If you have any questions, please open an issue.
-
-- [Compatibility](#compatibility)
-  - [Basic usage](#basic-usage)
-  - [Use without bundlers](#use-without-bundlers)
-- [Connection](#connection)
-  - [Backend](#backend)
-    - [`connect`](#connect)
-- [Authentication](#authentication)
-    - [AdbCredentialStore](#adbcredentialstore)
-      - [`generateKey`](#generatekey)
-      - [`iterateKeys`](#iteratekeys)
-      - [Implementations](#implementations)
-    - [AdbAuthenticator](#adbauthenticator)
-    - [`authenticate`](#authenticate)
-- [Stream multiplex](#stream-multiplex)
-- [Commands](#commands)
-  - [subprocess](#subprocess)
-    - [raw mode](#raw-mode)
-    - [pty mode](#pty-mode)
-  - [usb](#usb)
-  - [tcpip](#tcpip)
-  - [sync](#sync)
-    - [LIST](#list)
-    - [LIS2](#lis2)
-    - [STAT](#stat)
-    - [LST2](#lst2)
-    - [STA2](#sta2)
-    - [RECV](#recv)
-    - [RCV2](#rcv2)
-    - [SEND](#send)
-    - [SND2](#snd2)
-- [Useful links](#useful-links)
+**WARNING:** The public API is UNSTABLE. Open a GitHub discussion if you have any questions.
+
+-   [Compatibility](#compatibility)
+    -   [Basic usage](#basic-usage)
+    -   [Use without bundlers](#use-without-bundlers)
+-   [Transport](#transport)
+    -   [`AdbDaemonTransport`](#adbdaemontransport)
+        -   [`AdbCredentialStore`](#adbcredentialstore)
+            -   [`generateKey`](#generatekey)
+            -   [`iterateKeys`](#iteratekeys)
+        -   [`AdbAuthenticator`](#adbauthenticator)
+        -   [`authenticate`](#authenticate)
+        -   [`addReverseTunnel`](#addreversetunnel)
+    -   [`AdbServerTransport`](#adbservertransport)
+        -   [`AdbServerClient`](#adbserverclient)
+            -   [`getVersion`](#getversion)
+            -   [`kill`](#kill)
+            -   [`getServerFeatures`](#getserverfeatures)
+            -   [`getDevices`](#getdevices)
+            -   [`AdbServerDeviceSelector`](#adbserverdeviceselector)
+            -   [`getDeviceFeatures`](#getdevicefeatures)
+            -   [`waitFor`](#waitfor)
+-   [Commands](#commands)
+    -   [subprocess](#subprocess)
+        -   [raw mode](#raw-mode)
+        -   [pty mode](#pty-mode)
+    -   [usb](#usb)
+    -   [tcpip](#tcpip)
+    -   [sync](#sync)
+        -   [`lstat`](#lstat)
+        -   [`stat`](#stat)
+        -   [`isDirectory`](#isdirectory)
+        -   [`opendir`](#opendir)
+        -   [`readdir`](#readdir)
+-   [Useful links](#useful-links)
 
 ## Compatibility
 
@@ -42,52 +44,56 @@ Here is a list of features, their used APIs, and their compatibilities. If an op
 
 Some features can be polyfilled to support older runtimes, but this library doesn't ship with any polyfills.
 
-Each backend may have different requirements.
+Each transport and connection may have different requirements.
 
 ### Basic usage
 
-|                                 | Chrome | Edge | Firefox | Internet Explorer | Safari | Node.js             |
-| ------------------------------- | ------ | ---- | ------- | ----------------- | ------ | ------------------- |
-| `@yume-chan/struct`<sup>1</sup> | 67     | 79   | 68      | No                | 14     | 8.3<sup>2</sup>, 11 |
-| *Overall*                       | 67     | 79   | No      | No                | 14.1   | 16.5                |
+|                                  | Chrome | Edge | Firefox | Internet Explorer | Safari | Node.js             |
+| -------------------------------- | ------ | ---- | ------- | ----------------- | ------ | ------------------- |
+| `@yume-chan/struct`<sup>1</sup>  | 67     | 79   | 68      | No                | 14     | 8.3<sup>2</sup>, 11 |
+| Private class fields<sup>3</sup> | 74     | 79   | 90      | No                | 14.1   | 12.0.0              |
+| _Overall_                        | 74     | 79   | 90      | No                | 14.1   | 16.5                |
 
 <sup>1</sup> `uint64` and `string` are used.
 
 <sup>2</sup> `TextEncoder` and `TextDecoder` are only available in `util` module. Need to be assigned to `globalThis`.
 
+<sup>3</sup> Can be down-level compiled using Babel.
+
 ### Use without bundlers
 
 |                 | Chrome | Edge | Firefox | Internet Explorer | Safari | Node.js |
 | --------------- | ------ | ---- | ------- | ----------------- | ------ | ------- |
 | Top-level await | 89     | 89   | 89      | No                | 15     | 14.8    |
 
-## Connection
+## Transport
 
 This library doesn't tie to a specific transportation method.
 
-Instead, a `Backend` is responsible for transferring data in its own way (USB, WebSocket, TCP, etc).
+Instead, an implementation of the `AdbTransport` interface is responsible for creating ADB sockets when requested. Each implementation might have different methods to discover, connect and authenticate devices.
 
-### Backend
+### `AdbDaemonTransport`
 
-#### `connect`
+`AdbDaemonTransport` connects to an ADB daemon directly.
 
-```ts
-connect(): ValueOrPromise<ReadableWritablePair<AdbPacketCore, AdbPacketInit>>
-```
+It requires a `ReadableWritablePair<AdbPacketData, Consumable<AdbPacketInit>>` to send and receive ADB packets to the daemon.
 
-Connect to a device and create a pair of `AdbPacket` streams.
+Usually an implementation of `AdbDaemonConnection` will provide that along with other useful information about the device. Possible implementations includes:
 
-The backend, instead of the core library, is responsible for serializing and deserializing the packets. Because it's extreme slow for WebUSB backend (`@yume-chan/adb-backend-webusb`) to read packets with unknown size.
+-   WebUSB API
+-   `usb` package for Node.js
+-   Node.js' `net` module (for ADB over WiFi)
+-   Though a WebSockify wrapper (also for ADB over WiFi).
 
-## Authentication
+ADB daemon requires authentication unless built in debug mode. For how ADB authentication work, see https://chensi.moe/blog/2020/09/30/webadb-part2-connection/#auth.
 
-For how does ADB authentication work, see https://chensi.moe/blog/2020/09/30/webadb-part2-connection/#auth.
+Authentication requires two extra components:
 
-In this library, authentication comes in two parts:
+#### `AdbCredentialStore`
 
-#### AdbCredentialStore
+An interface to generate, store and iterate ADB private keys on each runtime. (Because Node.js and Browsers have different APIs to do that)
 
-An interface to generate, store and iterate ADB private keys on each runtime. (Because Node.js and Browsers have different APIs to do this)
+The `@yume-chan/adb-credential-web` package contains a `AdbWebCredentialStore` implementation using Web Crypto API for generating keys and IndexedDB for storing keys.
 
 ##### `generateKey`
 
@@ -109,48 +115,128 @@ Synchronously or asynchronously iterate through all stored RSA private keys.
 
 Each call to `iterateKeys` must return a different iterator that iterate through all stored keys.
 
-##### Implementations
-
-The `@yume-chan/adb-credential-web` package contains a `AdbWebCredentialStore` implementation using Web Crypto API for generating keys and Web Storage API for storing keys.
-
-#### AdbAuthenticator
+#### `AdbAuthenticator`
 
 An `AdbAuthenticator` generates `AUTH` responses for each `AUTH` request from server.
 
-This package contains `AdbSignatureAuthenticator` and `AdbPublicKeyAuthenticator`, the two basic modes.
+This package contains `AdbSignatureAuthenticator` and `AdbPublicKeyAuthenticator` classes for the two basic modes, they all uses the `AdbCredentialStore` to get the private key.
 
 #### `authenticate`
 
 ```ts
-static async authenticate(
+static async authenticate(options: {
     connection: ReadableWritablePair<AdbPacketCore, AdbPacketCore>,
     credentialStore: AdbCredentialStore,
-    authenticators = AdbDefaultAuthenticators,
-): Promise<Adb>
+    authenticators?: AdbAuthenticator[],
+}): Promise<AdbDaemonTransport>
+```
+
+Authenticates the connection and creates an `AdbDaemonTransport` instance that can be used by `Adb` class.
+
+If an authentication process failed, it's possible to call `authenticate` again on the same connection. Because every time the device receives a `CNXN` packet, it resets all internal state, and starts a new authentication process.
+
+#### `addReverseTunnel`
+
+```ts
+public addReverseTunnel(
+    handler: AdbIncomingSocketHandler,
+    address?: string
+): string
+```
+
+Adds a reverse tunnel handler to the transport. It doesn't register the reverse tunnel to the device, for that use `AdbReverseCommand#add` instead. Because the process for ADB to create a tunnel is same as calling a command, `address` can be any string that the ADB daemon might call as a command.
+
+### `AdbServerTransport`
+
+`AdbServerTransport` connects to an ADB server. Because a USB device can only be used by one process at a time, the ADB server is the process that manages all connected devices. The server proxies and multiplexes connections from ADB clients so multiple adb commands can be executed on one device at the same time. `AdbServerTransport` instances can be retrieved from `AdbServerClient` class.
+
+#### `AdbServerClient`
+
+The `AdbServerClient` class implements the client-server protocol to interact with the ADB server. It can query the list of connected devices, detect device connections and disconnections, and invoke other server commands.
+
+It needs an implementation of `AdbServerConnection` interface to actually connects to the ADB server using each runtime's API.
+
+##### `getVersion`
+
+```ts
+public async getVersion(): Promise<string>;
+```
+
+Get the version number of the ADB server. This version is not related to the ADB server-daemon protocol version nor device Android version, it increases when a breaking change is introduced into the client-server protocol.
+
+##### `kill`
+
+```ts
+public async kill(): Promise<void>;
+```
+
+Kill the ADB server, for example if you want to connect to the ADB daemon directly over USB.
+
+##### `getServerFeatures`
+
+```ts
+public async getServerFeatures(): Promise<AdbFeature[]>;
+```
+
+Get the list of ADB features supported by the server.
+
+Generally it's not that useful because most ADB commands only cares about what features the device supports.
+
+##### `getDevices`
+
+```ts
+public async getDevices(): Promise<AdbServerTransport[]>;
 ```
 
-Call this method to authenticate the connection and create an `Adb` instance.
+Get the list of connected devices.
+
+The returned `AdbServerTransport` instance can be supplied to `new Adb` to operate on that device.
+
+##### `AdbServerDeviceSelector`
+
+Some commands target a specific device. `AdbServerDeviceSelector` chooses a device from the list of connected devices.
+
+It can be one of:
+
+-   `undefined`: any one device, will throw an error if there are multiple devices connected. Same as no argument are given to `adb` command.
+-   `{ serial: string }`: a device with the given serial number. Note that multiple devices can have the same serial number (if the manufacturer is lazy), usually it's enough to identify a device. Same as the `-s` argument for the `adb` command.
+-   `{ transportId: number }`: a device with the given transport ID. The transport ID is from the order devices connect. It can be obtained from `getDevices` method. Same as the `-t` argument for the `adb` command.
+-   `{ usb: true }`: any one USB device, will throw an error if there are multiple devices connected via USB. Same as the `-d` argument for the `adb` command.
+-   `{ emulator: true }`: any one TCP device (including emulators and devices connected via ADB over WiFi), will throw an error if there are multiple TCP devices. Same as the `-e` argument for the `adb` command. Same as the `-e` argument for the `adb` command.
+
+The selector will be sent to ADB server and resolved there.
+
+##### `getDeviceFeatures`
 
-If an authentication process failed, it's possible to call `authenticate` again on the same connection (`AdbPacket` stream pair). Every time the device receives a `CNXN` packet, it resets all internal state, and starts a new authentication process.
+```ts
+public async getDeviceFeatures(
+    device: AdbServerDeviceSelector
+): Promise<AdbFeature[]>
+```
+
+Gets the list of ADB features supported by the device. `Adb` class requires this information to choose the correct commands to use.
 
-## Stream multiplex
+##### `waitFor`
 
-ADB commands are all based on streams. Multiple streams can send and receive at the same time in one connection.
+```ts
+public async waitFor(
+    device: AdbServerDeviceSelector,
+    state: "device" | "disconnect",
+    signal?: AbortSignal
+): Promise<void>
+```
 
-1. Client sends an `OPEN` packet to create a stream.
-2. Server responds with `OKAY` or `FAIL`.
-3. Client and server read/write on the stream.
-4. Client/server sends a `CLSE` to close the stream.
+Wait for a specific device to be connected or disconnected. The `AdbServerTransport` instance uses this method to detect device disconnects.
 
 ## Commands
 
 ### subprocess
 
-ADB has two subprocess invocation modes and two data protocols (4 combinations).
+ADB has two subprocess invocation modes and two data protocols (4 combinations). The Shell protocol was added in Android 8 and can be identified by the `shell_v2` feature flag.
 
 #### raw mode
 
-In raw mode, Shell protocol transfers `stdout` and `stderr` separately. It also supports returning exit code.
+In raw mode, Shell protocol transfers `stdout` and `stderr` separately, and supports returning exit code.
 
 |                             | Legacy protocol             | Shell Protocol               |
 | --------------------------- | --------------------------- | ---------------------------- |
@@ -163,13 +249,15 @@ Use `spawn` method to create a subprocess in raw mode.
 
 #### pty mode
 
-In PTY mode, the subprocess has a pseudo-terminal, so it can send special control sequences like clear screen and set cursor position. The two protocols both send data in `stdout`, but Shell Protocol also supports resizing the terminal from client.
+In PTY mode, the subprocess has a pseudo-terminal, so it can send special control sequences like clear screen and set cursor position. The two protocols both send data in `stdout`, but Shell Protocol also supports resizing the terminal from client and returning the exit code.
 
 |                             | Legacy protocol             | Shell Protocol               |
 | --------------------------- | --------------------------- | ---------------------------- |
 | Feature flag                | -                           | `shell_v2`                   |
 | Implementation              | `AdbNoneSubprocessProtocol` | `AdbShellSubprocessProtocol` |
 | Resizing window             | No                          | Yes                          |
+| Splitting stdout and stderr | No                          | No                           |
+| Returning exit code         | No                          | Yes                          |
 
 Use `shell` method to create a subprocess in PTY mode.
 
@@ -183,65 +271,96 @@ Enable ADB over WiFi.
 
 ### sync
 
-Client and server will communicate with another protocol on the opened stream.
+Sync protocol is a sub-protocol of the server-daemon protocol, it allows interacting with the device's filesystem.
 
-#### LIST
+```ts
+public async sync(): Promise<AdbSync>;
+```
 
-Request server to list the content of a folder.
+Creates an `AdbSync` client. The client can send multiple command in sequence, and multiple clients can be created to send commands in parallel.
 
-#### LIS2
+#### `lstat`
 
-Version 2 of the LIST command, contains more information.
+```ts
+public async lstat(path: string): Promise<AdbSyncStat>;
+```
 
-Supported on devices with `ls_v2` feature.
+Gets the information of a file or folder. If `path` points to a symbolic link, the returned information is about the link itself.
 
-#### STAT
+This uses the `STAT` or `LST2` (when supported) sync commands, notice that despite the name of `STAT`, it doesn't resolve symbolic links.
 
-Request server to return the information of a file.
+Same as the [`lstat`](https://linux.die.net/man/2/lstat) system call in Linux.
 
-If path is a symbolic link, the returned information is about the link itself.
+#### `stat`
 
-So it's actually the [`lstat`](https://linux.die.net/man/2/lstat) system call.
+```ts
+public async stat(path: string): Promise<AdbSyncStat>;
+```
 
-#### LST2
+Gets the information of a file or folder. If `path` points to a symbolic link, it will be resolved and the returned information is about the target.
 
-Version 2 of the STAT command, contains more information.
+Uses the `STA2` sync command, which requires the `stat_v2` feature flag. Will throw an error if device doesn't support that.
 
-Supported on devices with `stat_v2` feature.
+Same as the `stat` system call in Linux.
 
-#### STA2
+#### `isDirectory`
 
-Basically identical to LST2, but if path is a symbolic link, the information is about the file it refers to.
+```ts
+public async isDirectory(path: string): Promise<boolean>
+```
 
-Supported on devices with `stat_v2` feature.
+Checks if `path` is a directory, or a symbolic link to a directory.
 
-#### RECV
+This uses `lstat` internally, thus works on all Android versions.
 
-Request server to send the content of a file.
+#### `opendir`
 
-#### RCV2
+```ts
+public opendir(path: string): AsyncGenerator<AdbSyncEntry, void, void>;
+```
 
-*(Not Implemented)*
+Returns an async generator that yields the content of a folder.
 
-Version 2 of the RECV command.
+Example:
 
-Supported on devices with `sendrecv_v2` feature.
+```ts
+for await (const entry of this.opendir(path)) {
+    console.log(entry.name, entry.size);
+}
+```
 
-#### SEND
+#### `readdir`
 
-*(Not Implemented)*
+```ts
+public async readdir(path: string): Promise<AdbSyncEntry>
+```
+
+Collects the result of `opendir` into an array. Useful if you want to send other commands using the same `AdbSync` instance while iterating the folder.
+
+#### `read`
 
-Send a file onto server's file system.
+```ts
+public read(filename: string): ReadableStream<Uint8Array>
+```
 
-#### SND2
+Reads the content of a file on device.
 
-*(Not Implemented)*
+#### `write`
 
-Version 2 of the SEND command.
+```ts
+public async write(options: {
+    filename: string;
+    file: ReadableStream<Consumable<Uint8Array>>;
+    type?: LinuxFileType;
+    permission?: number;
+    mtime?: number;
+    dryRun?: boolean;
+})
+```
 
-Supported on devices with `sendrecv_v2` feature.
+Writes a file on device. If the file name already exists, it will be overwritten.
 
 ## Useful links
 
-* [ADB protocol overview](https://android.googlesource.com/platform/packages/modules/adb/+/2fd69306184634c6d90db3ed3be5349e71dcc471/OVERVIEW.TXT)
-* [ADB commands](https://android.googlesource.com/platform/packages/modules/adb/+/2fd69306184634c6d90db3ed3be5349e71dcc471/SERVICES.TXT#145)
+-   [ADB protocol overview](https://android.googlesource.com/platform/packages/modules/adb/+/2fd69306184634c6d90db3ed3be5349e71dcc471/OVERVIEW.TXT)
+-   [ADB commands](https://android.googlesource.com/platform/packages/modules/adb/+/2fd69306184634c6d90db3ed3be5349e71dcc471/SERVICES.TXT#145)

package/esm/adb.d.ts

@@ -1,64 +1,47 @@
 import type { Consumable, ReadableWritablePair } from "@yume-chan/stream-extra";
-import type { AdbCredentialStore } from "./auth.js";
+import type { ValueOrPromise } from "@yume-chan/struct";
+import type { AdbBanner } from "./banner.js";
 import type { AdbFrameBuffer } from "./commands/index.js";
 import { AdbPower, AdbReverseCommand, AdbSubprocess, AdbSync, AdbTcpIpCommand } from "./commands/index.js";
-import { AdbFeature } from "./features.js";
-import type { AdbPacketData, AdbPacketInit } from "./packet.js";
-import type { AdbIncomingSocketHandler, AdbSocket, Closeable } from "./socket/index.js";
-export declare enum AdbPropKey {
-    Product = "ro.product.name",
-    Model = "ro.product.model",
-    Device = "ro.product.device",
-    Features = "features"
+import type { AdbFeature } from "./features.js";
+export interface AdbSocket extends ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>, Closeable {
+    readonly service: string;
+}
+export type AdbIncomingSocketHandler = (socket: AdbSocket) => ValueOrPromise<void>;
+export interface Closeable {
+    close(): ValueOrPromise<void>;
+}
+export interface AdbTransport extends Closeable {
+    readonly serial: string;
+    readonly maxPayloadSize: number;
+    readonly banner: AdbBanner;
+    readonly disconnected: Promise<void>;
+    connect(service: string): ValueOrPromise<AdbSocket>;
+    addReverseTunnel(handler: AdbIncomingSocketHandler, address?: string): ValueOrPromise<string>;
+    removeReverseTunnel(address: string): ValueOrPromise<void>;
+    clearReverseTunnels(): ValueOrPromise<void>;
 }
-export declare const VERSION_OMIT_CHECKSUM = 16777217;
 export declare class Adb implements Closeable {
-    /**
-     * It's possible to call `authenticate` multiple times on a single connection,
-     * every time the device receives a `CNXN` packet, it resets its internal state,
-     * and starts a new authentication process.
-     */
-    static authenticate(connection: ReadableWritablePair<AdbPacketData, Consumable<AdbPacketInit>>, credentialStore: AdbCredentialStore, authenticators?: import("./auth.js").AdbAuthenticator[]): Promise<Adb>;
-    private readonly dispatcher;
-    get disconnected(): Promise<void>;
-    private _protocolVersion;
-    get protocolVersion(): number;
-    private _maxPayloadSize;
+    readonly transport: AdbTransport;
+    get serial(): string;
     get maxPayloadSize(): number;
-    private _product;
-    get product(): string | undefined;
-    private _model;
-    get model(): string | undefined;
-    private _device;
-    get device(): string | undefined;
-    private _features;
-    get features(): AdbFeature[];
+    get banner(): AdbBanner;
+    get disconnected(): Promise<void>;
     readonly subprocess: AdbSubprocess;
     readonly power: AdbPower;
     readonly reverse: AdbReverseCommand;
     readonly tcpip: AdbTcpIpCommand;
-    constructor(connection: ReadableWritablePair<AdbPacketData, Consumable<AdbPacketInit>>, version: number, maxPayloadSize: number, banner: string);
-    private parseBanner;
+    constructor(transport: AdbTransport);
     supportsFeature(feature: AdbFeature): boolean;
-    /**
-     * Add a handler for incoming socket.
-     * @param handler A function to call with new incoming sockets. It must return `true` if it accepts the socket.
-     * @returns A function to remove the handler.
-     */
-    onIncomingSocket(handler: AdbIncomingSocketHandler): import("@yume-chan/event").RemoveEventListener;
     createSocket(service: string): Promise<AdbSocket>;
     createSocketAndWait(service: string): Promise<string>;
     getProp(key: string): Promise<string>;
-    rm(...filenames: string[]): Promise<string>;
+    rm(filenames: string | string[], options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<string>;
     sync(): Promise<AdbSync>;
     framebuffer(): Promise<AdbFrameBuffer>;
-    /**
-     * Close the ADB connection.
-     *
-     * Note that it won't close the streams from backends.
-     * The streams are both physically and logically intact,
-     * and can be reused.
-     */
     close(): Promise<void>;
 }
 //# sourceMappingURL=adb.d.ts.map