@yume-chan/adb 0.0.17 → 0.0.18

package/src/commands/sync/stat.ts

@@ -1,8 +1,11 @@
-import type { BufferedReadableStream, WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
-import Struct, { placeholder } from '@yume-chan/struct';
+import {
+    type BufferedReadableStream,
+    type WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
+import Struct, { placeholder } from "@yume-chan/struct";
 
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
-import { adbSyncReadResponse, AdbSyncResponseId } from './response.js';
+import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
+import { AdbSyncResponseId, adbSyncReadResponse } from "./response.js";
 
 // https://github.com/python/cpython/blob/4e581d64b8aff3e2eda99b12f080c877bb78dfca/Lib/stat.py#L36
 export enum LinuxFileType {
@@ -24,27 +27,27 @@ export interface AdbSyncStat {
     ctime?: bigint;
 }
 
-export const AdbSyncLstatResponse =
-    new Struct({ littleEndian: true })
-        .int32('mode')
-        .int32('size')
-        .int32('mtime')
-        .extra({
-            id: AdbSyncResponseId.Lstat as const,
-            get type() { return this.mode >> 12 as LinuxFileType; },
-            get permission() { return this.mode & 0b00001111_11111111; },
-        })
-        .postDeserialize((object) => {
-            if (
-                object.mode === 0 &&
-                object.size === 0 &&
-                object.mtime === 0
-            ) {
-                throw new Error('lstat failed');
-            }
-        });
+export const AdbSyncLstatResponse = new Struct({ littleEndian: true })
+    .int32("mode")
+    .int32("size")
+    .int32("mtime")
+    .extra({
+        id: AdbSyncResponseId.Lstat as const,
+        get type() {
+            return (this.mode >> 12) as LinuxFileType;
+        },
+        get permission() {
+            return this.mode & 0b00001111_11111111;
+        },
+    })
+    .postDeserialize((object) => {
+        if (object.mode === 0 && object.size === 0 && object.mtime === 0) {
+            throw new Error("lstat error");
+        }
+    });
 
-export type AdbSyncLstatResponse = typeof AdbSyncLstatResponse['TDeserializeResult'];
+export type AdbSyncLstatResponse =
+    typeof AdbSyncLstatResponse["TDeserializeResult"];
 
 export enum AdbSyncStatErrorCode {
     SUCCESS = 0,
@@ -70,51 +73,67 @@ export enum AdbSyncStatErrorCode {
     ETXTBSY = 26,
 }
 
-export const AdbSyncStatResponse =
-    new Struct({ littleEndian: true })
-        .uint32('error', placeholder<AdbSyncStatErrorCode>())
-        .uint64('dev')
-        .uint64('ino')
-        .uint32('mode')
-        .uint32('nlink')
-        .uint32('uid')
-        .uint32('gid')
-        .uint64('size')
-        .uint64('atime')
-        .uint64('mtime')
-        .uint64('ctime')
-        .extra({
-            id: AdbSyncResponseId.Stat as const,
-            get type() { return this.mode >> 12 as LinuxFileType; },
-            get permission() { return this.mode & 0b00001111_11111111; },
-        })
-        .postDeserialize((object) => {
-            if (object.error) {
-                throw new Error(AdbSyncStatErrorCode[object.error]);
-            }
-        });
+export const AdbSyncStatResponse = new Struct({ littleEndian: true })
+    .uint32("error", placeholder<AdbSyncStatErrorCode>())
+    .uint64("dev")
+    .uint64("ino")
+    .uint32("mode")
+    .uint32("nlink")
+    .uint32("uid")
+    .uint32("gid")
+    .uint64("size")
+    .uint64("atime")
+    .uint64("mtime")
+    .uint64("ctime")
+    .extra({
+        id: AdbSyncResponseId.Stat as const,
+        get type() {
+            return (this.mode >> 12) as LinuxFileType;
+        },
+        get permission() {
+            return this.mode & 0b00001111_11111111;
+        },
+    })
+    .postDeserialize((object) => {
+        if (object.error) {
+            throw new Error(AdbSyncStatErrorCode[object.error]);
+        }
+    });
 
-export type AdbSyncStatResponse = typeof AdbSyncStatResponse['TDeserializeResult'];
+export type AdbSyncStatResponse =
+    typeof AdbSyncStatResponse["TDeserializeResult"];
 
 export async function adbSyncLstat(
     stream: BufferedReadableStream,
     writer: WritableStreamDefaultWriter<Uint8Array>,
     path: string,
-    v2: boolean,
+    v2: boolean
 ): Promise<AdbSyncStat> {
     if (v2) {
         await adbSyncWriteRequest(writer, AdbSyncRequestId.Lstat2, path);
-        return await adbSyncReadResponse(stream, AdbSyncResponseId.Lstat2, AdbSyncStatResponse);
+        return await adbSyncReadResponse(
+            stream,
+            AdbSyncResponseId.Lstat2,
+            AdbSyncStatResponse
+        );
     } else {
         await adbSyncWriteRequest(writer, AdbSyncRequestId.Lstat, path);
-        const response = await adbSyncReadResponse(stream, AdbSyncResponseId.Lstat, AdbSyncLstatResponse);
+        const response = await adbSyncReadResponse(
+            stream,
+            AdbSyncResponseId.Lstat,
+            AdbSyncLstatResponse
+        );
         return {
             mode: response.mode,
             // Convert to `BigInt` to make it compatible with `AdbSyncStatResponse`
             size: BigInt(response.size),
             mtime: BigInt(response.mtime),
-            get type() { return response.type; },
-            get permission() { return response.permission; },
+            get type() {
+                return response.type;
+            },
+            get permission() {
+                return response.permission;
+            },
         };
     }
 }
@@ -122,8 +141,12 @@ export async function adbSyncLstat(
 export async function adbSyncStat(
     stream: BufferedReadableStream,
     writer: WritableStreamDefaultWriter<Uint8Array>,
-    path: string,
+    path: string
 ): Promise<AdbSyncStatResponse> {
     await adbSyncWriteRequest(writer, AdbSyncRequestId.Stat, path);
-    return await adbSyncReadResponse(stream, AdbSyncResponseId.Stat, AdbSyncStatResponse);
+    return await adbSyncReadResponse(
+        stream,
+        AdbSyncResponseId.Stat,
+        AdbSyncStatResponse
+    );
 }

package/src/commands/sync/sync.ts

@@ -1,15 +1,23 @@
-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 {
+    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 { 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";
 
 /**
  * A simplified `dirname` function that only handles absolute unix paths.
@@ -17,12 +25,12 @@ 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);
 }
@@ -51,7 +59,10 @@ export class AdbSync extends AutoDisposable {
 
     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.adb.features.includes(AdbFeatures.ShellV2) &&
+            !this.fixedPushMkdir
+        );
     }
 
     public constructor(adb: Adb, socket: AdbSocket) {
@@ -66,7 +77,12 @@ export class AdbSync extends AutoDisposable {
         await this.sendLock.wait();
 
         try {
-            return adbSyncLstat(this.stream, this.writer, path, this.supportsStat);
+            return adbSyncLstat(
+                this.stream,
+                this.writer,
+                path,
+                this.supportsStat
+            );
         } finally {
             this.sendLock.notify();
         }
@@ -74,7 +90,7 @@ export class AdbSync extends AutoDisposable {
 
     public async stat(path: string) {
         if (!this.supportsStat) {
-            throw new Error('Not supported');
+            throw new Error("Not supported");
         }
 
         await this.sendLock.wait();
@@ -88,7 +104,7 @@ export class AdbSync extends AutoDisposable {
 
     public async isDirectory(path: string): Promise<boolean> {
         try {
-            await this.lstat(path + '/');
+            await this.lstat(path + "/");
             return true;
         } catch (e) {
             return false;
@@ -101,7 +117,12 @@ export class AdbSync extends AutoDisposable {
         await this.sendLock.wait();
 
         try {
-            yield* adbSyncOpenDir(this.stream, this.writer, path, this.supportsList2);
+            yield* adbSyncOpenDir(
+                this.stream,
+                this.writer,
+                path,
+                this.supportsList2
+            );
         } finally {
             this.sendLock.notify();
         }
@@ -127,7 +148,7 @@ export class AdbSync extends AutoDisposable {
                 await this.sendLock.wait();
                 return adbSyncPull(this.stream, this.writer, filename);
             },
-            close: async () => {
+            close: () => {
                 this.sendLock.notify();
             },
         });
@@ -144,7 +165,7 @@ export class AdbSync extends AutoDisposable {
     public write(
         filename: string,
         mode?: number,
-        mtime?: number,
+        mtime?: number
     ): WritableStream<Uint8Array> {
         return new WrapWritableStream({
             start: async () => {
@@ -155,8 +176,8 @@ export class AdbSync extends AutoDisposable {
                     // Ignore the result.
                     // TODO: sync: test push mkdir workaround (need an Android 8 device)
                     await this.adb.subprocess.spawnAndWait([
-                        'mkdir',
-                        '-p',
+                        "mkdir",
+                        "-p",
                         escapeArg(dirname(filename)),
                     ]);
                 }
@@ -166,12 +187,12 @@ export class AdbSync extends AutoDisposable {
                     this.writer,
                     filename,
                     mode,
-                    mtime,
+                    mtime
                 );
             },
-            close: async () => {
+            close: () => {
                 this.sendLock.notify();
-            }
+            },
         });
     }
 

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/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 { TransformStream } 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,29 +38,41 @@ 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 = Omit<typeof AdbPacket["TInit"], "magic">;
 
 export function calculateChecksum(payload: Uint8Array): number;
 export function calculateChecksum(init: AdbPacketData): AdbPacketInit;
-export function calculateChecksum(payload: Uint8Array | AdbPacketData): number | 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);
+        (payload as AdbPacketInit).checksum = calculateChecksum(
+            payload.payload
+        );
         return payload as AdbPacketInit;
     }
 }
 
-export class AdbPacketSerializeStream extends TransformStream<AdbPacketInit, Uint8Array>{
+export class AdbPacketSerializeStream extends TransformStream<
+    AdbPacketInit,
+    Uint8Array
+> {
     public constructor() {
         super({
-            transform: async (init, controller) => {
+            transform: (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;
+                (init as unknown as AdbPacketHeaderInit).magic =
+                    init.command ^ 0xffffffff;
+                (init as unknown as AdbPacketHeaderInit).payloadLength =
+                    init.payload.byteLength;
 
                 controller.enqueue(
                     AdbPacketHeader.serialize(