@yume-chan/adb 0.0.19 → 0.0.20

package/src/commands/sync/response.ts

@@ -1,5 +1,5 @@
 import type {
-    StructAsyncDeserializeStream,
+    AsyncExactReadable,
     StructLike,
     StructValueType,
 } from "@yume-chan/struct";
@@ -27,11 +27,11 @@ export const AdbSyncFailResponse = new Struct({ littleEndian: true })
     });
 
 export async function adbSyncReadResponse<T>(
-    stream: StructAsyncDeserializeStream,
+    stream: AsyncExactReadable,
     id: AdbSyncResponseId,
     type: StructLike<T>
 ): Promise<T> {
-    const actualId = decodeUtf8(await stream.read(4));
+    const actualId = decodeUtf8(await stream.readExactly(4));
     switch (actualId) {
         case AdbSyncResponseId.Fail:
             await AdbSyncFailResponse.deserialize(stream);
@@ -46,12 +46,12 @@ export async function adbSyncReadResponse<T>(
 export async function* adbSyncReadResponses<
     T extends Struct<object, PropertyKey, object, any>
 >(
-    stream: StructAsyncDeserializeStream,
+    stream: AsyncExactReadable,
     id: AdbSyncResponseId,
     type: T
 ): AsyncGenerator<StructValueType<T>, void, void> {
     while (true) {
-        const actualId = decodeUtf8(await stream.read(4));
+        const actualId = decodeUtf8(await stream.readExactly(4));
         switch (actualId) {
             case AdbSyncResponseId.Fail:
                 await AdbSyncFailResponse.deserialize(stream);
@@ -61,7 +61,7 @@ export async function* adbSyncReadResponses<
                 //
                 // For example, `DONE` responses for `LIST` requests are 16 bytes (same as `DENT` responses),
                 // but `DONE` responses for `STAT` requests are 12 bytes (same as `STAT` responses).
-                await stream.read(type.size);
+                await stream.readExactly(type.size);
                 return;
             case id:
                 yield await type.deserialize(stream);

package/src/commands/sync/socket.ts

@@ -7,19 +7,21 @@ import {
     BufferedReadableStream,
     ConsumableWritableStream,
 } from "@yume-chan/stream-extra";
-import type { StructAsyncDeserializeStream } from "@yume-chan/struct";
+import type { AsyncExactReadable } from "@yume-chan/struct";
 
-import type { AdbSocket } from "../../index.js";
-import { AutoResetEvent } from "../../index.js";
+import type { AdbSocket } from "../../adb.js";
+import { AutoResetEvent } from "../../utils/index.js";
 
-export class AdbSyncSocketLocked implements StructAsyncDeserializeStream {
-    private readonly _writer: WritableStreamDefaultWriter<
-        Consumable<Uint8Array>
-    >;
-    private readonly _readable: BufferedReadableStream;
-    private readonly _socketLock: AutoResetEvent;
-    private readonly _writeLock = new AutoResetEvent();
-    private readonly _combiner: BufferCombiner;
+export class AdbSyncSocketLocked implements AsyncExactReadable {
+    readonly #writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>;
+    readonly #readable: BufferedReadableStream;
+    readonly #socketLock: AutoResetEvent;
+    readonly #writeLock = new AutoResetEvent();
+    readonly #combiner: BufferCombiner;
+
+    public get position() {
+        return this.#readable.position;
+    }
 
     public constructor(
         writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>,
@@ -27,71 +29,71 @@ export class AdbSyncSocketLocked implements StructAsyncDeserializeStream {
         bufferSize: number,
         lock: AutoResetEvent
     ) {
-        this._writer = writer;
-        this._readable = readable;
-        this._socketLock = lock;
-        this._combiner = new BufferCombiner(bufferSize);
+        this.#writer = writer;
+        this.#readable = readable;
+        this.#socketLock = lock;
+        this.#combiner = new BufferCombiner(bufferSize);
     }
 
     private async writeInnerStream(buffer: Uint8Array) {
-        await ConsumableWritableStream.write(this._writer, buffer);
+        await ConsumableWritableStream.write(this.#writer, buffer);
     }
 
     public async flush() {
         try {
-            await this._writeLock.wait();
-            const buffer = this._combiner.flush();
+            await this.#writeLock.wait();
+            const buffer = this.#combiner.flush();
             if (buffer) {
                 await this.writeInnerStream(buffer);
             }
         } finally {
-            this._writeLock.notifyOne();
+            this.#writeLock.notifyOne();
         }
     }
 
     public async write(data: Uint8Array) {
         try {
-            await this._writeLock.wait();
-            for (const buffer of this._combiner.push(data)) {
+            await this.#writeLock.wait();
+            for (const buffer of this.#combiner.push(data)) {
                 await this.writeInnerStream(buffer);
             }
         } finally {
-            this._writeLock.notifyOne();
+            this.#writeLock.notifyOne();
         }
     }
 
-    public async read(length: number) {
+    public async readExactly(length: number) {
         await this.flush();
-        return await this._readable.read(length);
+        return await this.#readable.readExactly(length);
     }
 
     public release(): void {
-        this._combiner.flush();
-        this._socketLock.notifyOne();
+        this.#combiner.flush();
+        this.#socketLock.notifyOne();
     }
 }
 
 export class AdbSyncSocket {
-    private _lock = new AutoResetEvent();
-    private _socket: AdbSocket;
-    private _locked: AdbSyncSocketLocked;
+    readonly #lock = new AutoResetEvent();
+    readonly #socket: AdbSocket;
+    readonly #locked: AdbSyncSocketLocked;
 
     public constructor(socket: AdbSocket, bufferSize: number) {
-        this._socket = socket;
-        this._locked = new AdbSyncSocketLocked(
+        this.#socket = socket;
+        this.#locked = new AdbSyncSocketLocked(
             socket.writable.getWriter(),
             new BufferedReadableStream(socket.readable),
             bufferSize,
-            this._lock
+            this.#lock
         );
     }
 
     public async lock() {
-        await this._lock.wait();
-        return this._locked;
+        await this.#lock.wait();
+        return this.#locked;
     }
 
     public async close() {
-        await this._socket.close();
+        await this.#socket.close();
     }
 }

package/src/commands/sync/sync.ts

@@ -1,9 +1,8 @@
 import { AutoDisposable } from "@yume-chan/event";
 import type { Consumable, ReadableStream } from "@yume-chan/stream-extra";
 
-import type { Adb } from "../../adb.js";
+import type { Adb, AdbSocket } from "../../adb.js";
 import { AdbFeature } from "../../features.js";
-import type { AdbSocket } from "../../socket/index.js";
 import { escapeArg } from "../subprocess/index.js";
 
 import type { AdbSyncEntry } from "./list.js";
@@ -11,6 +10,7 @@ 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";
 
 /**
@@ -32,7 +32,8 @@ export function dirname(path: string): string {
 export interface AdbSyncWriteOptions {
     filename: string;
     file: ReadableStream<Consumable<Uint8Array>>;
-    mode?: number;
+    type?: LinuxFileType;
+    permission?: number;
     mtime?: number;
     dryRun?: boolean;
 }
@@ -41,30 +42,30 @@ export class AdbSync extends AutoDisposable {
     protected _adb: Adb;
     protected _socket: AdbSyncSocket;
 
-    private _supportsStat: boolean;
-    private _supportsListV2: boolean;
-    private _fixedPushMkdir: boolean;
-    private _supportsSendReceiveV2: boolean;
-    private _needPushMkdirWorkaround: boolean;
+    readonly #supportsStat: boolean;
+    readonly #supportsListV2: boolean;
+    readonly #fixedPushMkdir: boolean;
+    readonly #supportsSendReceiveV2: boolean;
+    readonly #needPushMkdirWorkaround: boolean;
 
     public get supportsStat(): boolean {
-        return this._supportsStat;
+        return this.#supportsStat;
     }
 
     public get supportsListV2(): boolean {
-        return this._supportsListV2;
+        return this.#supportsListV2;
     }
 
     public get fixedPushMkdir(): boolean {
-        return this._fixedPushMkdir;
+        return this.#fixedPushMkdir;
     }
 
     public get supportsSendReceiveV2(): boolean {
-        return this._supportsSendReceiveV2;
+        return this.#supportsSendReceiveV2;
     }
 
     public get needPushMkdirWorkaround(): boolean {
-        return this._needPushMkdirWorkaround;
+        return this.#needPushMkdirWorkaround;
     }
 
     public constructor(adb: Adb, socket: AdbSocket) {
@@ -73,19 +74,19 @@ export class AdbSync extends AutoDisposable {
         this._adb = adb;
         this._socket = new AdbSyncSocket(socket, adb.maxPayloadSize);
 
-        this._supportsStat = adb.supportsFeature(AdbFeature.StatV2);
-        this._supportsListV2 = adb.supportsFeature(AdbFeature.ListV2);
-        this._fixedPushMkdir = adb.supportsFeature(AdbFeature.FixedPushMkdir);
-        this._supportsSendReceiveV2 = adb.supportsFeature(
+        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.#needPushMkdirWorkaround =
             this._adb.supportsFeature(AdbFeature.ShellV2) &&
             !this.fixedPushMkdir;
     }
 
-    public async lstat(path: string) {
+    public async lstat(path: string): Promise<AdbSyncStat> {
         return await adbSyncLstat(this._socket, path, this.supportsStat);
     }
 
@@ -119,25 +120,21 @@ 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 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 file The content 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 async write(options: AdbSyncWriteOptions) {
+    public async write(options: AdbSyncWriteOptions): Promise<void> {
         if (this.needPushMkdirWorkaround) {
             // It may fail if the path is already existed.
             // Ignore the result.

package/src/commands/tcpip.ts

@@ -1,21 +1,23 @@
 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> {
+    public async disable(): Promise<string> {
         const output = await this.adb.createSocketAndWait("usb:");
         if (output !== "restarting in USB mode\n") {
-            throw new Error("Invalid response");
+            throw new Error(output);
         }
+        return output;
     }
 }

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

@@ -2,14 +2,15 @@ import { PromiseResolver } from "@yume-chan/async";
 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 type { AdbPacketData } from "./packet.js";
 import { AdbCommand } from "./packet.js";
-import { calculateBase64EncodedLength, encodeBase64 } from "./utils/index.js";
 
 export type AdbKeyIterable = Iterable<Uint8Array> | AsyncIterable<Uint8Array>;
 
@@ -64,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,
@@ -94,7 +95,7 @@ export const AdbPublicKeyAuthenticator: AdbAuthenticator = async function* (
         privateKey = await credentialStore.generateKey();
     }
 
-    const publicKeyLength = calculatePublicKeyLength();
+    const publicKeyLength = adbGetPublicKeySize();
     const [publicKeyBase64Length] =
         calculateBase64EncodedLength(publicKeyLength);
 
@@ -102,7 +103,7 @@ export const AdbPublicKeyAuthenticator: AdbAuthenticator = async function* (
         publicKeyBase64Length + 1 // Null character
     );
 
-    calculatePublicKey(privateKey, publicKeyBuffer);
+    adbGeneratePublicKey(privateKey, publicKeyBuffer);
     encodeBase64(publicKeyBuffer.subarray(0, publicKeyLength), publicKeyBuffer);
 
     yield {
@@ -123,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[],
@@ -136,7 +136,7 @@ export class AdbAuthenticationProcessor implements Disposable {
     }
 
     private getNextRequest = (): Promise<AdbPacketData> => {
-        return this.pendingRequest.promise;
+        return this.#pendingRequest.promise;
     };
 
     private async *invokeAuthenticator(): AsyncGenerator<
@@ -151,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;
@@ -163,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");
         }
@@ -178,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/{backend.ts → daemon/device.ts}

@@ -3,7 +3,7 @@ import type { ValueOrPromise } from "@yume-chan/struct";
 
 import type { AdbPacketData, AdbPacketInit } from "./packet.js";
 
-export interface AdbBackend {
+export interface AdbDaemonDevice {
     readonly serial: string;
 
     readonly name: string | undefined;