@yume-chan/adb 0.0.24 → 1.1.0

package/src/commands/sync/response.ts

@@ -1,10 +1,6 @@
 import { getUint32LittleEndian } from "@yume-chan/no-data-view";
-import type {
-    AsyncExactReadable,
-    StructLike,
-    StructValueType,
-} from "@yume-chan/struct";
-import Struct, { decodeUtf8 } from "@yume-chan/struct";
+import type { AsyncExactReadable, StructLike } from "@yume-chan/struct";
+import { decodeUtf8, string, struct, u32 } from "@yume-chan/struct";
 
 function encodeAsciiUnchecked(value: string): Uint8Array {
     const result = new Uint8Array(value.length);
@@ -18,32 +14,37 @@ function encodeAsciiUnchecked(value: string): Uint8Array {
  * Encode ID to numbers for faster comparison
  * @param value A 4-character string
  * @returns A 32-bit integer by encoding the string as little-endian
+ *
+ * #__NO_SIDE_EFFECTS__
  */
 export function adbSyncEncodeId(value: string): number {
     const buffer = encodeAsciiUnchecked(value);
     return getUint32LittleEndian(buffer, 0);
 }
 
-export namespace AdbSyncResponseId {
-    export const Entry = adbSyncEncodeId("DENT");
-    export const Entry2 = adbSyncEncodeId("DNT2");
-    export const Lstat = adbSyncEncodeId("STAT");
-    export const Stat = adbSyncEncodeId("STA2");
-    export const Lstat2 = adbSyncEncodeId("LST2");
-    export const Done = adbSyncEncodeId("DONE");
-    export const Data = adbSyncEncodeId("DATA");
-    export const Ok = adbSyncEncodeId("OKAY");
-    export const Fail = adbSyncEncodeId("FAIL");
-}
+export const AdbSyncResponseId = {
+    Entry: adbSyncEncodeId("DENT"),
+    Entry2: adbSyncEncodeId("DNT2"),
+    Lstat: adbSyncEncodeId("STAT"),
+    Stat: adbSyncEncodeId("STA2"),
+    Lstat2: adbSyncEncodeId("LST2"),
+    Done: adbSyncEncodeId("DONE"),
+    Data: adbSyncEncodeId("DATA"),
+    Ok: adbSyncEncodeId("OKAY"),
+    Fail: adbSyncEncodeId("FAIL"),
+};
 
 export class AdbSyncError extends Error {}
 
-export const AdbSyncFailResponse = new Struct({ littleEndian: true })
-    .uint32("messageLength")
-    .string("message", { lengthField: "messageLength" })
-    .postDeserialize((object) => {
-        throw new AdbSyncError(object.message);
-    });
+export const AdbSyncFailResponse = struct(
+    { message: string(u32) },
+    {
+        littleEndian: true,
+        postDeserialize(value) {
+            throw new AdbSyncError(value.message);
+        },
+    },
+);
 
 export async function adbSyncReadResponse<T>(
     stream: AsyncExactReadable,
@@ -68,13 +69,11 @@ export async function adbSyncReadResponse<T>(
     }
 }
 
-export async function* adbSyncReadResponses<
-    T extends Struct<object, PropertyKey, object, unknown>,
->(
+export async function* adbSyncReadResponses<T>(
     stream: AsyncExactReadable,
     id: number | string,
-    type: T,
-): AsyncGenerator<StructValueType<T>, void, void> {
+    type: StructLike<T>,
+): AsyncGenerator<T, void, void> {
     if (typeof id === "string") {
         id = adbSyncEncodeId(id);
     }
@@ -93,7 +92,7 @@ export async function* adbSyncReadResponses<
                 await stream.readExactly(type.size);
                 return;
             case id:
-                yield (await type.deserialize(stream)) as StructValueType<T>;
+                yield await type.deserialize(stream);
                 break;
             default:
                 throw new Error(

package/src/commands/sync/socket.ts

@@ -35,9 +35,9 @@ export class AdbSyncSocketLocked implements AsyncExactReadable {
         this.#combiner = new BufferCombiner(bufferSize);
     }
 
-    async #write(buffer: Uint8Array) {
+    #write(buffer: Uint8Array) {
         // `#combiner` will reuse the buffer, so we need to use the Consumable pattern
-        await Consumable.WritableStream.write(this.#writer, buffer);
+        return Consumable.WritableStream.write(this.#writer, buffer);
     }
 
     async flush() {

package/src/commands/sync/stat.ts

@@ -1,15 +1,18 @@
-import Struct, { placeholder } from "@yume-chan/struct";
+import type { StructValue } from "@yume-chan/struct";
+import { struct, u32, u64 } from "@yume-chan/struct";
 
 import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
 import { AdbSyncResponseId, adbSyncReadResponse } from "./response.js";
 import type { AdbSyncSocket } from "./socket.js";
 
 // https://github.com/python/cpython/blob/4e581d64b8aff3e2eda99b12f080c877bb78dfca/Lib/stat.py#L36
-export enum LinuxFileType {
-    Directory = 0o04,
-    File = 0o10,
-    Link = 0o12,
-}
+export const LinuxFileType = {
+    Directory: 0o04,
+    File: 0o10,
+    Link: 0o12,
+} as const;
+
+export type LinuxFileType = (typeof LinuxFileType)[keyof typeof LinuxFileType];
 
 export interface AdbSyncStat {
     mode: number;
@@ -24,79 +27,98 @@ export interface AdbSyncStat {
     ctime?: bigint;
 }
 
-export const AdbSyncLstatResponse = new Struct({ littleEndian: true })
-    .int32("mode")
-    .int32("size")
-    .int32("mtime")
-    .extra({
-        get type() {
-            return (this.mode >> 12) as LinuxFileType;
+export const AdbSyncLstatResponse = struct(
+    { mode: u32, size: u32, mtime: u32 },
+    {
+        littleEndian: true,
+        extra: {
+            get type(): LinuxFileType {
+                return (this.mode >> 12) as LinuxFileType;
+            },
+            get permission(): number {
+                return this.mode & 0b00001111_11111111;
+            },
         },
-        get permission() {
-            return this.mode & 0b00001111_11111111;
+        postDeserialize(value) {
+            if (value.mode === 0 && value.size === 0 && value.mtime === 0) {
+                throw new Error("lstat error");
+            }
+            return value;
         },
-    })
-    .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 = StructValue<typeof AdbSyncLstatResponse>;
 
-export enum AdbSyncStatErrorCode {
-    SUCCESS = 0,
-    EACCES = 13,
-    EEXIST = 17,
-    EFAULT = 14,
-    EFBIG = 27,
-    EINTR = 4,
-    EINVAL = 22,
-    EIO = 5,
-    EISDIR = 21,
-    ELOOP = 40,
-    EMFILE = 24,
-    ENAMETOOLONG = 36,
-    ENFILE = 23,
-    ENOENT = 2,
-    ENOMEM = 12,
-    ENOSPC = 28,
-    ENOTDIR = 20,
-    EOVERFLOW = 75,
-    EPERM = 1,
-    EROFS = 30,
-    ETXTBSY = 26,
-}
+export const AdbSyncStatErrorCode = {
+    SUCCESS: 0,
+    EACCES: 13,
+    EEXIST: 17,
+    EFAULT: 14,
+    EFBIG: 27,
+    EINTR: 4,
+    EINVAL: 22,
+    EIO: 5,
+    EISDIR: 21,
+    ELOOP: 40,
+    EMFILE: 24,
+    ENAMETOOLONG: 36,
+    ENFILE: 23,
+    ENOENT: 2,
+    ENOMEM: 12,
+    ENOSPC: 28,
+    ENOTDIR: 20,
+    EOVERFLOW: 75,
+    EPERM: 1,
+    EROFS: 30,
+    ETXTBSY: 26,
+} as const;
 
-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({
-        get type() {
-            return (this.mode >> 12) as LinuxFileType;
+export type AdbSyncStatErrorCode =
+    (typeof AdbSyncStatErrorCode)[keyof typeof AdbSyncStatErrorCode];
+
+const AdbSyncStatErrorName = /* #__PURE__ */ (() =>
+    Object.fromEntries(
+        Object.entries(AdbSyncStatErrorCode).map(([key, value]) => [
+            value,
+            key,
+        ]),
+    ))();
+
+export const AdbSyncStatResponse = struct(
+    {
+        error: u32<AdbSyncStatErrorCode>(),
+        dev: u64,
+        ino: u64,
+        mode: u32,
+        nlink: u32,
+        uid: u32,
+        gid: u32,
+        size: u64,
+        atime: u64,
+        mtime: u64,
+        ctime: u64,
+    },
+    {
+        littleEndian: true,
+        extra: {
+            get type(): LinuxFileType {
+                return (this.mode >> 12) as LinuxFileType;
+            },
+            get permission(): number {
+                return this.mode & 0b00001111_11111111;
+            },
         },
-        get permission() {
-            return this.mode & 0b00001111_11111111;
+        postDeserialize(value) {
+            if (value.error) {
+                throw new Error(AdbSyncStatErrorName[value.error]);
+            }
+            return value;
         },
-    })
-    .postDeserialize((object) => {
-        if (object.error) {
-            throw new Error(AdbSyncStatErrorCode[object.error]);
-        }
-    });
+    },
+);
 
-export type AdbSyncStatResponse =
-    (typeof AdbSyncStatResponse)["TDeserializeResult"];
+export type AdbSyncStatResponse = StructValue<typeof AdbSyncStatResponse>;
 
 export async function adbSyncLstat(
     socket: AdbSyncSocket,

package/src/commands/sync/sync.ts

@@ -1,4 +1,3 @@
-import { AutoDisposable } from "@yume-chan/event";
 import type { MaybeConsumable, ReadableStream } from "@yume-chan/stream-extra";
 
 import type { Adb, AdbSocket } from "../../adb.js";
@@ -39,7 +38,7 @@ export interface AdbSyncWriteOptions {
     dryRun?: boolean;
 }
 
-export class AdbSync extends AutoDisposable {
+export class AdbSync {
     protected _adb: Adb;
     protected _socket: AdbSyncSocket;
 
@@ -70,8 +69,6 @@ export class AdbSync extends AutoDisposable {
     }
 
     constructor(adb: Adb, socket: AdbSocket) {
-        super();
-
         this._adb = adb;
         this._socket = new AdbSyncSocket(socket, adb.maxPayloadSize);
 
@@ -117,7 +114,7 @@ export class AdbSync extends AutoDisposable {
         try {
             await this.lstat(path + "/");
             return true;
-        } catch (e) {
+        } catch {
             return false;
         }
     }
@@ -172,8 +169,7 @@ export class AdbSync extends AutoDisposable {
         return this._socket.lock();
     }
 
-    override async dispose() {
-        super.dispose();
-        await this._socket.close();
+    dispose() {
+        return this._socket.close();
     }
 }

package/src/commands/tcpip.ts

@@ -20,14 +20,14 @@ export interface AdbTcpIpListenAddresses {
     persistPort: number | undefined;
 }
 
-export class AdbTcpIpCommand extends AdbCommandBase {
-    #parsePort(value: string): number | undefined {
-        if (!value || value === "0") {
-            return undefined;
-        }
-        return Number.parseInt(value, 10);
+function parsePort(value: string): number | undefined {
+    if (!value || value === "0") {
+        return undefined;
     }
+    return Number.parseInt(value, 10);
+}
 
+export class AdbTcpIpCommand extends AdbCommandBase {
     async getListenAddresses(): Promise<AdbTcpIpListenAddresses> {
         const serviceListenAddresses = await this.adb.getProp(
             "service.adb.listen_addrs",
@@ -40,8 +40,8 @@ export class AdbTcpIpCommand extends AdbCommandBase {
                 serviceListenAddresses != ""
                     ? serviceListenAddresses.split(",")
                     : [],
-            servicePort: this.#parsePort(servicePort),
-            persistPort: this.#parsePort(persistPort),
+            servicePort: parsePort(servicePort),
+            persistPort: parsePort(persistPort),
         };
     }
 

package/src/daemon/auth.ts

@@ -1,7 +1,7 @@
+import type { MaybePromiseLike } from "@yume-chan/async";
 import { PromiseResolver } from "@yume-chan/async";
 import type { Disposable } from "@yume-chan/event";
-import type { ValueOrPromise } from "@yume-chan/struct";
-import { EMPTY_UINT8_ARRAY } from "@yume-chan/struct";
+import { EmptyUint8Array } from "@yume-chan/struct";
 
 import {
     calculateBase64EncodedLength,
@@ -33,7 +33,7 @@ export interface AdbCredentialStore {
     /**
      * Generates and stores a RSA private key with modulus length `2048` and public exponent `65537`.
      */
-    generateKey(): ValueOrPromise<AdbPrivateKey>;
+    generateKey(): MaybePromiseLike<AdbPrivateKey>;
 
     /**
      * Synchronously or asynchronously iterates through all stored RSA private keys.
@@ -43,11 +43,13 @@ export interface AdbCredentialStore {
     iterateKeys(): AdbKeyIterable;
 }
 
-export enum AdbAuthType {
-    Token = 1,
-    Signature = 2,
-    PublicKey = 3,
-}
+export const AdbAuthType = {
+    Token: 1,
+    Signature: 2,
+    PublicKey: 3,
+} as const;
+
+export type AdbAuthType = (typeof AdbAuthType)[keyof typeof AdbAuthType];
 
 export interface AdbAuthenticator {
     /**
@@ -114,7 +116,7 @@ export const AdbPublicKeyAuthenticator: AdbAuthenticator = async function* (
 
     const nameBuffer = privateKey.name?.length
         ? encodeUtf8(privateKey.name)
-        : EMPTY_UINT8_ARRAY;
+        : EmptyUint8Array;
     const publicKeyBuffer = new Uint8Array(
         publicKeyBase64Length +
             (nameBuffer.length ? nameBuffer.length + 1 : 0) + // Space character + name

package/src/daemon/crypto.ts

@@ -38,6 +38,8 @@ export function getBigUint(
  * @param littleEndian If `false` or `undefined`, a big-endian value should be written,
  * otherwise a little-endian value should be written.
  */
+
+// eslint-disable-next-line @typescript-eslint/max-params
 export function setBigUint(
     array: Uint8Array,
     byteOffset: number,

package/src/daemon/device.ts

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

package/src/daemon/dispatcher.ts

@@ -16,7 +16,7 @@ import {
     Consumable,
     WritableStream,
 } from "@yume-chan/stream-extra";
-import { EMPTY_UINT8_ARRAY, decodeUtf8, encodeUtf8 } from "@yume-chan/struct";
+import { EmptyUint8Array, decodeUtf8, encodeUtf8 } from "@yume-chan/struct";
 
 import type { AdbIncomingSocketHandler, AdbSocket, Closeable } from "../adb.js";
 
@@ -259,7 +259,7 @@ export class AdbPacketDispatcher implements Closeable {
             AdbCommand.Close,
             packet.arg1,
             packet.arg0,
-            EMPTY_UINT8_ARRAY,
+            EmptyUint8Array,
         );
     }
 
@@ -271,7 +271,7 @@ export class AdbPacketDispatcher implements Closeable {
             payload = new Uint8Array(4);
             setUint32LittleEndian(payload, 0, ackBytes);
         } else {
-            payload = EMPTY_UINT8_ARRAY;
+            payload = EmptyUint8Array;
         }
 
         return this.sendPacket(AdbCommand.Okay, localId, remoteId, payload);
@@ -312,7 +312,7 @@ export class AdbPacketDispatcher implements Closeable {
                 AdbCommand.Close,
                 0,
                 remoteId,
-                EMPTY_UINT8_ARRAY,
+                EmptyUint8Array,
             );
             return;
         }
@@ -334,12 +334,12 @@ export class AdbPacketDispatcher implements Closeable {
                 remoteId,
                 this.options.initialDelayedAckBytes,
             );
-        } catch (e) {
+        } catch {
             await this.sendPacket(
                 AdbCommand.Close,
                 0,
                 remoteId,
-                EMPTY_UINT8_ARRAY,
+                EmptyUint8Array,
             );
         }
     }

package/src/daemon/packet.ts

@@ -1,32 +1,43 @@
 import { Consumable, TransformStream } from "@yume-chan/stream-extra";
-import Struct from "@yume-chan/struct";
+import type { StructInit, StructValue } from "@yume-chan/struct";
+import { buffer, s32, struct, u32 } from "@yume-chan/struct";
 
-export enum AdbCommand {
-    Auth = 0x48545541, // 'AUTH'
-    Close = 0x45534c43, // 'CLSE'
-    Connect = 0x4e584e43, // 'CNXN'
-    Okay = 0x59414b4f, // 'OKAY'
-    Open = 0x4e45504f, // 'OPEN'
-    Write = 0x45545257, // 'WRTE'
-}
+export const AdbCommand = {
+    Auth: 0x48545541, // 'AUTH'
+    Close: 0x45534c43, // 'CLSE'
+    Connect: 0x4e584e43, // 'CNXN'
+    Okay: 0x59414b4f, // 'OKAY'
+    Open: 0x4e45504f, // 'OPEN'
+    Write: 0x45545257, // 'WRTE'
+} as const;
+
+export type AdbCommand = (typeof AdbCommand)[keyof typeof AdbCommand];
 
-export const AdbPacketHeader = new Struct({ littleEndian: true })
-    .uint32("command")
-    .uint32("arg0")
-    .uint32("arg1")
-    .uint32("payloadLength")
-    .uint32("checksum")
-    .int32("magic");
+export const AdbPacketHeader = struct(
+    {
+        command: u32,
+        arg0: u32,
+        arg1: u32,
+        payloadLength: u32,
+        checksum: u32,
+        magic: s32,
+    },
+    { littleEndian: true },
+);
 
-export type AdbPacketHeader = (typeof AdbPacketHeader)["TDeserializeResult"];
+export type AdbPacketHeader = StructValue<typeof AdbPacketHeader>;
 
-type AdbPacketHeaderInit = (typeof AdbPacketHeader)["TInit"];
+type AdbPacketHeaderInit = StructInit<typeof AdbPacketHeader>;
 
-export const AdbPacket = new Struct({ littleEndian: true })
-    .concat(AdbPacketHeader)
-    .uint8Array("payload", { lengthField: "payloadLength" });
+export const AdbPacket = struct(
+    /* #__PURE__ */ (() => ({
+        ...AdbPacketHeader.fields,
+        payload: buffer("payloadLength"),
+    }))(),
+    { littleEndian: true },
+);
 
-export type AdbPacket = (typeof AdbPacket)["TDeserializeResult"];
+export type AdbPacket = StructValue<typeof AdbPacket>;
 
 /**
  * `AdbPacketData` contains all the useful fields of `AdbPacket`.
@@ -39,11 +50,11 @@ export type AdbPacket = (typeof AdbPacket)["TDeserializeResult"];
  * so `AdbSocket#writable#write` only needs `AdbPacketData`.
  */
 export type AdbPacketData = Omit<
-    (typeof AdbPacket)["TInit"],
+    StructInit<typeof AdbPacket>,
     "checksum" | "magic"
 >;
 
-export type AdbPacketInit = (typeof AdbPacket)["TInit"];
+export type AdbPacketInit = StructInit<typeof AdbPacket>;
 
 export function calculateChecksum(payload: Uint8Array): number {
     return payload.reduce((result, item) => result + item, 0);
@@ -61,9 +72,10 @@ export class AdbPacketSerializeStream extends TransformStream<
                     const init = chunk as AdbPacketInit & AdbPacketHeaderInit;
                     init.payloadLength = init.payload.length;
 
+                    AdbPacketHeader.serialize(init, headerBuffer);
                     await Consumable.ReadableStream.enqueue(
                         controller,
-                        AdbPacketHeader.serialize(init, headerBuffer),
+                        headerBuffer,
                     );
 
                     if (init.payloadLength) {

package/src/daemon/socket.ts

@@ -7,7 +7,7 @@ import type {
     WritableStreamDefaultController,
 } from "@yume-chan/stream-extra";
 import { MaybeConsumable, PushReadableStream } from "@yume-chan/stream-extra";
-import { EMPTY_UINT8_ARRAY } from "@yume-chan/struct";
+import { EmptyUint8Array } from "@yume-chan/struct";
 
 import type { AdbSocket } from "../adb.js";
 
@@ -138,20 +138,7 @@ export class AdbDaemonSocketController
     }
 
     async enqueue(data: Uint8Array) {
-        // Consumers can `cancel` the `readable` if they are not interested in future data.
-        // Throw away the data if that happens.
-        if (this.#readableController.abortSignal.aborted) {
-            return;
-        }
-
-        try {
-            await this.#readableController.enqueue(data);
-        } catch (e) {
-            if (this.#readableController.abortSignal.aborted) {
-                return;
-            }
-            throw e;
-        }
+        await this.#readableController.enqueue(data);
     }
 
     public ack(bytes: number) {
@@ -177,28 +164,18 @@ export class AdbDaemonSocketController
             AdbCommand.Close,
             this.localId,
             this.remoteId,
-            EMPTY_UINT8_ARRAY,
+            EmptyUint8Array,
         );
     }
 
     dispose() {
-        try {
-            this.#readableController.close();
-        } catch {
-            // ignore
-        }
-
+        this.#readableController.close();
         this.#closedPromise.resolve();
     }
 }
 
 /**
  * A duplex stream representing a socket to ADB daemon.
- *
- * To close it, call either `socket.close()`,
- * `socket.readable.cancel()`, `socket.readable.getReader().cancel()`,
- * `socket.writable.abort()`, `socket.writable.getWriter().abort()`,
- * `socket.writable.close()` or `socket.writable.getWriter().close()`.
  */
 export class AdbDaemonSocket implements AdbDaemonSocketInfo, AdbSocket {
     #controller: AdbDaemonSocketController;