@yume-chan/adb 0.0.18 → 0.0.20

package/src/commands/sync/sync.ts

@@ -1,22 +1,16 @@
 import { AutoDisposable } from "@yume-chan/event";
-import {
-    BufferedReadableStream,
-    WrapReadableStream,
-    WrapWritableStream,
-    type ReadableStream,
-    type WritableStream,
-    type WritableStreamDefaultWriter,
-} from "@yume-chan/stream-extra";
-
-import { type Adb } from "../../adb.js";
-import { AdbFeatures } from "../../features.js";
-import { type AdbSocket } from "../../socket/index.js";
-import { AutoResetEvent } from "../../utils/index.js";
+import type { Consumable, ReadableStream } from "@yume-chan/stream-extra";
+
+import type { Adb, AdbSocket } from "../../adb.js";
+import { AdbFeature } from "../../features.js";
 import { escapeArg } from "../subprocess/index.js";
 
-import { adbSyncOpenDir, type AdbSyncEntry } from "./list.js";
+import type { AdbSyncEntry } from "./list.js";
+import { adbSyncOpenDir } from "./list.js";
 import { adbSyncPull } from "./pull.js";
 import { adbSyncPush } from "./push.js";
+import { AdbSyncSocket } from "./socket.js";
+import type { AdbSyncStat, LinuxFileType } from "./stat.js";
 import { adbSyncLstat, adbSyncStat } from "./stat.js";
 
 /**
@@ -35,57 +29,65 @@ export function dirname(path: string): string {
     return path.substring(0, end);
 }
 
+export interface AdbSyncWriteOptions {
+    filename: string;
+    file: ReadableStream<Consumable<Uint8Array>>;
+    type?: LinuxFileType;
+    permission?: number;
+    mtime?: number;
+    dryRun?: boolean;
+}
+
 export class AdbSync extends AutoDisposable {
-    protected adb: Adb;
+    protected _adb: Adb;
+    protected _socket: AdbSyncSocket;
 
-    protected stream: BufferedReadableStream;
-    // Getting another writer on a locked WritableStream will throw.
-    // We don't want this behavior on higher-level APIs.
-    // So we acquire the writer early and use a blocking lock to guard it.
-    protected writer: WritableStreamDefaultWriter<Uint8Array>;
-    protected sendLock = this.addDisposable(new AutoResetEvent());
+    readonly #supportsStat: boolean;
+    readonly #supportsListV2: boolean;
+    readonly #fixedPushMkdir: boolean;
+    readonly #supportsSendReceiveV2: boolean;
+    readonly #needPushMkdirWorkaround: boolean;
 
     public get supportsStat(): boolean {
-        return this.adb.features.includes(AdbFeatures.StatV2);
+        return this.#supportsStat;
     }
 
-    public get supportsList2(): boolean {
-        return this.adb.features.includes(AdbFeatures.ListV2);
+    public get supportsListV2(): boolean {
+        return this.#supportsListV2;
     }
 
     public get fixedPushMkdir(): boolean {
-        return this.adb.features.includes(AdbFeatures.FixedPushMkdir);
+        return this.#fixedPushMkdir;
+    }
+
+    public get supportsSendReceiveV2(): boolean {
+        return this.#supportsSendReceiveV2;
     }
 
     public get needPushMkdirWorkaround(): boolean {
-        // https://android.googlesource.com/platform/packages/modules/adb/+/91768a57b7138166e0a3d11f79cd55909dda7014/client/file_sync_client.cpp#1361
-        return (
-            this.adb.features.includes(AdbFeatures.ShellV2) &&
-            !this.fixedPushMkdir
-        );
+        return this.#needPushMkdirWorkaround;
     }
 
     public constructor(adb: Adb, socket: AdbSocket) {
         super();
 
-        this.adb = adb;
-        this.stream = new BufferedReadableStream(socket.readable);
-        this.writer = socket.writable.getWriter();
-    }
+        this._adb = adb;
+        this._socket = new AdbSyncSocket(socket, adb.maxPayloadSize);
 
-    public async lstat(path: string) {
-        await this.sendLock.wait();
+        this.#supportsStat = adb.supportsFeature(AdbFeature.StatV2);
+        this.#supportsListV2 = adb.supportsFeature(AdbFeature.ListV2);
+        this.#fixedPushMkdir = adb.supportsFeature(AdbFeature.FixedPushMkdir);
+        this.#supportsSendReceiveV2 = adb.supportsFeature(
+            AdbFeature.SendReceiveV2
+        );
+        // https://android.googlesource.com/platform/packages/modules/adb/+/91768a57b7138166e0a3d11f79cd55909dda7014/client/file_sync_client.cpp#1361
+        this.#needPushMkdirWorkaround =
+            this._adb.supportsFeature(AdbFeature.ShellV2) &&
+            !this.fixedPushMkdir;
+    }
 
-        try {
-            return adbSyncLstat(
-                this.stream,
-                this.writer,
-                path,
-                this.supportsStat
-            );
-        } finally {
-            this.sendLock.notify();
-        }
+    public async lstat(path: string): Promise<AdbSyncStat> {
+        return await adbSyncLstat(this._socket, path, this.supportsStat);
     }
 
     public async stat(path: string) {
@@ -93,13 +95,7 @@ export class AdbSync extends AutoDisposable {
             throw new Error("Not supported");
         }
 
-        await this.sendLock.wait();
-
-        try {
-            return adbSyncStat(this.stream, this.writer, path);
-        } finally {
-            this.sendLock.notify();
-        }
+        return await adbSyncStat(this._socket, path);
     }
 
     public async isDirectory(path: string): Promise<boolean> {
@@ -111,21 +107,8 @@ export class AdbSync extends AutoDisposable {
         }
     }
 
-    public async *opendir(
-        path: string
-    ): AsyncGenerator<AdbSyncEntry, void, void> {
-        await this.sendLock.wait();
-
-        try {
-            yield* adbSyncOpenDir(
-                this.stream,
-                this.writer,
-                path,
-                this.supportsList2
-            );
-        } finally {
-            this.sendLock.notify();
-        }
+    public opendir(path: string): AsyncGenerator<AdbSyncEntry, void, void> {
+        return adbSyncOpenDir(this._socket, path, this.supportsListV2);
     }
 
     public async readdir(path: string) {
@@ -137,67 +120,41 @@ export class AdbSync extends AutoDisposable {
     }
 
     /**
-     * Read the content of a file on device.
+     * Reads the content of a file on device.
      *
      * @param filename The full path of the file on device to read.
-     * @returns A `ReadableStream` that reads from the file.
+     * @returns A `ReadableStream` that contains the file content.
      */
     public read(filename: string): ReadableStream<Uint8Array> {
-        return new WrapReadableStream({
-            start: async () => {
-                await this.sendLock.wait();
-                return adbSyncPull(this.stream, this.writer, filename);
-            },
-            close: () => {
-                this.sendLock.notify();
-            },
-        });
+        return adbSyncPull(this._socket, filename);
     }
 
     /**
-     * Write (or overwrite) a file on device.
+     * Writes a file on device. If the file name already exists, it will be overwritten.
      *
-     * @param filename The full path of the file on device to write.
-     * @param mode The unix permissions of the file.
-     * @param mtime The modified time of the file.
-     * @returns A `WritableStream` that writes to the file.
+     * @param options The content and options of the file to write.
      */
-    public write(
-        filename: string,
-        mode?: number,
-        mtime?: number
-    ): WritableStream<Uint8Array> {
-        return new WrapWritableStream({
-            start: async () => {
-                await this.sendLock.wait();
-
-                if (this.needPushMkdirWorkaround) {
-                    // It may fail if the path is already existed.
-                    // Ignore the result.
-                    // TODO: sync: test push mkdir workaround (need an Android 8 device)
-                    await this.adb.subprocess.spawnAndWait([
-                        "mkdir",
-                        "-p",
-                        escapeArg(dirname(filename)),
-                    ]);
-                }
-
-                return adbSyncPush(
-                    this.stream,
-                    this.writer,
-                    filename,
-                    mode,
-                    mtime
-                );
-            },
-            close: () => {
-                this.sendLock.notify();
-            },
+    public async write(options: AdbSyncWriteOptions): Promise<void> {
+        if (this.needPushMkdirWorkaround) {
+            // It may fail if the path is already existed.
+            // Ignore the result.
+            // TODO: sync: test push mkdir workaround (need an Android 8 device)
+            await this._adb.subprocess.spawnAndWait([
+                "mkdir",
+                "-p",
+                escapeArg(dirname(options.filename)),
+            ]);
+        }
+
+        await adbSyncPush({
+            v2: this.supportsSendReceiveV2,
+            socket: this._socket,
+            ...options,
         });
     }
 
     public override async dispose() {
         super.dispose();
-        await this.writer.close();
+        await this._socket.close();
     }
 }

package/src/commands/tcpip.ts

@@ -1,21 +1,23 @@
-import { AdbCommandBase } from './base.js';
+import { AdbCommandBase } from "./base.js";
 
 export class AdbTcpIpCommand extends AdbCommandBase {
-    public async setPort(port: number): Promise<void> {
+    public async setPort(port: number): Promise<string> {
         if (port <= 0) {
             throw new Error(`Invalid port ${port}`);
         }
 
         const output = await this.adb.createSocketAndWait(`tcpip:${port}`);
         if (output !== `restarting in TCP mode port: ${port}\n`) {
-            throw new Error('Invalid response');
+            throw new Error(output);
         }
+        return output;
     }
 
-    public async disable(): Promise<void> {
-        const output = await this.adb.createSocketAndWait('usb:');
-        if (output !== 'restarting in USB mode\n') {
-            throw new Error('Invalid response');
+    public async disable(): Promise<string> {
+        const output = await this.adb.createSocketAndWait("usb:");
+        if (output !== "restarting in USB mode\n") {
+            throw new Error(output);
         }
+        return output;
     }
 }

package/src/{auth.ts → daemon/auth.ts}

@@ -1,14 +1,16 @@
 import { PromiseResolver } from "@yume-chan/async";
-import { type Disposable } from "@yume-chan/event";
-import { type ValueOrPromise } from "@yume-chan/struct";
+import type { Disposable } from "@yume-chan/event";
+import type { ValueOrPromise } from "@yume-chan/struct";
+
+import { calculateBase64EncodedLength, encodeBase64 } from "../utils/index.js";
 
 import {
-    calculatePublicKey,
-    calculatePublicKeyLength,
-    sign,
+    adbGeneratePublicKey,
+    adbGetPublicKeySize,
+    rsaSign,
 } from "./crypto.js";
-import { AdbCommand, type AdbPacketData } from "./packet.js";
-import { calculateBase64EncodedLength, encodeBase64 } from "./utils/index.js";
+import type { AdbPacketData } from "./packet.js";
+import { AdbCommand } from "./packet.js";
 
 export type AdbKeyIterable = Iterable<Uint8Array> | AsyncIterable<Uint8Array>;
 
@@ -63,7 +65,7 @@ export const AdbSignatureAuthenticator: AdbAuthenticator = async function* (
             return;
         }
 
-        const signature = sign(key, packet.payload);
+        const signature = rsaSign(key, packet.payload);
         yield {
             command: AdbCommand.Auth,
             arg0: AdbAuthType.Signature,
@@ -93,15 +95,15 @@ export const AdbPublicKeyAuthenticator: AdbAuthenticator = async function* (
         privateKey = await credentialStore.generateKey();
     }
 
-    const publicKeyLength = calculatePublicKeyLength();
+    const publicKeyLength = adbGetPublicKeySize();
     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);
+    adbGeneratePublicKey(privateKey, publicKeyBuffer);
     encodeBase64(publicKeyBuffer.subarray(0, publicKeyLength), publicKeyBuffer);
 
     yield {
@@ -122,9 +124,8 @@ export class AdbAuthenticationProcessor implements Disposable {
 
     private readonly credentialStore: AdbCredentialStore;
 
-    private pendingRequest = new PromiseResolver<AdbPacketData>();
-
-    private iterator: AsyncIterator<AdbPacketData, void, void> | undefined;
+    #pendingRequest = new PromiseResolver<AdbPacketData>();
+    #iterator: AsyncIterator<AdbPacketData, void, void> | undefined;
 
     public constructor(
         authenticators: readonly AdbAuthenticator[],
@@ -135,7 +136,7 @@ export class AdbAuthenticationProcessor implements Disposable {
     }
 
     private getNextRequest = (): Promise<AdbPacketData> => {
-        return this.pendingRequest.promise;
+        return this.#pendingRequest.promise;
     };
 
     private async *invokeAuthenticator(): AsyncGenerator<
@@ -150,7 +151,7 @@ export class AdbAuthenticationProcessor implements Disposable {
             )) {
                 // If the authenticator yielded a response
                 // Prepare `nextRequest` for next authentication request
-                this.pendingRequest = new PromiseResolver();
+                this.#pendingRequest = new PromiseResolver();
 
                 // Yield the response to outer layer
                 yield packet;
@@ -162,13 +163,13 @@ export class AdbAuthenticationProcessor implements Disposable {
     }
 
     public async process(packet: AdbPacketData): Promise<AdbPacketData> {
-        if (!this.iterator) {
-            this.iterator = this.invokeAuthenticator();
+        if (!this.#iterator) {
+            this.#iterator = this.invokeAuthenticator();
         }
 
-        this.pendingRequest.resolve(packet);
+        this.#pendingRequest.resolve(packet);
 
-        const result = await this.iterator.next();
+        const result = await this.#iterator.next();
         if (result.done) {
             throw new Error("No authenticator can handle the request");
         }
@@ -177,6 +178,6 @@ export class AdbAuthenticationProcessor implements Disposable {
     }
 
     public dispose() {
-        void this.iterator?.return?.();
+        void this.#iterator?.return?.();
     }
 }

package/src/{crypto.ts → daemon/crypto.ts}

@@ -3,11 +3,6 @@ import {
     setBigUint64,
 } from "@yume-chan/dataview-bigint-polyfill/esm/fallback.js";
 
-const BigInt0 = BigInt(0);
-const BigInt1 = BigInt(1);
-const BigInt2 = BigInt(2);
-const BigInt64 = BigInt(64);
-
 /**
  * Gets the `BigInt` value at the specified byte offset and length from the start of the view. There is
  * no alignment constraint; multi-byte values may be fetched from any offset.
@@ -20,13 +15,13 @@ export function getBigUint(
     byteOffset: number,
     length: number
 ): bigint {
-    let result = BigInt0;
+    let result = 0n;
 
     // Currently `length` must be a multiplication of 8
     // Support for arbitrary length can be easily added
 
     for (let i = byteOffset; i < byteOffset + length; i += 8) {
-        result <<= BigInt64;
+        result <<= 64n;
         const value = getBigUint64(dataView, i, false);
         result += value;
     }
@@ -50,18 +45,18 @@ export function setBigUint(
     const start = byteOffset;
 
     if (littleEndian) {
-        while (value > BigInt0) {
+        while (value > 0n) {
             setBigUint64(dataView, byteOffset, value, true);
             byteOffset += 8;
-            value >>= BigInt64;
+            value >>= 64n;
         }
     } else {
         // Because we don't know how long (in bits) the `value` is,
         // Convert it to an array of `uint64` first.
         const uint64Array: bigint[] = [];
-        while (value > BigInt0) {
+        while (value > 0n) {
             uint64Array.push(BigInt.asUintN(64, value));
-            value >>= BigInt64;
+            value >>= 64n;
         }
 
         for (let i = uint64Array.length - 1; i >= 0; i -= 1) {
@@ -99,7 +94,7 @@ const RsaPrivateKeyNLength = 2048 / 8;
 const RsaPrivateKeyDOffset = 303;
 const RsaPrivateKeyDLength = 2048 / 8;
 
-export function parsePrivateKey(key: Uint8Array): [n: bigint, d: bigint] {
+export function rsaParsePrivateKey(key: Uint8Array): [n: bigint, d: bigint] {
     const view = new DataView(key.buffer, key.byteOffset, key.byteLength);
     const n = getBigUint(view, RsaPrivateKeyNOffset, RsaPrivateKeyNLength);
     const d = getBigUint(view, RsaPrivateKeyDOffset, RsaPrivateKeyDLength);
@@ -133,16 +128,16 @@ export function modInverse(a: number, m: number) {
     return ((y % m) + m) % m;
 }
 
-export function calculatePublicKeyLength() {
+export function adbGetPublicKeySize() {
     return 4 + 4 + 2048 / 8 + 2048 / 8 + 4;
 }
 
-export function calculatePublicKey(privateKey: Uint8Array): Uint8Array;
-export function calculatePublicKey(
+export function adbGeneratePublicKey(privateKey: Uint8Array): Uint8Array;
+export function adbGeneratePublicKey(
     privateKey: Uint8Array,
     output: Uint8Array
 ): number;
-export function calculatePublicKey(
+export function adbGeneratePublicKey(
     privateKey: Uint8Array,
     output?: Uint8Array
 ): Uint8Array | number {
@@ -164,10 +159,10 @@ export function calculatePublicKey(
     // See https://android.googlesource.com/platform/system/core.git/+/91784040db2b9273687f88d8b95f729d4a61ecc2/libcrypto_utils/android_pubkey.cpp#38
 
     // extract `n` from private key
-    const [n] = parsePrivateKey(privateKey);
+    const [n] = rsaParsePrivateKey(privateKey);
 
     let outputType: "Uint8Array" | "number";
-    const outputLength = calculatePublicKeyLength();
+    const outputLength = adbGetPublicKeySize();
     if (!output) {
         output = new Uint8Array(outputLength);
         outputType = "Uint8Array";
@@ -191,12 +186,9 @@ export function calculatePublicKey(
     outputOffset += 4;
 
     // Calculate `n0inv`
-    // Don't know why need to multiple -1
+    // Don't know why need to multiply by -1
     // Didn't exist in Android codebase
-    const n0inv = modInverse(
-        Number(BigInt.asUintN(32, n) * BigInt(-1)),
-        2 ** 32
-    );
+    const n0inv = modInverse(-Number(BigInt.asUintN(32, n)), 2 ** 32);
     outputView.setUint32(outputOffset, n0inv, true);
     outputOffset += 4;
 
@@ -205,7 +197,7 @@ export function calculatePublicKey(
     outputOffset += 256;
 
     // Calculate rr = (2^(rsa_size)) ^ 2 mod n
-    const rr = BigInt(2) ** BigInt(4096) % n;
+    const rr = 2n ** 4096n % n;
     outputOffset += setBigUint(outputView, outputOffset, rr, true);
 
     // exponent
@@ -231,20 +223,20 @@ export function powMod(
     exponent: bigint,
     modulus: bigint
 ): bigint {
-    if (modulus === BigInt1) {
-        return BigInt0;
+    if (modulus === 1n) {
+        return 0n;
     }
 
-    let r = BigInt1;
+    let r = 1n;
     base = base % modulus;
 
-    while (exponent > BigInt0) {
-        if (BigInt.asUintN(1, exponent) === BigInt1) {
+    while (exponent > 0n) {
+        if (BigInt.asUintN(1, exponent) === 1n) {
             r = (r * base) % modulus;
         }
 
-        exponent >>= BigInt1;
-        base = base ** BigInt2 % modulus;
+        base = (base * base) % modulus;
+        exponent >>= 1n;
     }
 
     return r;
@@ -283,8 +275,8 @@ export const SHA1_DIGEST_INFO = new Uint8Array([
 // 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
-export function sign(privateKey: Uint8Array, data: Uint8Array): Uint8Array {
-    const [n, d] = parsePrivateKey(privateKey);
+export function rsaSign(privateKey: Uint8Array, data: Uint8Array): Uint8Array {
+    const [n, d] = rsaParsePrivateKey(privateKey);
 
     // PKCS#1 padding
     const padded = new Uint8Array(256);

package/src/daemon/device.ts

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