@yume-chan/adb 0.0.10 → 0.0.11

package/src/commands/sync/response.ts

@@ -1,6 +1,6 @@
-import Struct, { StructAsyncDeserializeStream, StructLike, StructValueType } from '@yume-chan/struct';
-import { AdbBufferedStream } from '../../stream';
-import { decodeUtf8 } from "../../utils";
+import Struct, { type StructAsyncDeserializeStream, type StructLike, type StructValueType } from '@yume-chan/struct';
+import type { AdbBufferedStream } from '../../stream/index.js';
+import { decodeUtf8 } from "../../utils/index.js";
 
 export enum AdbSyncResponseId {
     Entry = 'DENT',
@@ -51,7 +51,7 @@ export async function adbSyncReadResponse<T extends Record<string, StructLike<an
     }
 
     if (types[id]) {
-        return types[id].deserialize(stream);
+        return types[id]!.deserialize(stream);
     }
 
     throw new Error('Unexpected response id');

package/src/commands/sync/stat.ts

@@ -1,7 +1,7 @@
 import Struct, { placeholder } from '@yume-chan/struct';
-import { AdbBufferedStream } from '../../stream';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request';
-import { adbSyncReadResponse, AdbSyncResponseId } from './response';
+import type { AdbBufferedStream, WritableStreamDefaultWriter } from '../../stream/index.js';
+import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
+import { adbSyncReadResponse, AdbSyncResponseId } from './response.js';
 
 // https://github.com/python/cpython/blob/4e581d64b8aff3e2eda99b12f080c877bb78dfca/Lib/stat.py#L36
 export enum LinuxFileType {
@@ -94,6 +94,7 @@ const Lstat2ResponseType = {
 
 export async function adbSyncLstat(
     stream: AdbBufferedStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
     path: string,
     v2: boolean,
 ): Promise<AdbSyncLstatResponse | AdbSyncStatResponse> {
@@ -108,14 +109,15 @@ export async function adbSyncLstat(
         responseType = LstatResponseType;
     }
 
-    await adbSyncWriteRequest(stream, requestId, path);
+    await adbSyncWriteRequest(writer, requestId, path);
     return adbSyncReadResponse(stream, responseType);
 }
 
 export async function adbSyncStat(
     stream: AdbBufferedStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
     path: string,
 ): Promise<AdbSyncStatResponse> {
-    await adbSyncWriteRequest(stream, AdbSyncRequestId.Stat, path);
-    return adbSyncReadResponse(stream, StatResponseType);
+    await adbSyncWriteRequest(writer, AdbSyncRequestId.Stat, path);
+    return await adbSyncReadResponse(stream, StatResponseType);
 }

package/src/commands/sync/sync.ts

@@ -1,19 +1,21 @@
 import { AutoDisposable } from '@yume-chan/event';
-import { Adb } from '../../adb';
-import { AdbFeatures } from '../../features';
-import { AdbSocket } from '../../socket';
-import { AdbBufferedStream } from '../../stream';
-import { AutoResetEvent } from '../../utils';
-import { AdbSyncEntryResponse, adbSyncOpenDir } from './list';
-import { adbSyncPull } from './pull';
-import { adbSyncPush } from './push';
-import { adbSyncLstat, adbSyncStat } from './stat';
+import type { Adb } from '../../adb.js';
+import { AdbFeatures } from '../../features.js';
+import type { AdbSocket } from '../../socket/index.js';
+import { AdbBufferedStream, ReadableStream, WrapReadableStream, WrapWritableStream, WritableStream, WritableStreamDefaultWriter } from '../../stream/index.js';
+import { AutoResetEvent } from '../../utils/index.js';
+import { AdbSyncEntryResponse, adbSyncOpenDir } from './list.js';
+import { adbSyncPull } from './pull.js';
+import { adbSyncPush } from './push.js';
+import { adbSyncLstat, adbSyncStat } from './stat.js';
 
 export class AdbSync extends AutoDisposable {
     protected adb: Adb;
 
     protected stream: AdbBufferedStream;
 
+    protected writer: WritableStreamDefaultWriter<Uint8Array>;
+
     protected sendLock = this.addDisposable(new AutoResetEvent());
 
     public get supportsStat(): boolean {
@@ -25,13 +27,14 @@ export class AdbSync extends AutoDisposable {
 
         this.adb = adb;
         this.stream = new AdbBufferedStream(socket);
+        this.writer = socket.writable.getWriter();
     }
 
     public async lstat(path: string) {
         await this.sendLock.wait();
 
         try {
-            return adbSyncLstat(this.stream, path, this.supportsStat);
+            return adbSyncLstat(this.stream, this.writer, path, this.supportsStat);
         } finally {
             this.sendLock.notify();
         }
@@ -45,7 +48,7 @@ export class AdbSync extends AutoDisposable {
         await this.sendLock.wait();
 
         try {
-            return adbSyncStat(this.stream, path);
+            return adbSyncStat(this.stream, this.writer, path);
         } finally {
             this.sendLock.notify();
         }
@@ -66,7 +69,7 @@ export class AdbSync extends AutoDisposable {
         await this.sendLock.wait();
 
         try {
-            yield* adbSyncOpenDir(this.stream, path);
+            yield* adbSyncOpenDir(this.stream, this.writer, path);
         } finally {
             this.sendLock.notify();
         }
@@ -80,34 +83,63 @@ export class AdbSync extends AutoDisposable {
         return results;
     }
 
-    public async *read(filename: string): AsyncGenerator<ArrayBuffer, void, void> {
-        await this.sendLock.wait();
-
-        try {
-            yield* adbSyncPull(this.stream, filename);
-        } finally {
-            this.sendLock.notify();
-        }
+    /**
+     * Read 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.
+     */
+    public read(filename: string): ReadableStream<Uint8Array> {
+        return new WrapReadableStream<Uint8Array, ReadableStream<Uint8Array>, undefined>({
+            start: async () => {
+                await this.sendLock.wait();
+                return {
+                    readable: adbSyncPull(this.stream, this.writer, filename),
+                    state: undefined,
+                };
+            },
+            close: async () => {
+                this.sendLock.notify();
+            },
+        });
     }
 
-    public async write(
+    /**
+     * Write (or overwrite) a file on device.
+     *
+     * @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.
+     */
+    public write(
         filename: string,
-        content: ArrayLike<number> | ArrayBufferLike | AsyncIterable<ArrayBuffer>,
         mode?: number,
         mtime?: number,
-        onProgress?: (uploaded: number) => void,
-    ): Promise<void> {
-        await this.sendLock.wait();
-
-        try {
-            await adbSyncPush(this.stream, filename, content, mode, mtime, undefined, onProgress);
-        } finally {
-            this.sendLock.notify();
-        }
+    ): WritableStream<Uint8Array> {
+        return new WrapWritableStream({
+            start: async () => {
+                await this.sendLock.wait();
+                return {
+                    writable: adbSyncPush(
+                        this.stream,
+                        this.writer,
+                        filename,
+                        mode,
+                        mtime,
+                    ),
+                    state: undefined,
+                };
+            },
+            close: async () => {
+                this.sendLock.notify();
+            }
+        });
     }
 
-    public override dispose() {
+    public override async dispose() {
         super.dispose();
         this.stream.close();
+        await this.writer.close();
     }
 }

package/src/commands/tcpip.ts

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

package/src/crypto.ts

@@ -1,24 +1,25 @@
+import { getBigUint64, setBigUint64 } from '@yume-chan/dataview-bigint-polyfill/esm/fallback.js';
+
 const BigInt0 = BigInt(0);
 const BigInt1 = BigInt(1);
 const BigInt2 = BigInt(2);
-
-const BigInt2To64 = BigInt2 ** BigInt(64);
+const BigInt64 = BigInt(64);
 
 export function getBig(
-    buffer: ArrayBuffer,
+    array: Uint8Array,
     offset = 0,
-    length = buffer.byteLength - offset
+    length = array.byteLength - offset
 ): bigint {
-    const view = new DataView(buffer);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
 
     let result = BigInt0;
 
-    // Now `length` must be a multiplication of 8
+    // Currently `length` must be a multiplication of 8
     // Support for arbitrary length can be easily added
 
     for (let i = offset; i < offset + length; i += 8) {
-        result *= BigInt2To64;
-        const value = view.getBigUint64(i, false);
+        result <<= BigInt64;
+        const value = getBigUint64(view, i, false);
         result += value;
     }
 
@@ -29,22 +30,22 @@ export function setBig(buffer: ArrayBuffer, value: bigint, offset: number = 0) {
     const uint64Array: bigint[] = [];
     while (value > BigInt0) {
         uint64Array.push(BigInt.asUintN(64, value));
-        value /= BigInt2To64;
+        value >>= BigInt64;
     }
 
     const view = new DataView(buffer);
     for (let i = uint64Array.length - 1; i >= 0; i -= 1) {
-        view.setBigUint64(offset, uint64Array[i], false);
+        setBigUint64(view, offset, uint64Array[i]!, false);
         offset += 8;
     }
 }
 
-export function setBigLE(buffer: ArrayBuffer, value: bigint, offset = 0) {
-    const view = new DataView(buffer);
+export function setBigLE(array: Uint8Array, value: bigint, offset = 0) {
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
     while (value > BigInt0) {
-        view.setBigUint64(offset, value, true);
+        setBigUint64(view, offset, value, true);
         offset += 8;
-        value /= BigInt2To64;
+        value >>= BigInt64;
     }
 }
 
@@ -74,7 +75,7 @@ const RsaPrivateKeyNLength = 2048 / 8;
 const RsaPrivateKeyDOffset = 303;
 const RsaPrivateKeyDLength = 2048 / 8;
 
-export function parsePrivateKey(key: ArrayBuffer): [n: bigint, d: bigint] {
+export function parsePrivateKey(key: Uint8Array): [n: bigint, d: bigint] {
     let n = getBig(key, RsaPrivateKeyNOffset, RsaPrivateKeyNLength);
     let d = getBig(key, RsaPrivateKeyDOffset, RsaPrivateKeyDLength);
 
@@ -85,11 +86,6 @@ export function parsePrivateKey(key: ArrayBuffer): [n: bigint, d: bigint] {
 // I can't understand, but it does work
 // Only used with numbers less than 2^32 so doesn't need BigInt
 export function modInverse(a: number, m: number) {
-    // validate inputs
-    [a, m] = [Number(a), Number(m)];
-    if (Number.isNaN(a) || Number.isNaN(m)) {
-        return NaN; // invalid input
-    }
     a = (a % m + m) % m;
     if (!a || m < 2) {
         return NaN; // invalid input
@@ -108,7 +104,7 @@ export function modInverse(a: number, m: number) {
     let x = 1;
     let y = 0;
     for (let i = s.length - 2; i >= 0; --i) {
-        [x, y] = [y, x - y * Math.floor(s[i].a / s[i].b)];
+        [x, y] = [y, x - y * Math.floor(s[i]!.a / s[i]!.b)];
     }
     return (y % m + m) % m;
 }
@@ -118,18 +114,16 @@ export function calculatePublicKeyLength() {
 }
 
 export function calculatePublicKey(
-    privateKey: ArrayBuffer
-): ArrayBuffer;
+    privateKey: Uint8Array
+): Uint8Array;
 export function calculatePublicKey(
-    privateKey: ArrayBuffer,
-    output: ArrayBuffer,
-    outputOffset?: number
+    privateKey: Uint8Array,
+    output: Uint8Array,
 ): number;
 export function calculatePublicKey(
-    privateKey: ArrayBuffer,
-    output?: ArrayBuffer,
-    outputOffset: number = 0
-): ArrayBuffer | number {
+    privateKey: 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
 
@@ -150,20 +144,21 @@ export function calculatePublicKey(
     // extract `n` from private key
     const [n] = parsePrivateKey(privateKey);
 
-    let outputType: 'ArrayBuffer' | 'number';
+    let outputType: 'Uint8Array' | 'number';
     const outputLength = calculatePublicKeyLength();
     if (!output) {
-        output = new ArrayBuffer(outputLength);
-        outputType = 'ArrayBuffer';
+        output = new Uint8Array(outputLength);
+        outputType = 'Uint8Array';
     } else {
-        if (output.byteLength - outputOffset < outputLength) {
+        if (output.byteLength < outputLength) {
             throw new Error('output buffer is too small');
         }
 
         outputType = 'number';
     }
 
-    const outputView = new DataView(output);
+    const outputView = new DataView(output.buffer, output.byteOffset, output.byteLength);
+    let outputOffset = 0;
 
     // modulusLengthInWords
     outputView.setUint32(outputOffset, 2048 / 8 / 4, true);
@@ -189,7 +184,7 @@ export function calculatePublicKey(
     outputView.setUint32(outputOffset, 65537, true);
     outputOffset += 4;
 
-    if (outputType === 'ArrayBuffer') {
+    if (outputType === 'Uint8Array') {
         return output;
     } else {
         return outputLength;
@@ -231,14 +226,14 @@ export const Asn1Null = 0x05;
 export const Asn1Oid = 0x06;
 
 // PKCS#1 SHA-1 hash digest info
-export const Sha1DigestInfo = [
+export const Sha1DigestInfo = new Uint8Array([
     Asn1Sequence, 0x0d + Sha1DigestLength,
     Asn1Sequence, 0x09,
     // SHA-1 (1 3 14 3 2 26)
     Asn1Oid, 0x05, 1 * 40 + 3, 14, 3, 2, 26,
     Asn1Null, 0x00,
     Asn1OctetString, Sha1DigestLength
-];
+]);
 
 // SubtleCrypto.sign() will hash the given data and sign the hash
 // But we don't need the hashing step
@@ -246,7 +241,7 @@ export const Sha1DigestInfo = [
 // 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: ArrayBuffer, data: ArrayBuffer): ArrayBuffer {
+export function sign(privateKey: Uint8Array, data: Uint8Array): ArrayBuffer {
     const [n, d] = parsePrivateKey(privateKey);
 
     // PKCS#1 padding
@@ -259,7 +254,7 @@ export function sign(privateKey: ArrayBuffer, data: ArrayBuffer): ArrayBuffer {
     padded[index] = 1;
     index += 1;
 
-    const fillLength = padded.length - Sha1DigestInfo.length - data.byteLength - 1;
+    const fillLength = padded.length - Sha1DigestInfo.length - data.length - 1;
     while (index < fillLength) {
         padded[index] = 0xff;
         index += 1;
@@ -268,14 +263,14 @@ export function sign(privateKey: ArrayBuffer, data: ArrayBuffer): ArrayBuffer {
     padded[index] = 0;
     index += 1;
 
-    padded.set(new Uint8Array(Sha1DigestInfo), index);
+    padded.set(Sha1DigestInfo, index);
     index += Sha1DigestInfo.length;
 
-    padded.set(new Uint8Array(data), index);
+    padded.set(data, index);
 
     // Encryption
     // signature = padded ** d % n
-    let signature = powMod(getBig(padded.buffer), d, n);
+    let signature = powMod(getBig(padded), d, n);
 
     // Put into an ArrayBuffer
     const result = new ArrayBuffer(256);

package/src/index.ts

@@ -1,10 +1,11 @@
-export * from './adb';
-export * from './auth';
-export * from './backend';
-export * from './commands';
-export * from './crypto';
-export * from './features';
-export * from './packet';
-export * from './socket';
-export * from './stream';
-export * from './utils';
+
+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 './stream/index.js';
+export * from './utils/index.js';

package/src/packet.ts

@@ -1,6 +1,5 @@
 import Struct from '@yume-chan/struct';
-import { AdbBackend } from './backend';
-import { BufferedStream } from './stream';
+import { TransformStream } from "./stream/index.js";
 
 export enum AdbCommand {
     Auth = 0x48545541,    // 'AUTH'
@@ -20,65 +19,51 @@ const AdbPacketHeader =
         .uint32('checksum')
         .int32('magic');
 
-const AdbPacketStruct =
+type AdbPacketHeaderInit = typeof AdbPacketHeader['TInit'];
+
+export const AdbPacket =
     new Struct({ littleEndian: true })
         .fields(AdbPacketHeader)
-        .arrayBuffer('payload', { lengthField: 'payloadLength' });
-
-export type AdbPacket = typeof AdbPacketStruct['TDeserializeResult'];
+        .uint8Array('payload', { lengthField: 'payloadLength' });
 
-export type AdbPacketInit = Omit<typeof AdbPacketStruct['TInit'], 'checksum' | 'magic'>;
+export type AdbPacket = typeof AdbPacket['TDeserializeResult'];
 
-export namespace AdbPacket {
-    export async function read(backend: AdbBackend): Promise<AdbPacket> {
-        // Detect boundary
-        // Note that it relies on the backend to only return data from one write operation
-        let buffer: ArrayBuffer;
-        do {
-            // Maybe it's a payload from last connection.
-            // Ignore and try again
-            buffer = await backend.read(24);
-        } while (buffer.byteLength !== 24);
+// All the useful fields
+export type AdbPacketCore = Omit<typeof AdbPacket['TInit'], 'checksum' | 'magic'>;
 
-        let bufferUsed = false;
-        const stream = new BufferedStream({
-            async read(length: number) {
-                if (!bufferUsed) {
-                    bufferUsed = true;
-                    return buffer;
-                }
-                return backend.read(length);
-            }
-        });
+// All fields except `magic`, which can be calculated in `AdbPacketSerializeStream`
+export type AdbPacketInit = Omit<typeof AdbPacket['TInit'], 'magic'>;
 
-        return AdbPacketStruct.deserialize(stream);
+export function calculateChecksum(payload: Uint8Array): number;
+export function calculateChecksum(init: AdbPacketCore): AdbPacketInit;
+export function calculateChecksum(payload: Uint8Array | AdbPacketCore): 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 async function write(
-        init: AdbPacketInit,
-        calculateChecksum: boolean,
-        backend: AdbBackend
-    ): Promise<void> {
-        let checksum: number;
-        if (calculateChecksum && init.payload) {
-            const array = new Uint8Array(init.payload);
-            checksum = array.reduce((result, item) => result + item, 0);
-        } else {
-            checksum = 0;
-        }
+export class AdbPacketSerializeStream extends TransformStream<AdbPacketInit, Uint8Array>{
+    public constructor() {
+        super({
+            transform: async (init, controller) => {
+                // This syntax is ugly, but I don't want to create an new object.
+                (init as unknown as AdbPacketHeaderInit).magic = init.command ^ 0xFFFFFFFF;
+                (init as unknown as AdbPacketHeaderInit).payloadLength = init.payload.byteLength;
 
-        const packet = {
-            ...init,
-            checksum,
-            magic: init.command ^ 0xFFFFFFFF,
-            payloadLength: init.payload.byteLength,
-        };
+                controller.enqueue(
+                    AdbPacketHeader.serialize(
+                        init as unknown as AdbPacketHeaderInit
+                    )
+                );
 
-        // Write payload separately to avoid an extra copy
-        const header = AdbPacketHeader.serialize(packet);
-        await backend.write(header);
-        if (packet.payload.byteLength) {
-            await backend.write(packet.payload);
-        }
+                if (init.payload.byteLength) {
+                    // Enqueue payload separately to avoid copying
+                    controller.enqueue(init.payload);
+                }
+            },
+        });
     }
 }