@yume-chan/adb 0.0.17 → 0.0.19

package/src/commands/sync/sync.ts

@@ -1,15 +1,17 @@
-import { AutoDisposable } from '@yume-chan/event';
-import { BufferedReadableStream, ReadableStream, WrapReadableStream, WrapWritableStream, WritableStream, 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 { escapeArg } from '../subprocess/index.js';
-import { adbSyncOpenDir, type AdbSyncEntry } from './list.js';
-import { adbSyncPull } from './pull.js';
-import { adbSyncPush } from './push.js';
-import { adbSyncLstat, adbSyncStat } from './stat.js';
+import { AutoDisposable } from "@yume-chan/event";
+import type { Consumable, ReadableStream } from "@yume-chan/stream-extra";
+
+import type { Adb } 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";
+import { adbSyncOpenDir } from "./list.js";
+import { adbSyncPull } from "./pull.js";
+import { adbSyncPush } from "./push.js";
+import { AdbSyncSocket } from "./socket.js";
+import { adbSyncLstat, adbSyncStat } from "./stat.js";
 
 /**
  * A simplified `dirname` function that only handles absolute unix paths.
@@ -17,94 +19,95 @@ import { adbSyncLstat, adbSyncStat } from './stat.js';
  * @returns the directory name of the input path
  */
 export function dirname(path: string): string {
-    const end = path.lastIndexOf('/');
+    const end = path.lastIndexOf("/");
     if (end === -1) {
         throw new Error(`Invalid path`);
     }
     if (end === 0) {
-        return '/';
+        return "/";
     }
     return path.substring(0, end);
 }
 
+export interface AdbSyncWriteOptions {
+    filename: string;
+    file: ReadableStream<Consumable<Uint8Array>>;
+    mode?: 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());
+    private _supportsStat: boolean;
+    private _supportsListV2: boolean;
+    private _fixedPushMkdir: boolean;
+    private _supportsSendReceiveV2: boolean;
+    private _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);
+
+        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;
     }
 
     public async lstat(path: string) {
-        await this.sendLock.wait();
-
-        try {
-            return adbSyncLstat(this.stream, this.writer, path, this.supportsStat);
-        } finally {
-            this.sendLock.notify();
-        }
+        return await adbSyncLstat(this._socket, path, this.supportsStat);
     }
 
     public async stat(path: string) {
         if (!this.supportsStat) {
-            throw new Error('Not supported');
+            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> {
         try {
-            await this.lstat(path + '/');
+            await this.lstat(path + "/");
             return true;
         } catch (e) {
             return false;
         }
     }
 
-    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) {
@@ -122,61 +125,39 @@ export class AdbSync extends AutoDisposable {
      * @returns A `ReadableStream` that reads from the file.
      */
     public read(filename: string): ReadableStream<Uint8Array> {
-        return new WrapReadableStream({
-            start: async () => {
-                await this.sendLock.wait();
-                return adbSyncPull(this.stream, this.writer, filename);
-            },
-            close: async () => {
-                this.sendLock.notify();
-            },
-        });
+        return adbSyncPull(this._socket, filename);
     }
 
     /**
      * Write (or overwrite) a file on device.
      *
      * @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.
      */
-    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: async () => {
-                this.sendLock.notify();
-            }
+    public async write(options: AdbSyncWriteOptions) {
+        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,4 +1,4 @@
-import { AdbCommandBase } from './base.js';
+import { AdbCommandBase } from "./base.js";
 
 export class AdbTcpIpCommand extends AdbCommandBase {
     public async setPort(port: number): Promise<void> {
@@ -8,14 +8,14 @@ export class AdbTcpIpCommand extends AdbCommandBase {
 
         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("Invalid response");
         }
     }
 
     public async disable(): Promise<void> {
-        const output = await this.adb.createSocketAndWait('usb:');
-        if (output !== 'restarting in USB mode\n') {
-            throw new Error('Invalid response');
+        const output = await this.adb.createSocketAndWait("usb:");
+        if (output !== "restarting in USB mode\n") {
+            throw new Error("Invalid response");
         }
     }
 }

package/src/crypto.ts

@@ -1,4 +1,7 @@
-import { getBigUint64, setBigUint64 } from '@yume-chan/dataview-bigint-polyfill/esm/fallback.js';
+import {
+    getBigUint64,
+    setBigUint64,
+} from "@yume-chan/dataview-bigint-polyfill/esm/fallback.js";
 
 const BigInt0 = BigInt(0);
 const BigInt1 = BigInt(1);
@@ -12,7 +15,11 @@ const BigInt64 = BigInt(64);
  * Only supports Big-Endian, because that's what ADB uses.
  * @param byteOffset The place in the buffer at which the value should be retrieved.
  */
-export function getBigUint(dataView: DataView, byteOffset: number, length: number): bigint {
+export function getBigUint(
+    dataView: DataView,
+    byteOffset: number,
+    length: number
+): bigint {
     let result = BigInt0;
 
     // Currently `length` must be a multiplication of 8
@@ -34,7 +41,12 @@ export function getBigUint(dataView: DataView, byteOffset: number, length: numbe
  * @param littleEndian If `false` or `undefined`, a big-endian value should be written,
  * otherwise a little-endian value should be written.
  */
-export function setBigUint(dataView: DataView, byteOffset: number, value: bigint, littleEndian?: boolean) {
+export function setBigUint(
+    dataView: DataView,
+    byteOffset: number,
+    value: bigint,
+    littleEndian?: boolean
+) {
     const start = byteOffset;
 
     if (littleEndian) {
@@ -98,7 +110,7 @@ export function parsePrivateKey(key: Uint8Array): [n: bigint, d: bigint] {
 // I can't understand, but it does work
 // Only used with numbers smaller than 2^32 so doesn't need BigInt
 export function modInverse(a: number, m: number) {
-    a = (a % m + m) % m;
+    a = ((a % m) + m) % m;
     if (!a || m < 2) {
         return NaN; // invalid input
     }
@@ -115,26 +127,24 @@ export function modInverse(a: number, m: number) {
     // find the inverse
     let x = 1;
     let y = 0;
-    for (let i = s.length - 2; i >= 0; --i) {
+    for (let i = s.length - 2; i >= 0; i -= 1) {
         [x, y] = [y, x - y * Math.floor(s[i]!.a / s[i]!.b)];
     }
-    return (y % m + m) % m;
+    return ((y % m) + m) % m;
 }
 
 export function calculatePublicKeyLength() {
     return 4 + 4 + 2048 / 8 + 2048 / 8 + 4;
 }
 
-export function calculatePublicKey(
-    privateKey: Uint8Array
-): Uint8Array;
+export function calculatePublicKey(privateKey: Uint8Array): Uint8Array;
 export function calculatePublicKey(
     privateKey: Uint8Array,
-    output: Uint8Array,
+    output: Uint8Array
 ): number;
 export function calculatePublicKey(
     privateKey: Uint8Array,
-    output?: Uint8Array,
+    output?: Uint8Array
 ): Uint8Array | number {
     // Android has its own public key generation algorithm
     // See https://android.googlesource.com/platform/system/core.git/+/91784040db2b9273687f88d8b95f729d4a61ecc2/libcrypto_utils/android_pubkey.cpp#111
@@ -156,20 +166,24 @@ export function calculatePublicKey(
     // extract `n` from private key
     const [n] = parsePrivateKey(privateKey);
 
-    let outputType: 'Uint8Array' | 'number';
+    let outputType: "Uint8Array" | "number";
     const outputLength = calculatePublicKeyLength();
     if (!output) {
         output = new Uint8Array(outputLength);
-        outputType = 'Uint8Array';
+        outputType = "Uint8Array";
     } else {
         if (output.byteLength < outputLength) {
-            throw new Error('output buffer is too small');
+            throw new Error("output buffer is too small");
         }
 
-        outputType = 'number';
+        outputType = "number";
     }
 
-    const outputView = new DataView(output.buffer, output.byteOffset, output.byteLength);
+    const outputView = new DataView(
+        output.buffer,
+        output.byteOffset,
+        output.byteLength
+    );
     let outputOffset = 0;
 
     // modulusLengthInWords
@@ -179,7 +193,10 @@ export function calculatePublicKey(
     // Calculate `n0inv`
     // Don't know why need to multiple -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) * BigInt(-1)),
+        2 ** 32
+    );
     outputView.setUint32(outputOffset, n0inv, true);
     outputOffset += 4;
 
@@ -188,14 +205,14 @@ export function calculatePublicKey(
     outputOffset += 256;
 
     // Calculate rr = (2^(rsa_size)) ^ 2 mod n
-    let rr = BigInt(2) ** BigInt(4096) % n;
+    const rr = BigInt(2) ** BigInt(4096) % n;
     outputOffset += setBigUint(outputView, outputOffset, rr, true);
 
     // exponent
     outputView.setUint32(outputOffset, 65537, true);
     outputOffset += 4;
 
-    if (outputType === 'Uint8Array') {
+    if (outputType === "Uint8Array") {
         return output;
     } else {
         return outputLength;
@@ -209,7 +226,11 @@ export function calculatePublicKey(
  *
  * See https://en.wikipedia.org/wiki/Modular_exponentiation#Implementation_in_Lua
  */
-export function powMod(base: bigint, exponent: bigint, modulus: bigint): bigint {
+export function powMod(
+    base: bigint,
+    exponent: bigint,
+    modulus: bigint
+): bigint {
     if (modulus === BigInt1) {
         return BigInt0;
     }
@@ -219,7 +240,7 @@ export function powMod(base: bigint, exponent: bigint, modulus: bigint): bigint
 
     while (exponent > BigInt0) {
         if (BigInt.asUintN(1, exponent) === BigInt1) {
-            r = r * base % modulus;
+            r = (r * base) % modulus;
         }
 
         exponent >>= BigInt1;
@@ -238,12 +259,22 @@ export const ASN1_OID = 0x06;
 
 // PKCS#1 SHA-1 hash digest info
 export const SHA1_DIGEST_INFO = new Uint8Array([
-    ASN1_SEQUENCE, 0x0d + SHA1_DIGEST_LENGTH,
-    ASN1_SEQUENCE, 0x09,
+    ASN1_SEQUENCE,
+    0x0d + SHA1_DIGEST_LENGTH,
+    ASN1_SEQUENCE,
+    0x09,
     // SHA-1 (1 3 14 3 2 26)
-    ASN1_OID, 0x05, 1 * 40 + 3, 14, 3, 2, 26,
-    ASN1_NULL, 0x00,
-    ASN1_OCTET_STRING, SHA1_DIGEST_LENGTH
+    ASN1_OID,
+    0x05,
+    1 * 40 + 3,
+    14,
+    3,
+    2,
+    26,
+    ASN1_NULL,
+    0x00,
+    ASN1_OCTET_STRING,
+    SHA1_DIGEST_LENGTH,
 ]);
 
 // SubtleCrypto.sign() will hash the given data and sign the hash
@@ -265,7 +296,8 @@ export function sign(privateKey: Uint8Array, data: Uint8Array): Uint8Array {
     padded[index] = 1;
     index += 1;
 
-    const fillLength = padded.length - SHA1_DIGEST_INFO.length - data.length - 1;
+    const fillLength =
+        padded.length - SHA1_DIGEST_INFO.length - data.length - 1;
     while (index < fillLength) {
         padded[index] = 0xff;
         index += 1;
@@ -282,11 +314,7 @@ export function sign(privateKey: Uint8Array, data: Uint8Array): Uint8Array {
     // Encryption
     // signature = padded ** d % n
     const view = new DataView(padded.buffer);
-    const signature = powMod(
-        getBigUint(view, 0, view.byteLength),
-        d,
-        n
-    );
+    const signature = powMod(getBigUint(view, 0, view.byteLength), d, n);
 
     // `padded` is not used anymore,
     // re-use the buffer to store the result

package/src/features.ts

@@ -1,9 +1,12 @@
 // The order follows
 // https://android.googlesource.com/platform/packages/modules/adb/+/79010dc6d5ca7490c493df800d4421730f5466ca/transport.cpp#1252
-export enum AdbFeatures {
-    ShellV2 = 'shell_v2',
-    Cmd = 'cmd',
-    StatV2 = 'stat_v2',
-    ListV2 = 'ls_v2',
-    FixedPushMkdir = 'fixed_push_mkdir',
+export enum AdbFeature {
+    ShellV2 = "shell_v2",
+    Cmd = "cmd",
+    StatV2 = "stat_v2",
+    ListV2 = "ls_v2",
+    FixedPushMkdir = "fixed_push_mkdir",
+    Abb = "abb",
+    AbbExec = "abb_exec",
+    SendReceiveV2 = "sendrecv_v2",
 }

package/src/index.ts

@@ -1,10 +1,9 @@
-
-export * from './adb.js';
-export * from './auth.js';
-export * from './backend.js';
-export * from './commands/index.js';
-export * from './crypto.js';
-export * from './features.js';
-export * from './packet.js';
-export * from './socket/index.js';
-export * from './utils/index.js';
+export * from "./adb.js";
+export * from "./auth.js";
+export * from "./backend.js";
+export * from "./commands/index.js";
+export * from "./crypto.js";
+export * from "./features.js";
+export * from "./packet.js";
+export * from "./socket/index.js";
+export * from "./utils/index.js";

package/src/packet.ts

@@ -1,34 +1,32 @@
-import { TransformStream } from '@yume-chan/stream-extra';
-import Struct from '@yume-chan/struct';
+import { ConsumableTransformStream } from "@yume-chan/stream-extra";
+import Struct from "@yume-chan/struct";
 
 export enum AdbCommand {
-    Auth = 0x48545541,    // 'AUTH'
-    Close = 0x45534c43,   // 'CLSE'
+    Auth = 0x48545541, // 'AUTH'
+    Close = 0x45534c43, // 'CLSE'
     Connect = 0x4e584e43, // 'CNXN'
-    OK = 0x59414b4f,      // 'OKAY'
-    Open = 0x4e45504f,    // 'OPEN'
-    Write = 0x45545257,   // 'WRTE'
+    OK = 0x59414b4f, // 'OKAY'
+    Open = 0x4e45504f, // 'OPEN'
+    Write = 0x45545257, // 'WRTE'
 }
 
-export const AdbPacketHeader =
-    new Struct({ littleEndian: true })
-        .uint32('command')
-        .uint32('arg0')
-        .uint32('arg1')
-        .uint32('payloadLength')
-        .uint32('checksum')
-        .int32('magic');
+export const AdbPacketHeader = new Struct({ littleEndian: true })
+    .uint32("command")
+    .uint32("arg0")
+    .uint32("arg1")
+    .uint32("payloadLength")
+    .uint32("checksum")
+    .int32("magic");
 
-export type AdbPacketHeader = typeof AdbPacketHeader['TDeserializeResult'];
+export type AdbPacketHeader = (typeof AdbPacketHeader)["TDeserializeResult"];
 
-type AdbPacketHeaderInit = typeof AdbPacketHeader['TInit'];
+type AdbPacketHeaderInit = (typeof AdbPacketHeader)["TInit"];
 
-export const AdbPacket =
-    new Struct({ littleEndian: true })
-        .fields(AdbPacketHeader)
-        .uint8Array('payload', { lengthField: 'payloadLength' });
+export const AdbPacket = new Struct({ littleEndian: true })
+    .fields(AdbPacketHeader)
+    .uint8Array("payload", { lengthField: "payloadLength" });
 
-export type AdbPacket = typeof AdbPacket['TDeserializeResult'];
+export type AdbPacket = (typeof AdbPacket)["TDeserializeResult"];
 
 /**
  * `AdbPacketData` contains all the useful fields of `AdbPacket`.
@@ -40,39 +38,36 @@ export type AdbPacket = typeof AdbPacket['TDeserializeResult'];
  * however, `AdbPacketDispatcher` will transform `AdbPacketData` to `AdbPacketInit` for you,
  * so `AdbSocket#writable#write` only needs `AdbPacketData`.
  */
-export type AdbPacketData = Omit<typeof AdbPacket['TInit'], 'checksum' | 'magic'>;
+export type AdbPacketData = Omit<
+    (typeof AdbPacket)["TInit"],
+    "checksum" | "magic"
+>;
 
-// All fields except `magic`, which can be calculated in `AdbPacketSerializeStream`
-export type AdbPacketInit = Omit<typeof AdbPacket['TInit'], 'magic'>;
+export type AdbPacketInit = (typeof AdbPacket)["TInit"];
 
-export function calculateChecksum(payload: Uint8Array): number;
-export function calculateChecksum(init: AdbPacketData): AdbPacketInit;
-export function calculateChecksum(payload: Uint8Array | AdbPacketData): number | AdbPacketInit {
-    if (payload instanceof Uint8Array) {
-        return payload.reduce((result, item) => result + item, 0);
-    } else {
-        (payload as AdbPacketInit).checksum = calculateChecksum(payload.payload);
-        return payload as AdbPacketInit;
-    }
+export function calculateChecksum(payload: Uint8Array): number {
+    return payload.reduce((result, item) => result + item, 0);
 }
 
-export class AdbPacketSerializeStream extends TransformStream<AdbPacketInit, Uint8Array>{
+export class AdbPacketSerializeStream extends ConsumableTransformStream<
+    AdbPacketInit,
+    Uint8Array
+> {
     public constructor() {
+        const headerBuffer = new Uint8Array(AdbPacketHeader.size);
         super({
-            transform: async (init, controller) => {
-                // This syntax is ugly, but I don't want to create a new object.
-                (init as unknown as AdbPacketHeaderInit).magic = init.command ^ 0xFFFFFFFF;
-                (init as unknown as AdbPacketHeaderInit).payloadLength = init.payload.byteLength;
+            transform: async (chunk, controller) => {
+                const init = chunk as AdbPacketInit & AdbPacketHeaderInit;
+                init.payloadLength = init.payload.byteLength;
 
-                controller.enqueue(
-                    AdbPacketHeader.serialize(
-                        init as unknown as AdbPacketHeaderInit
-                    )
-                );
+                AdbPacketHeader.serialize(init, headerBuffer);
+                await controller.enqueue(headerBuffer);
 
                 if (init.payload.byteLength) {
-                    // Enqueue payload separately to avoid copying
-                    controller.enqueue(init.payload);
+                    // USB protocol preserves packet boundaries,
+                    // so we must write payload separately as native ADB does,
+                    // otherwise the read operation on device will fail.
+                    await controller.enqueue(init.payload);
                 }
             },
         });