@yume-chan/adb 0.0.17 → 0.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yume-chan/adb",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "TypeScript implementation of Android Debug Bridge (ADB) protocol.",
   "keywords": [
     "adb",
@@ -26,24 +26,28 @@
   "types": "esm/index.d.ts",
   "dependencies": {
     "@yume-chan/async": "^2.2.0",
-    "@yume-chan/dataview-bigint-polyfill": "^0.0.17",
-    "@yume-chan/event": "^0.0.17",
-    "@yume-chan/stream-extra": "^0.0.17",
-    "@yume-chan/struct": "^0.0.17",
-    "tslib": "^2.4.0"
+    "@yume-chan/dataview-bigint-polyfill": "^0.0.19",
+    "@yume-chan/event": "^0.0.19",
+    "@yume-chan/stream-extra": "^0.0.19",
+    "@yume-chan/struct": "^0.0.19",
+    "tslib": "^2.4.1"
   },
   "devDependencies": {
-    "@jest/globals": "^28.1.2",
-    "@types/node": "^17.0.17",
-    "@yume-chan/ts-package-builder": "^1.0.0",
+    "@jest/globals": "^29.5.0",
+    "@types/node": "^18.15.0",
+    "@yume-chan/eslint-config": "^1.0.0",
+    "@yume-chan/tsconfig": "^1.0.0",
     "cross-env": "^7.0.3",
-    "jest": "^28.1.2",
-    "ts-jest": "^28.0.5",
-    "typescript": "^4.7.4"
+    "eslint": "^8.36.0",
+    "jest": "^29.5.0",
+    "prettier": "^2.8.4",
+    "ts-jest": "^29.0.4",
+    "typescript": "^4.9.4"
   },
   "scripts": {
     "build": "tsc -b tsconfig.build.json",
     "build:watch": "tsc -b tsconfig.build.json",
-    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --coverage"
+    "test": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --coverage",
+    "lint": "eslint src/**/*.ts --fix && prettier src/**/*.ts --write --tab-width 4"
   }
 }

package/src/adb.ts

@@ -1,20 +1,44 @@
-// cspell: ignore libusb
-
-import { PromiseResolver } from '@yume-chan/async';
-import { AbortController, DecodeUtf8Stream, GatherStringStream, WritableStream, type ReadableWritablePair } from '@yume-chan/stream-extra';
-
-import { AdbAuthenticationProcessor, ADB_DEFAULT_AUTHENTICATORS, type AdbCredentialStore } from './auth.js';
-import { AdbPower, AdbReverseCommand, AdbSubprocess, AdbSync, AdbTcpIpCommand, escapeArg, framebuffer, install, type AdbFrameBuffer } from './commands/index.js';
-import { AdbFeatures } from './features.js';
-import { AdbCommand, calculateChecksum, type AdbPacketData, type AdbPacketInit } from './packet.js';
-import { AdbIncomingSocketHandler, AdbPacketDispatcher, type AdbSocket, type Closeable } from './socket/index.js';
-import { decodeUtf8, encodeUtf8 } from './utils/index.js';
+import { PromiseResolver } from "@yume-chan/async";
+import type { Consumable, ReadableWritablePair } from "@yume-chan/stream-extra";
+import {
+    AbortController,
+    ConsumableWritableStream,
+    DecodeUtf8Stream,
+    GatherStringStream,
+    WritableStream,
+} from "@yume-chan/stream-extra";
+
+import type { AdbCredentialStore } from "./auth.js";
+import {
+    ADB_DEFAULT_AUTHENTICATORS,
+    AdbAuthenticationProcessor,
+} from "./auth.js";
+import type { AdbFrameBuffer } from "./commands/index.js";
+import {
+    AdbPower,
+    AdbReverseCommand,
+    AdbSubprocess,
+    AdbSync,
+    AdbTcpIpCommand,
+    escapeArg,
+    framebuffer,
+} from "./commands/index.js";
+import { AdbFeature } from "./features.js";
+import type { AdbPacketData, AdbPacketInit } from "./packet.js";
+import { AdbCommand, calculateChecksum } from "./packet.js";
+import type {
+    AdbIncomingSocketHandler,
+    AdbSocket,
+    Closeable,
+} from "./socket/index.js";
+import { AdbPacketDispatcher } from "./socket/index.js";
+import { decodeUtf8, encodeUtf8 } from "./utils/index.js";
 
 export enum AdbPropKey {
-    Product = 'ro.product.name',
-    Model = 'ro.product.model',
-    Device = 'ro.product.device',
-    Features = 'features',
+    Product = "ro.product.name",
+    Model = "ro.product.model",
+    Device = "ro.product.device",
+    Features = "features",
 }
 
 export const VERSION_OMIT_CHECKSUM = 0x01000001;
@@ -26,47 +50,63 @@ export class Adb implements Closeable {
      * and starts a new authentication process.
      */
     public static async authenticate(
-        connection: ReadableWritablePair<AdbPacketData, AdbPacketInit>,
+        connection: ReadableWritablePair<
+            AdbPacketData,
+            Consumable<AdbPacketInit>
+        >,
         credentialStore: AdbCredentialStore,
-        authenticators = ADB_DEFAULT_AUTHENTICATORS,
+        authenticators = ADB_DEFAULT_AUTHENTICATORS
     ): Promise<Adb> {
         // Initially, set to highest-supported version and payload size.
         let version = 0x01000001;
-        let maxPayloadSize = 0x100000;
+        // Android 4: 4K, Android 7: 256K, Android 9: 1M
+        let maxPayloadSize = 1024 * 1024;
 
         const resolver = new PromiseResolver<string>();
-        const authProcessor = new AdbAuthenticationProcessor(authenticators, credentialStore);
+        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;
-                    }
+            .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,
                 }
-            }), {
-                // Don't cancel the source ReadableStream on AbortSignal abort.
-                preventCancel: true,
-                signal: abortController.signal,
-            })
+            )
             .catch((e) => {
                 resolver.reject(e);
             });
@@ -75,7 +115,9 @@ export class Adb implements Closeable {
         async function sendPacket(init: AdbPacketData) {
             // Always send checksum in auth steps
             // Because we don't know if the device needs it or not.
-            await writer.write(calculateChecksum(init));
+            (init as AdbPacketInit).checksum = calculateChecksum(init.payload);
+            (init as AdbPacketInit).magic = init.command ^ 0xffffffff;
+            await ConsumableWritableStream.write(writer, init as AdbPacketInit);
         }
 
         let banner: string;
@@ -83,25 +125,25 @@ export class Adb implements Closeable {
             // 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).
             const features = [
-                AdbFeatures.ShellV2,
-                AdbFeatures.Cmd,
-                AdbFeatures.StatV2,
-                AdbFeatures.ListV2,
-                AdbFeatures.FixedPushMkdir,
-                'apex',
-                'abb',
+                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',
-                'abb_exec',
-                'remount_shell',
-                'track_app',
-                'sendrecv_v2',
-                'sendrecv_v2_brotli',
-                'sendrecv_v2_lz4',
-                'sendrecv_v2_zstd',
-                'sendrecv_v2_dry_run_send',
-            ].join(',');
+                "fixed_push_symlink_timestamp",
+                AdbFeature.AbbExec,
+                "remount_shell",
+                "track_app",
+                "sendrecv_v2",
+                "sendrecv_v2_brotli",
+                "sendrecv_v2_lz4",
+                "sendrecv_v2_zstd",
+                "sendrecv_v2_dry_run_send",
+            ].join(",");
 
             await sendPacket({
                 command: AdbCommand.Connect,
@@ -123,32 +165,44 @@ export class Adb implements Closeable {
             await pipe;
         }
 
-        return new Adb(
-            connection,
-            version,
-            maxPayloadSize,
-            banner,
-        );
+        return new Adb(connection, version, maxPayloadSize, banner);
     }
 
     private readonly dispatcher: AdbPacketDispatcher;
 
-    public get disconnected() { return this.dispatcher.disconnected; }
+    public get disconnected() {
+        return this.dispatcher.disconnected;
+    }
 
-    private _protocolVersion: number | undefined;
-    public get protocolVersion() { return this._protocolVersion; }
+    private _protocolVersion: number;
+    public get protocolVersion() {
+        return this._protocolVersion;
+    }
+
+    private _maxPayloadSize: number;
+    public get maxPayloadSize() {
+        return this._maxPayloadSize;
+    }
 
     private _product: string | undefined;
-    public get product() { return this._product; }
+    public get product() {
+        return this._product;
+    }
 
     private _model: string | undefined;
-    public get model() { return this._model; }
+    public get model() {
+        return this._model;
+    }
 
     private _device: string | undefined;
-    public get device() { return this._device; }
+    public get device() {
+        return this._device;
+    }
 
-    private _features: AdbFeatures[] = [];
-    public get features() { return this._features; }
+    private _features: AdbFeature[] = [];
+    public get features() {
+        return this._features;
+    }
 
     public readonly subprocess: AdbSubprocess;
     public readonly power: AdbPower;
@@ -156,10 +210,13 @@ export class Adb implements Closeable {
     public readonly tcpip: AdbTcpIpCommand;
 
     public constructor(
-        connection: ReadableWritablePair<AdbPacketData, AdbPacketInit>,
+        connection: ReadableWritablePair<
+            AdbPacketData,
+            Consumable<AdbPacketInit>
+        >,
         version: number,
         maxPayloadSize: number,
-        banner: string,
+        banner: string
     ) {
         this.parseBanner(banner);
 
@@ -173,16 +230,14 @@ export class Adb implements Closeable {
             appendNullToServiceString = true;
         }
 
-        this.dispatcher = new AdbPacketDispatcher(
-            connection,
-            {
-                calculateChecksum,
-                appendNullToServiceString,
-                maxPayloadSize,
-            }
-        );
+        this.dispatcher = new AdbPacketDispatcher(connection, {
+            calculateChecksum,
+            appendNullToServiceString,
+            maxPayloadSize,
+        });
 
         this._protocolVersion = version;
+        this._maxPayloadSize = maxPayloadSize;
 
         this.subprocess = new AdbSubprocess(this);
         this.power = new AdbPower(this);
@@ -191,15 +246,15 @@ export class Adb implements Closeable {
     }
 
     private parseBanner(banner: string): void {
-        const pieces = banner.split('::');
+        const pieces = banner.split("::");
         if (pieces.length > 1) {
             const props = pieces[1]!;
-            for (const prop of props.split(';')) {
+            for (const prop of props.split(";")) {
                 if (!prop) {
                     continue;
                 }
 
-                const keyValue = prop.split('=');
+                const keyValue = prop.split("=");
                 if (keyValue.length !== 2) {
                     continue;
                 }
@@ -216,13 +271,17 @@ export class Adb implements Closeable {
                         this._device = value;
                         break;
                     case AdbPropKey.Features:
-                        this._features = value!.split(',') as AdbFeatures[];
+                        this._features = value!.split(",") as AdbFeature[];
                         break;
                 }
             }
         }
     }
 
+    public supportsFeature(feature: AdbFeature): boolean {
+        return this._features.includes(feature);
+    }
+
     /**
      * 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.
@@ -246,25 +305,25 @@ export class Adb implements Closeable {
     }
 
     public async getProp(key: string): Promise<string> {
-        const stdout = await this.subprocess.spawnAndWaitLegacy(
-            ['getprop', key]
-        );
+        const stdout = await this.subprocess.spawnAndWaitLegacy([
+            "getprop",
+            key,
+        ]);
         return stdout.trim();
     }
 
     public async rm(...filenames: string[]): Promise<string> {
-        const stdout = await this.subprocess.spawnAndWaitLegacy(
-            ['rm', '-rf', ...filenames.map(arg => escapeArg(arg))],
-        );
+        // https://android.googlesource.com/platform/packages/modules/adb/+/1a0fb8846d4e6b671c8aa7f137a8c21d7b248716/client/adb_install.cpp#984
+        const stdout = await this.subprocess.spawnAndWaitLegacy([
+            "rm",
+            ...filenames.map((arg) => escapeArg(arg)),
+            "</dev/null",
+        ]);
         return stdout;
     }
 
-    public install() {
-        return install(this);
-    }
-
     public async sync(): Promise<AdbSync> {
-        const socket = await this.createSocket('sync:');
+        const socket = await this.createSocket("sync:");
         return new AdbSync(this, socket);
     }
 

package/src/auth.ts

@@ -1,10 +1,15 @@
-import { PromiseResolver } from '@yume-chan/async';
-import type { Disposable } from '@yume-chan/event';
-import type { ValueOrPromise } from '@yume-chan/struct';
-
-import { calculatePublicKey, calculatePublicKeyLength, sign } from './crypto.js';
-import { AdbCommand, type AdbPacketData } from './packet.js';
-import { calculateBase64EncodedLength, encodeBase64 } from './utils/index.js';
+import { PromiseResolver } from "@yume-chan/async";
+import type { Disposable } from "@yume-chan/event";
+import type { ValueOrPromise } from "@yume-chan/struct";
+
+import {
+    calculatePublicKey,
+    calculatePublicKeyLength,
+    sign,
+} from "./crypto.js";
+import type { AdbPacketData } from "./packet.js";
+import { AdbCommand } from "./packet.js";
+import { calculateBase64EncodedLength, encodeBase64 } from "./utils/index.js";
 
 export type AdbKeyIterable = Iterable<Uint8Array> | AsyncIterable<Uint8Array>;
 
@@ -50,7 +55,7 @@ export interface AdbAuthenticator {
 
 export const AdbSignatureAuthenticator: AdbAuthenticator = async function* (
     credentialStore: AdbCredentialStore,
-    getNextRequest: () => Promise<AdbPacketData>,
+    getNextRequest: () => Promise<AdbPacketData>
 ): AsyncIterable<AdbPacketData> {
     for await (const key of credentialStore.iterateKeys()) {
         const packet = await getNextRequest();
@@ -71,7 +76,7 @@ export const AdbSignatureAuthenticator: AdbAuthenticator = async function* (
 
 export const AdbPublicKeyAuthenticator: AdbAuthenticator = async function* (
     credentialStore: AdbCredentialStore,
-    getNextRequest: () => Promise<AdbPacketData>,
+    getNextRequest: () => Promise<AdbPacketData>
 ): AsyncIterable<AdbPacketData> {
     const packet = await getNextRequest();
 
@@ -85,23 +90,20 @@ export const AdbPublicKeyAuthenticator: AdbAuthenticator = async function* (
         break;
     }
 
-
     if (!privateKey) {
         privateKey = await credentialStore.generateKey();
     }
 
     const publicKeyLength = calculatePublicKeyLength();
-    const [publicKeyBase64Length] = calculateBase64EncodedLength(publicKeyLength);
+    const [publicKeyBase64Length] =
+        calculateBase64EncodedLength(publicKeyLength);
 
-    // The public key is null terminated,
-    // So we allocate the buffer with one extra byte.
-    const publicKeyBuffer = new Uint8Array(publicKeyBase64Length + 1);
+    const publicKeyBuffer = new Uint8Array(
+        publicKeyBase64Length + 1 // Null character
+    );
 
     calculatePublicKey(privateKey, publicKeyBuffer);
-    encodeBase64(
-        publicKeyBuffer.subarray(0, publicKeyLength),
-        publicKeyBuffer
-    );
+    encodeBase64(publicKeyBuffer.subarray(0, publicKeyLength), publicKeyBuffer);
 
     yield {
         command: AdbCommand.Auth,
@@ -137,9 +139,16 @@ export class AdbAuthenticationProcessor implements Disposable {
         return this.pendingRequest.promise;
     };
 
-    private async* invokeAuthenticator(): AsyncGenerator<AdbPacketData, void, void> {
+    private async *invokeAuthenticator(): AsyncGenerator<
+        AdbPacketData,
+        void,
+        void
+    > {
         for (const authenticator of this.authenticators) {
-            for await (const packet of authenticator(this.credentialStore, this.getNextRequest)) {
+            for await (const packet of authenticator(
+                this.credentialStore,
+                this.getNextRequest
+            )) {
                 // If the authenticator yielded a response
                 // Prepare `nextRequest` for next authentication request
                 this.pendingRequest = new PromiseResolver();
@@ -162,13 +171,13 @@ export class AdbAuthenticationProcessor implements Disposable {
 
         const result = await this.iterator.next();
         if (result.done) {
-            throw new Error('No authenticator can handle the request');
+            throw new Error("No authenticator can handle the request");
         }
 
         return result.value;
     }
 
     public dispose() {
-        this.iterator?.return?.();
+        void this.iterator?.return?.();
     }
 }

package/src/backend.ts

@@ -1,12 +1,14 @@
-import type { ReadableWritablePair } from '@yume-chan/stream-extra';
-import type { ValueOrPromise } from '@yume-chan/struct';
+import type { Consumable, ReadableWritablePair } from "@yume-chan/stream-extra";
+import type { ValueOrPromise } from "@yume-chan/struct";
 
-import type { AdbPacketData, AdbPacketInit } from './packet.js';
+import type { AdbPacketData, AdbPacketInit } from "./packet.js";
 
 export interface AdbBackend {
     readonly serial: string;
 
     readonly name: string | undefined;
 
-    connect(): ValueOrPromise<ReadableWritablePair<AdbPacketData, AdbPacketInit>>;
+    connect(): ValueOrPromise<
+        ReadableWritablePair<AdbPacketData, Consumable<AdbPacketInit>>
+    >;
 }

package/src/commands/base.ts

@@ -1,6 +1,6 @@
-import { AutoDisposable } from '@yume-chan/event';
+import { AutoDisposable } from "@yume-chan/event";
 
-import type { Adb } from '../adb.js';
+import type { Adb } from "../adb.js";
 
 export class AdbCommandBase extends AutoDisposable {
     protected adb: Adb;

package/src/commands/framebuffer.ts

@@ -1,48 +1,44 @@
-import { BufferedReadableStream } from '@yume-chan/stream-extra';
-import Struct from '@yume-chan/struct';
+import { BufferedReadableStream } from "@yume-chan/stream-extra";
+import Struct from "@yume-chan/struct";
 
-import type { Adb } from '../adb.js';
+import type { Adb } from "../adb.js";
 
-const Version =
-    new Struct({ littleEndian: true })
-        .uint32('version');
+const Version = new Struct({ littleEndian: true }).uint32("version");
 
-export const AdbFrameBufferV1 =
-    new Struct({ littleEndian: true })
-        .uint32('bpp')
-        .uint32('size')
-        .uint32('width')
-        .uint32('height')
-        .uint32('red_offset')
-        .uint32('red_length')
-        .uint32('blue_offset')
-        .uint32('blue_length')
-        .uint32('green_offset')
-        .uint32('green_length')
-        .uint32('alpha_offset')
-        .uint32('alpha_length')
-        .uint8Array('data', { lengthField: 'size' });
+export const AdbFrameBufferV1 = new Struct({ littleEndian: true })
+    .uint32("bpp")
+    .uint32("size")
+    .uint32("width")
+    .uint32("height")
+    .uint32("red_offset")
+    .uint32("red_length")
+    .uint32("blue_offset")
+    .uint32("blue_length")
+    .uint32("green_offset")
+    .uint32("green_length")
+    .uint32("alpha_offset")
+    .uint32("alpha_length")
+    .uint8Array("data", { lengthField: "size" });
 
-export type AdbFrameBufferV1 = typeof AdbFrameBufferV1['TDeserializeResult'];
+export type AdbFrameBufferV1 = (typeof AdbFrameBufferV1)["TDeserializeResult"];
 
-export const AdbFrameBufferV2 =
-    new Struct({ littleEndian: true })
-        .uint32('bpp')
-        .uint32('colorSpace')
-        .uint32('size')
-        .uint32('width')
-        .uint32('height')
-        .uint32('red_offset')
-        .uint32('red_length')
-        .uint32('blue_offset')
-        .uint32('blue_length')
-        .uint32('green_offset')
-        .uint32('green_length')
-        .uint32('alpha_offset')
-        .uint32('alpha_length')
-        .uint8Array('data', { lengthField: 'size' });
+export const AdbFrameBufferV2 = new Struct({ littleEndian: true })
+    .uint32("bpp")
+    .uint32("colorSpace")
+    .uint32("size")
+    .uint32("width")
+    .uint32("height")
+    .uint32("red_offset")
+    .uint32("red_length")
+    .uint32("blue_offset")
+    .uint32("blue_length")
+    .uint32("green_offset")
+    .uint32("green_length")
+    .uint32("alpha_offset")
+    .uint32("alpha_length")
+    .uint8Array("data", { lengthField: "size" });
 
-export type AdbFrameBufferV2 = typeof AdbFrameBufferV2['TDeserializeResult'];
+export type AdbFrameBufferV2 = (typeof AdbFrameBufferV2)["TDeserializeResult"];
 
 /**
  * ADB uses 8 int32 fields to describe bit depths
@@ -63,7 +59,7 @@ export type AdbFrameBufferV2 = typeof AdbFrameBufferV2['TDeserializeResult'];
 export type AdbFrameBuffer = AdbFrameBufferV1 | AdbFrameBufferV2;
 
 export async function framebuffer(adb: Adb): Promise<AdbFrameBuffer> {
-    const socket = await adb.createSocket('framebuffer:');
+    const socket = await adb.createSocket("framebuffer:");
     const stream = new BufferedReadableStream(socket.readable);
     const { version } = await Version.deserialize(stream);
     switch (version) {
@@ -73,6 +69,6 @@ export async function framebuffer(adb: Adb): Promise<AdbFrameBuffer> {
         case 2:
             return AdbFrameBufferV2.deserialize(stream);
         default:
-            throw new Error('Unknown FrameBuffer version');
+            throw new Error("Unsupported FrameBuffer version");
     }
 }