@yume-chan/adb 0.0.19 → 0.0.21

package/src/commands/subprocess/protocols/shell.ts

@@ -10,16 +10,14 @@ import {
     ConsumableWritableStream,
     PushReadableStream,
     StructDeserializeStream,
-    TransformStream,
     WritableStream,
     pipeFrom,
 } from "@yume-chan/stream-extra";
 import type { StructValueType } from "@yume-chan/struct";
 import Struct, { placeholder } from "@yume-chan/struct";
 
-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 { encodeUtf8 } from "../../../utils/index.js";
 
 import type { AdbSubprocessProtocol } from "./types.js";
@@ -62,54 +60,39 @@ class StdinSerializeStream extends ConsumableTransformStream<
     }
 }
 
-class StdoutDeserializeStream extends TransformStream<
-    AdbShellProtocolPacket,
-    Uint8Array
-> {
-    constructor(type: AdbShellProtocolId.Stdout | AdbShellProtocolId.Stderr) {
-        super({
-            transform(chunk, controller) {
-                if (chunk.id === type) {
-                    controller.enqueue(chunk.data);
-                }
-            },
-        });
-    }
-}
-
 class MultiplexStream<T> {
-    private _readable: PushReadableStream<T>;
-    private _readableController!: PushReadableStreamController<T>;
-    public get readable() {
-        return this._readable;
+    #readable: PushReadableStream<T>;
+    #readableController!: PushReadableStreamController<T>;
+    get readable() {
+        return this.#readable;
     }
 
-    private _activeCount = 0;
+    #activeCount = 0;
 
     constructor() {
-        this._readable = new PushReadableStream((controller) => {
-            this._readableController = controller;
+        this.#readable = new PushReadableStream((controller) => {
+            this.#readableController = controller;
         });
     }
 
-    public createWriteable() {
+    createWriteable() {
         return new WritableStream<T>({
             start: () => {
-                this._activeCount += 1;
+                this.#activeCount += 1;
             },
             write: async (chunk) => {
-                await this._readableController.enqueue(chunk);
+                await this.#readableController.enqueue(chunk);
             },
             abort: () => {
-                this._activeCount -= 1;
-                if (this._activeCount === 0) {
-                    this._readableController.close();
+                this.#activeCount -= 1;
+                if (this.#activeCount === 0) {
+                    this.#readableController.close();
                 }
             },
             close: () => {
-                this._activeCount -= 1;
-                if (this._activeCount === 0) {
-                    this._readableController.close();
+                this.#activeCount -= 1;
+                if (this.#activeCount === 0) {
+                    this.#readableController.close();
                 }
             },
         });
@@ -125,84 +108,99 @@ class MultiplexStream<T> {
  * * `resize`: Yes
  */
 export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
-    public static isSupported(adb: Adb) {
+    static isSupported(adb: Adb) {
         return adb.supportsFeature(AdbFeature.ShellV2);
     }
 
-    public static async pty(adb: Adb, command: string) {
+    static async pty(adb: Adb, command: string) {
         // TODO: AdbShellSubprocessProtocol: Support setting `XTERM` environment variable
         return new AdbSubprocessShellProtocol(
-            await adb.createSocket(`shell,v2,pty:${command}`)
+            await adb.createSocket(`shell,v2,pty:${command}`),
         );
     }
 
-    public static async raw(adb: Adb, command: string) {
+    static async raw(adb: Adb, command: string) {
         return new AdbSubprocessShellProtocol(
-            await adb.createSocket(`shell,v2,raw:${command}`)
+            await adb.createSocket(`shell,v2,raw:${command}`),
         );
     }
 
-    private readonly _socket: AdbSocket;
-    private _socketWriter: WritableStreamDefaultWriter<
+    readonly #socket: AdbSocket;
+    #socketWriter: WritableStreamDefaultWriter<
         Consumable<AdbShellProtocolPacketInit>
     >;
 
-    private _stdin: WritableStream<Consumable<Uint8Array>>;
-    public get stdin() {
-        return this._stdin;
+    #stdin: WritableStream<Consumable<Uint8Array>>;
+    get stdin() {
+        return this.#stdin;
     }
 
-    private _stdout: ReadableStream<Uint8Array>;
-    public get stdout() {
-        return this._stdout;
+    #stdout: ReadableStream<Uint8Array>;
+    get stdout() {
+        return this.#stdout;
     }
 
-    private _stderr: ReadableStream<Uint8Array>;
-    public get stderr() {
-        return this._stderr;
+    #stderr: ReadableStream<Uint8Array>;
+    get stderr() {
+        return this.#stderr;
     }
 
-    private readonly _exit = new PromiseResolver<number>();
-    public get exit() {
-        return this._exit.promise;
+    readonly #exit = new PromiseResolver<number>();
+    get exit() {
+        return this.#exit.promise;
     }
 
-    public constructor(socket: AdbSocket) {
-        this._socket = socket;
+    constructor(socket: AdbSocket) {
+        this.#socket = socket;
 
         // Check this image to help you understand the stream graph
         // cspell: disable-next-line
         // https://www.plantuml.com/plantuml/png/bL91QiCm4Bpx5SAdv90lb1JISmiw5XzaQKf5PIkiLZIqzEyLSg8ks13gYtOykpFhiOw93N6UGjVDqK7rZsxKqNw0U_NTgVAy4empOy2mm4_olC0VEVEE47GUpnGjKdgXoD76q4GIEpyFhOwP_m28hW0NNzxNUig1_JdW0bA7muFIJDco1daJ_1SAX9bgvoPJPyIkSekhNYctvIGXrCH6tIsPL5fs-s6J5yc9BpWXhKtNdF2LgVYPGM_6GlMwfhWUsIt4lbScANrwlgVVUifPSVi__t44qStnwPvZwobdSmHHlL57p2vFuHS0
 
-        // TODO: AdbShellSubprocessProtocol: Optimize stream graph
+        let stdoutController!: PushReadableStreamController<Uint8Array>;
+        let stderrController!: PushReadableStreamController<Uint8Array>;
+        this.#stdout = new PushReadableStream<Uint8Array>((controller) => {
+            stdoutController = controller;
+        });
+        this.#stderr = new PushReadableStream<Uint8Array>((controller) => {
+            stderrController = controller;
+        });
 
-        const [stdout, stderr] = socket.readable
+        socket.readable
             .pipeThrough(new StructDeserializeStream(AdbShellProtocolPacket))
-            .pipeThrough(
-                new TransformStream<
-                    AdbShellProtocolPacket,
-                    AdbShellProtocolPacket
-                >({
-                    transform: (chunk, controller) => {
-                        if (chunk.id === AdbShellProtocolId.Exit) {
-                            this._exit.resolve(new Uint8Array(chunk.data)[0]!);
-                            // We can let `StdoutDeserializeStream` to process `AdbShellProtocolId.Exit`,
-                            // but since we need this `TransformStream` to capture the exit code anyway,
-                            // terminating child streams here is killing two birds with one stone.
-                            controller.terminate();
-                            return;
+            .pipeTo(
+                new WritableStream<AdbShellProtocolPacket>({
+                    write: async (chunk) => {
+                        switch (chunk.id) {
+                            case AdbShellProtocolId.Exit:
+                                this.#exit.resolve(chunk.data[0]!);
+                                break;
+                            case AdbShellProtocolId.Stdout:
+                                await stdoutController.enqueue(chunk.data);
+                                break;
+                            case AdbShellProtocolId.Stderr:
+                                await stderrController.enqueue(chunk.data);
+                                break;
                         }
-                        controller.enqueue(chunk);
                     },
-                })
+                }),
             )
-            .tee();
-        this._stdout = stdout.pipeThrough(
-            new StdoutDeserializeStream(AdbShellProtocolId.Stdout)
-        );
-        this._stderr = stderr.pipeThrough(
-            new StdoutDeserializeStream(AdbShellProtocolId.Stderr)
-        );
+            .then(
+                () => {
+                    stdoutController.close();
+                    stderrController.close();
+                    // If `#exit` has already resolved, this will be a no-op
+                    this.#exit.reject(
+                        new Error("Socket ended without exit message"),
+                    );
+                },
+                (e) => {
+                    stdoutController.error(e);
+                    stderrController.error(e);
+                    // If `#exit` has already resolved, this will be a no-op
+                    this.#exit.reject(e);
+                },
+            );
 
         const multiplexer = new MultiplexStream<
             Consumable<AdbShellProtocolPacketInit>
@@ -212,34 +210,34 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
                 new ConsumableTransformStream({
                     async transform(chunk, controller) {
                         await controller.enqueue(
-                            AdbShellProtocolPacket.serialize(chunk)
+                            AdbShellProtocolPacket.serialize(chunk),
                         );
                     },
-                })
+                }),
             )
             .pipeTo(socket.writable);
 
-        this._stdin = pipeFrom(
+        this.#stdin = pipeFrom(
             multiplexer.createWriteable(),
-            new StdinSerializeStream()
+            new StdinSerializeStream(),
         );
 
-        this._socketWriter = multiplexer.createWriteable().getWriter();
+        this.#socketWriter = multiplexer.createWriteable().getWriter();
     }
 
-    public async resize(rows: number, cols: number) {
-        await ConsumableWritableStream.write(this._socketWriter, {
+    async resize(rows: number, cols: number) {
+        await ConsumableWritableStream.write(this.#socketWriter, {
             id: AdbShellProtocolId.WindowSizeChange,
             data: encodeUtf8(
                 // The "correct" format is `${rows}x${cols},${x_pixels}x${y_pixels}`
                 // However, according to https://linux.die.net/man/4/tty_ioctl
                 // `x_pixels` and `y_pixels` are unused, so always sending `0` should be fine.
-                `${rows}x${cols},0x0\0`
+                `${rows}x${cols},0x0\0`,
             ),
         });
     }
 
-    public kill() {
-        return this._socket.close();
+    kill() {
+        return this.#socket.close();
     }
 }

package/src/commands/subprocess/protocols/types.ts

@@ -5,8 +5,7 @@ import type {
 } from "@yume-chan/stream-extra";
 import type { ValueOrPromise } from "@yume-chan/struct";
 
-import type { Adb } from "../../../adb.js";
-import type { AdbSocket } from "../../../socket/index.js";
+import type { Adb, AdbSocket } from "../../../adb.js";
 
 export interface AdbSubprocessProtocol {
     /**

package/src/commands/sync/list.ts

@@ -11,7 +11,7 @@ export interface AdbSyncEntry extends AdbSyncStat {
 }
 
 export const AdbSyncEntryResponse = new Struct({ littleEndian: true })
-    .fields(AdbSyncLstatResponse)
+    .concat(AdbSyncLstatResponse)
     .uint32("nameLength")
     .string("name", { lengthField: "nameLength" })
     .extra({ id: AdbSyncResponseId.Entry as const });
@@ -20,7 +20,7 @@ export type AdbSyncEntryResponse =
     (typeof AdbSyncEntryResponse)["TDeserializeResult"];
 
 export const AdbSyncEntry2Response = new Struct({ littleEndian: true })
-    .fields(AdbSyncStatResponse)
+    .concat(AdbSyncStatResponse)
     .uint32("nameLength")
     .string("name", { lengthField: "nameLength" })
     .extra({ id: AdbSyncResponseId.Entry2 as const });
@@ -30,7 +30,7 @@ export type AdbSyncEntry2Response =
 
 export async function* adbSyncOpenDirV2(
     socket: AdbSyncSocket,
-    path: string
+    path: string,
 ): AsyncGenerator<AdbSyncEntry2Response, void, void> {
     const locked = await socket.lock();
     try {
@@ -38,7 +38,7 @@ export async function* adbSyncOpenDirV2(
         for await (const item of adbSyncReadResponses(
             locked,
             AdbSyncResponseId.Entry2,
-            AdbSyncEntry2Response
+            AdbSyncEntry2Response,
         )) {
             // `LST2` can return error codes for failed `lstat` calls.
             // `LIST` just ignores them.
@@ -55,7 +55,7 @@ export async function* adbSyncOpenDirV2(
 
 export async function* adbSyncOpenDirV1(
     socket: AdbSyncSocket,
-    path: string
+    path: string,
 ): AsyncGenerator<AdbSyncEntryResponse, void, void> {
     const locked = await socket.lock();
     try {
@@ -63,7 +63,7 @@ export async function* adbSyncOpenDirV1(
         for await (const item of adbSyncReadResponses(
             locked,
             AdbSyncResponseId.Entry,
-            AdbSyncEntryResponse
+            AdbSyncEntryResponse,
         )) {
             yield item;
         }
@@ -75,7 +75,7 @@ export async function* adbSyncOpenDirV1(
 export async function* adbSyncOpenDir(
     socket: AdbSyncSocket,
     path: string,
-    v2: boolean
+    v2: boolean,
 ): AsyncGenerator<AdbSyncEntry, void, void> {
     if (v2) {
         yield* adbSyncOpenDirV2(socket, path);

package/src/commands/sync/pull.ts

@@ -16,7 +16,7 @@ export type AdbSyncDataResponse =
 
 export async function* adbSyncPullGenerator(
     socket: AdbSyncSocket,
-    path: string
+    path: string,
 ): AsyncGenerator<Uint8Array, void, void> {
     const locked = await socket.lock();
     let done = false;
@@ -25,7 +25,7 @@ export async function* adbSyncPullGenerator(
         for await (const packet of adbSyncReadResponses(
             locked,
             AdbSyncResponseId.Data,
-            AdbSyncDataResponse
+            AdbSyncDataResponse,
         )) {
             yield packet.data;
         }
@@ -36,7 +36,7 @@ export async function* adbSyncPullGenerator(
             for await (const packet of adbSyncReadResponses(
                 locked,
                 AdbSyncResponseId.Data,
-                AdbSyncDataResponse
+                AdbSyncDataResponse,
             )) {
                 void packet;
             }
@@ -47,7 +47,7 @@ export async function* adbSyncPullGenerator(
 
 export function adbSyncPull(
     socket: AdbSyncSocket,
-    path: string
+    path: string,
 ): ReadableStream<Uint8Array> {
     return new PushReadableStream(async (controller) => {
         for await (const data of adbSyncPullGenerator(socket, path)) {

package/src/commands/sync/push.ts

@@ -6,35 +6,34 @@ import {
 } from "@yume-chan/stream-extra";
 import Struct, { placeholder } from "@yume-chan/struct";
 
+import { NOOP } from "../../utils/index.js";
+
 import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
 import { AdbSyncResponseId, adbSyncReadResponse } from "./response.js";
 import type { AdbSyncSocket, AdbSyncSocketLocked } from "./socket.js";
 import { LinuxFileType } from "./stat.js";
 
-const NOOP = () => {
-    // no-op
-};
-
 export const ADB_SYNC_MAX_PACKET_SIZE = 64 * 1024;
 
 export interface AdbSyncPushV1Options {
     socket: AdbSyncSocket;
     filename: string;
     file: ReadableStream<Consumable<Uint8Array>>;
-    mode?: number;
+    type?: LinuxFileType;
+    permission?: number;
     mtime?: number;
     packetSize?: number;
 }
 
 export const AdbSyncOkResponse = new Struct({ littleEndian: true }).uint32(
-    "unused"
+    "unused",
 );
 
-async function pipeFile(
+async function pipeFileData(
     locked: AdbSyncSocketLocked,
     file: ReadableStream<Consumable<Uint8Array>>,
     packetSize: number,
-    mtime: number
+    mtime: number,
 ) {
     // Read and write in parallel,
     // allow error response to abort the write.
@@ -46,11 +45,11 @@ async function pipeFile(
                     await adbSyncWriteRequest(
                         locked,
                         AdbSyncRequestId.Data,
-                        chunk
+                        chunk,
                     );
                 },
             }),
-            { signal: abortController.signal }
+            { signal: abortController.signal },
         )
         .then(async () => {
             await adbSyncWriteRequest(locked, AdbSyncRequestId.Done, mtime);
@@ -60,7 +59,7 @@ async function pipeFile(
     await adbSyncReadResponse(
         locked,
         AdbSyncResponseId.Ok,
-        AdbSyncOkResponse
+        AdbSyncOkResponse,
     ).catch((e) => {
         abortController.abort();
         throw e;
@@ -71,15 +70,17 @@ export async function adbSyncPushV1({
     socket,
     filename,
     file,
-    mode = (LinuxFileType.File << 12) | 0o666,
+    type = LinuxFileType.File,
+    permission = 0o666,
     mtime = (Date.now() / 1000) | 0,
     packetSize = ADB_SYNC_MAX_PACKET_SIZE,
 }: AdbSyncPushV1Options) {
     const locked = await socket.lock();
     try {
+        const mode = (type << 12) | permission;
         const pathAndMode = `${filename},${mode.toString()}`;
         await adbSyncWriteRequest(locked, AdbSyncRequestId.Send, pathAndMode);
-        await pipeFile(locked, file, packetSize, mtime);
+        await pipeFileData(locked, file, packetSize, mtime);
     } finally {
         locked.release();
     }
@@ -103,6 +104,12 @@ export enum AdbSyncSendV2Flags {
 }
 
 export interface AdbSyncPushV2Options extends AdbSyncPushV1Options {
+    /**
+     * Don't write the file to disk. Requires the `sendrecv_v2` feature.
+     *
+     * It was used during ADB development to benchmark the performance of
+     * compression algorithms.
+     */
     dryRun?: boolean;
 }
 
@@ -115,7 +122,8 @@ export async function adbSyncPushV2({
     socket,
     filename,
     file,
-    mode = (LinuxFileType.File << 12) | 0o666,
+    type = LinuxFileType.File,
+    permission = 0o666,
     mtime = (Date.now() / 1000) | 0,
     packetSize = ADB_SYNC_MAX_PACKET_SIZE,
     dryRun = false,
@@ -124,6 +132,7 @@ export async function adbSyncPushV2({
     try {
         await adbSyncWriteRequest(locked, AdbSyncRequestId.SendV2, filename);
 
+        const mode = (type << 12) | permission;
         let flags: AdbSyncSendV2Flags = AdbSyncSendV2Flags.None;
         if (dryRun) {
             flags |= AdbSyncSendV2Flags.DryRun;
@@ -133,16 +142,19 @@ export async function adbSyncPushV2({
                 id: AdbSyncRequestId.SendV2,
                 mode,
                 flags,
-            })
+            }),
         );
 
-        await pipeFile(locked, file, packetSize, mtime);
+        await pipeFileData(locked, file, packetSize, mtime);
     } finally {
         locked.release();
     }
 }
 
 export interface AdbSyncPushOptions extends AdbSyncPushV2Options {
+    /**
+     * Whether to use the v2 protocol. Requires the `sendrecv_v2` feature.
+     */
     v2: boolean;
 }
 

package/src/commands/sync/request.ts

@@ -20,7 +20,7 @@ export const AdbSyncNumberRequest = new Struct({ littleEndian: true })
     .uint32("arg");
 
 export const AdbSyncDataRequest = new Struct({ littleEndian: true })
-    .fields(AdbSyncNumberRequest)
+    .concat(AdbSyncNumberRequest)
     .uint8Array("data", { lengthField: "arg" });
 
 export interface AdbSyncWritable {
@@ -30,7 +30,7 @@ export interface AdbSyncWritable {
 export async function adbSyncWriteRequest(
     writable: AdbSyncWritable,
     id: AdbSyncRequestId | string,
-    value: number | string | Uint8Array
+    value: number | string | Uint8Array,
 ): Promise<void> {
     if (typeof value === "number") {
         const buffer = AdbSyncNumberRequest.serialize({
@@ -42,12 +42,12 @@ export async function adbSyncWriteRequest(
         // Let `writable` buffer writes
         const buffer = encodeUtf8(value);
         await writable.write(
-            AdbSyncNumberRequest.serialize({ id, arg: buffer.byteLength })
+            AdbSyncNumberRequest.serialize({ id, arg: buffer.byteLength }),
         );
         await writable.write(buffer);
     } else {
         await writable.write(
-            AdbSyncNumberRequest.serialize({ id, arg: value.byteLength })
+            AdbSyncNumberRequest.serialize({ id, arg: value.byteLength }),
         );
         await writable.write(value);
     }

package/src/commands/sync/response.ts

@@ -1,5 +1,5 @@
 import type {
-    StructAsyncDeserializeStream,
+    AsyncExactReadable,
     StructLike,
     StructValueType,
 } from "@yume-chan/struct";
@@ -19,19 +19,21 @@ export enum AdbSyncResponseId {
     Fail = "FAIL",
 }
 
+export class AdbSyncError extends Error {}
+
 export const AdbSyncFailResponse = new Struct({ littleEndian: true })
     .uint32("messageLength")
     .string("message", { lengthField: "messageLength" })
     .postDeserialize((object) => {
-        throw new Error(object.message);
+        throw new AdbSyncError(object.message);
     });
 
 export async function adbSyncReadResponse<T>(
-    stream: StructAsyncDeserializeStream,
+    stream: AsyncExactReadable,
     id: AdbSyncResponseId,
-    type: StructLike<T>
+    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);
@@ -44,14 +46,14 @@ export async function adbSyncReadResponse<T>(
 }
 
 export async function* adbSyncReadResponses<
-    T extends Struct<object, PropertyKey, object, any>
+    T extends Struct<object, PropertyKey, object, any>,
 >(
-    stream: StructAsyncDeserializeStream,
+    stream: AsyncExactReadable,
     id: AdbSyncResponseId,
-    type: T
+    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,14 +63,14 @@ 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);
                 break;
             default:
                 throw new Error(
-                    `Expected '${id}' or '${AdbSyncResponseId.Done}', but got '${actualId}'`
+                    `Expected '${id}' or '${AdbSyncResponseId.Done}', but got '${actualId}'`,
                 );
         }
     }