@yume-chan/adb 0.0.16 → 0.0.18

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

@@ -1,11 +1,23 @@
-import { PromiseResolver } from "@yume-chan/async";
-import Struct, { placeholder, type StructValueType } from "@yume-chan/struct";
-import type { Adb } from "../../../adb.js";
-import { AdbFeatures } from "../../../features.js";
-import type { AdbSocket } from "../../../socket/index.js";
-import { pipeFrom, PushReadableStream, ReadableStream, StructDeserializeStream, StructSerializeStream, TransformStream, WritableStream, WritableStreamDefaultWriter, type PushReadableStreamController } from "../../../stream/index.js";
-import { encodeUtf8 } from "../../../utils/index.js";
-import type { AdbSubprocessProtocol } from "./types.js";
+import { PromiseResolver } from '@yume-chan/async';
+import {
+    PushReadableStream,
+    StructDeserializeStream,
+    StructSerializeStream,
+    TransformStream,
+    WritableStream,
+    pipeFrom,
+    type PushReadableStreamController,
+    type ReadableStream,
+    type WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
+import Struct, { placeholder, type StructValueType } from '@yume-chan/struct';
+
+import { type Adb } from "../../../adb.js";
+import { AdbFeatures } from '../../../features.js';
+import { type AdbSocket } from "../../../socket/index.js";
+import { encodeUtf8 } from '../../../utils/index.js';
+
+import { type AdbSubprocessProtocol } from "./types.js";
 
 export enum AdbShellProtocolId {
     Stdin,
@@ -55,15 +67,17 @@ class StdoutDeserializeStream extends TransformStream<AdbShellProtocolPacket, Ui
     }
 }
 
-class MultiplexStream<T>{
+class MultiplexStream<T> {
     private _readable: PushReadableStream<T>;
     private _readableController!: PushReadableStreamController<T>;
-    public get readable() { return this._readable; }
+    public get readable() {
+        return this._readable;
+    }
 
     private _activeCount = 0;
 
     constructor() {
-        this._readable = new PushReadableStream(controller => {
+        this._readable = new PushReadableStream((controller) => {
             this._readableController = controller;
         });
     }
@@ -76,13 +90,13 @@ class MultiplexStream<T>{
             write: async (chunk) => {
                 await this._readableController.enqueue(chunk);
             },
-            abort: async (e) => {
+            abort: () => {
                 this._activeCount -= 1;
                 if (this._activeCount === 0) {
                     this._readableController.close();
                 }
             },
-            close: async () => {
+            close: () => {
                 this._activeCount -= 1;
                 if (this._activeCount === 0) {
                     this._readableController.close();
@@ -102,32 +116,44 @@ class MultiplexStream<T>{
  */
 export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
     public static isSupported(adb: Adb) {
-        return adb.features!.includes(AdbFeatures.ShellV2);
+        return adb.features.includes(AdbFeatures.ShellV2);
     }
 
     public static async pty(adb: Adb, command: string) {
         // TODO: AdbShellSubprocessProtocol: Support setting `XTERM` environment variable
-        return new AdbSubprocessShellProtocol(await adb.createSocket(`shell,v2,pty:${command}`));
+        return new AdbSubprocessShellProtocol(
+            await adb.createSocket(`shell,v2,pty:${command}`)
+        );
     }
 
     public static async raw(adb: Adb, command: string) {
-        return new AdbSubprocessShellProtocol(await adb.createSocket(`shell,v2,raw:${command}`));
+        return new AdbSubprocessShellProtocol(
+            await adb.createSocket(`shell,v2,raw:${command}`)
+        );
     }
 
     private readonly _socket: AdbSocket;
     private _socketWriter: WritableStreamDefaultWriter<AdbShellProtocolPacketInit>;
 
     private _stdin: WritableStream<Uint8Array>;
-    public get stdin() { return this._stdin; }
+    public get stdin() {
+        return this._stdin;
+    }
 
     private _stdout: ReadableStream<Uint8Array>;
-    public get stdout() { return this._stdout; }
+    public get stdout() {
+        return this._stdout;
+    }
 
     private _stderr: ReadableStream<Uint8Array>;
-    public get stderr() { return this._stderr; }
+    public get stderr() {
+        return this._stderr;
+    }
 
     private readonly _exit = new PromiseResolver<number>();
-    public get exit() { return this._exit.promise; }
+    public get exit() {
+        return this._exit.promise;
+    }
 
     public constructor(socket: AdbSocket) {
         this._socket = socket;
@@ -140,27 +166,34 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
 
         const [stdout, stderr] = 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;
-                    }
-                    controller.enqueue(chunk);
-                }
-            }))
+            .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;
+                        }
+                        controller.enqueue(chunk);
+                    },
+                })
+            )
             .tee();
-        this._stdout = stdout
-            .pipeThrough(new StdoutDeserializeStream(AdbShellProtocolId.Stdout));
-        this._stderr = stderr
-            .pipeThrough(new StdoutDeserializeStream(AdbShellProtocolId.Stderr));
+        this._stdout = stdout.pipeThrough(
+            new StdoutDeserializeStream(AdbShellProtocolId.Stdout)
+        );
+        this._stderr = stderr.pipeThrough(
+            new StdoutDeserializeStream(AdbShellProtocolId.Stderr)
+        );
 
         const multiplexer = new MultiplexStream<AdbShellProtocolPacketInit>();
-        multiplexer.readable
+        void multiplexer.readable
             .pipeThrough(new StructSerializeStream(AdbShellProtocolPacket))
             .pipeTo(socket.writable);
 
@@ -178,7 +211,7 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
             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 not used, so always passing `0` is fine.
+                // `x_pixels` and `y_pixels` are unused, so always sending `0` should be fine.
                 `${rows}x${cols},0x0\0`
             ),
         });

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

@@ -1,21 +1,25 @@
-import type { ValueOrPromise } from "@yume-chan/struct";
-import type { Adb } from "../../../adb.js";
-import type { AdbSocket } from "../../../socket/index.js";
-import type { ReadableStream, WritableStream } from "../../../stream/index.js";
+import {
+    type ReadableStream,
+    type WritableStream,
+} 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";
 
 export interface AdbSubprocessProtocol {
     /**
-     * A WritableStream that writes to the `stdin` pipe.
+     * A WritableStream that writes to the `stdin` stream.
      */
     readonly stdin: WritableStream<Uint8Array>;
 
     /**
-     * The `stdout` pipe of the process.
+     * The `stdout` stream of the process.
      */
     readonly stdout: ReadableStream<Uint8Array>;
 
     /**
-     * The `stderr` pipe of the process.
+     * The `stderr` stream of the process.
      *
      * Note: Some `AdbSubprocessProtocol` doesn't separate `stdout` and `stderr`,
      * All output will be sent to `stdout`.
@@ -55,5 +59,5 @@ export interface AdbSubprocessProtocolConstructor {
     raw(adb: Adb, command: string): ValueOrPromise<AdbSubprocessProtocol>;
 
     /** Creates a new `AdbShell` by attaching to an exist `AdbSocket` */
-    new(socket: AdbSocket): AdbSubprocessProtocol;
+    new (socket: AdbSocket): AdbSubprocessProtocol;
 }

package/src/commands/sync/index.ts

@@ -1,7 +1,7 @@
 export * from './list.js';
 export * from './pull.js';
+export * from './push.js';
 export * from './request.js';
 export * from './response.js';
-export * from './push.js';
 export * from './stat.js';
 export * from './sync.js';

package/src/commands/sync/list.ts

@@ -1,86 +1,81 @@
-import Struct from '@yume-chan/struct';
-import type { AdbBufferedStream, WritableStreamDefaultWriter } from '../../stream/index.js';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
-import { AdbSyncDoneResponse, adbSyncReadResponse, AdbSyncResponseId } from './response.js';
-import { AdbSyncLstatResponse, AdbSyncStatResponse, type AdbSyncStat } from './stat.js';
+import {
+    type BufferedReadableStream,
+    type WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
+import Struct from "@yume-chan/struct";
+
+import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
+import { AdbSyncResponseId, adbSyncReadResponses } from "./response.js";
+import {
+    AdbSyncLstatResponse,
+    AdbSyncStatResponse,
+    type AdbSyncStat,
+} from "./stat.js";
 
 export interface AdbSyncEntry extends AdbSyncStat {
     name: string;
 }
 
-export const AdbSyncEntryResponse =
-    new Struct({ littleEndian: true })
-        .fields(AdbSyncLstatResponse)
-        .uint32('nameLength')
-        .string('name', { lengthField: 'nameLength' })
-        .extra({ id: AdbSyncResponseId.Entry as const });
-
-export type AdbSyncEntryResponse = typeof AdbSyncEntryResponse['TDeserializeResult'];
+export const AdbSyncEntryResponse = new Struct({ littleEndian: true })
+    .fields(AdbSyncLstatResponse)
+    .uint32("nameLength")
+    .string("name", { lengthField: "nameLength" })
+    .extra({ id: AdbSyncResponseId.Entry as const });
 
-export const AdbSyncEntry2Response =
-    new Struct({ littleEndian: true })
-        .fields(AdbSyncStatResponse)
-        .uint32('nameLength')
-        .string('name', { lengthField: 'nameLength' })
-        .extra({ id: AdbSyncResponseId.Entry2 as const });
+export type AdbSyncEntryResponse =
+    typeof AdbSyncEntryResponse["TDeserializeResult"];
 
-export type AdbSyncEntry2Response = typeof AdbSyncEntry2Response['TDeserializeResult'];
+export const AdbSyncEntry2Response = new Struct({ littleEndian: true })
+    .fields(AdbSyncStatResponse)
+    .uint32("nameLength")
+    .string("name", { lengthField: "nameLength" })
+    .extra({ id: AdbSyncResponseId.Entry2 as const });
 
-const LIST_V1_RESPONSE_TYPES = {
-    [AdbSyncResponseId.Entry]: AdbSyncEntryResponse,
-    [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncEntryResponse.size),
-};
-
-const LIST_V2_RESPONSE_TYPES = {
-    [AdbSyncResponseId.Entry2]: AdbSyncEntry2Response,
-    [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncEntry2Response.size),
-};
+export type AdbSyncEntry2Response =
+    typeof AdbSyncEntry2Response["TDeserializeResult"];
 
 export async function* adbSyncOpenDir(
-    stream: AdbBufferedStream,
+    stream: BufferedReadableStream,
     writer: WritableStreamDefaultWriter<Uint8Array>,
     path: string,
-    v2: boolean,
+    v2: boolean
 ): AsyncGenerator<AdbSyncEntry, void, void> {
-    let requestId: AdbSyncRequestId.List | AdbSyncRequestId.List2;
-    let responseType: typeof LIST_V1_RESPONSE_TYPES | typeof LIST_V2_RESPONSE_TYPES;
-
     if (v2) {
-        requestId = AdbSyncRequestId.List2;
-        responseType = LIST_V2_RESPONSE_TYPES;
+        await adbSyncWriteRequest(writer, AdbSyncRequestId.List2, path);
+        for await (const item of adbSyncReadResponses(
+            stream,
+            AdbSyncResponseId.Entry2,
+            AdbSyncEntry2Response
+        )) {
+            // `LST2` can return error codes for failed `lstat` calls.
+            // `LIST` just ignores them.
+            // But they only contain `name` so still pretty useless.
+            if (item.error !== 0) {
+                continue;
+            }
+            yield item;
+        }
     } else {
-        requestId = AdbSyncRequestId.List;
-        responseType = LIST_V1_RESPONSE_TYPES;
-    }
-
-    await adbSyncWriteRequest(writer, requestId, path);
-
-    while (true) {
-        const response = await adbSyncReadResponse(stream, responseType);
-        switch (response.id) {
-            case AdbSyncResponseId.Entry:
-                yield {
-                    mode: response.mode,
-                    size: BigInt(response.size),
-                    mtime: BigInt(response.mtime),
-                    get type() { return response.type; },
-                    get permission() { return response.permission; },
-                    name: response.name,
-                };
-                break;
-            case AdbSyncResponseId.Entry2:
-                // `LST2` can return error codes for failed `lstat` calls.
-                // `LIST` just ignores them.
-                // But they only contain `name` so still pretty useless.
-                if (response.error !== 0) {
-                    continue;
-                }
-                yield response;
-                break;
-            case AdbSyncResponseId.Done:
-                return;
-            default:
-                throw new Error('Unexpected response id');
+        await adbSyncWriteRequest(writer, AdbSyncRequestId.List, path);
+        for await (const item of adbSyncReadResponses(
+            stream,
+            AdbSyncResponseId.Entry,
+            AdbSyncEntryResponse
+        )) {
+            // Convert to same format as `AdbSyncEntry2Response` for easier consumption.
+            // However it will add some overhead.
+            yield {
+                mode: item.mode,
+                size: BigInt(item.size),
+                mtime: BigInt(item.mtime),
+                get type() {
+                    return item.type;
+                },
+                get permission() {
+                    return item.permission;
+                },
+                name: item.name,
+            };
         }
     }
 }

package/src/commands/sync/pull.ts

@@ -1,46 +1,62 @@
-import Struct from '@yume-chan/struct';
-import { AdbBufferedStream, ReadableStream, WritableStreamDefaultWriter } from '../../stream/index.js';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
-import { AdbSyncDoneResponse, adbSyncReadResponse, AdbSyncResponseId } from './response.js';
+import {
+    ReadableStream,
+    type BufferedReadableStream,
+    type WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
+import Struct from "@yume-chan/struct";
 
-export const AdbSyncDataResponse =
-    new Struct({ littleEndian: true })
-        .uint32('dataLength')
-        .uint8Array('data', { lengthField: 'dataLength' })
-        .extra({ id: AdbSyncResponseId.Data as const });
+import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
+import { AdbSyncResponseId, adbSyncReadResponses } from "./response.js";
 
-const RESPONSE_TYPES = {
-    [AdbSyncResponseId.Data]: AdbSyncDataResponse,
-    [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncDataResponse.size),
-};
+export const AdbSyncDataResponse = new Struct({ littleEndian: true })
+    .uint32("dataLength")
+    .uint8Array("data", { lengthField: "dataLength" })
+    .extra({ id: AdbSyncResponseId.Data as const });
+
+export type AdbSyncDataResponse =
+    typeof AdbSyncDataResponse["TDeserializeResult"];
 
 export function adbSyncPull(
-    stream: AdbBufferedStream,
+    stream: BufferedReadableStream,
     writer: WritableStreamDefaultWriter<Uint8Array>,
-    path: string,
+    path: string
 ): ReadableStream<Uint8Array> {
-    return new ReadableStream<Uint8Array>({
-        async start() {
-            await adbSyncWriteRequest(writer, AdbSyncRequestId.Receive, path);
-        },
-        async pull(controller) {
-            const response = await adbSyncReadResponse(stream, RESPONSE_TYPES);
-            switch (response.id) {
-                case AdbSyncResponseId.Data:
-                    controller.enqueue(response.data!);
-                    break;
-                case AdbSyncResponseId.Done:
+    let generator!: AsyncGenerator<AdbSyncDataResponse, void, void>;
+    return new ReadableStream<Uint8Array>(
+        {
+            async start() {
+                // TODO: If `ReadableStream.from(AsyncGenerator)` is added to spec, use it instead.
+                await adbSyncWriteRequest(
+                    writer,
+                    AdbSyncRequestId.Receive,
+                    path
+                );
+                generator = adbSyncReadResponses(
+                    stream,
+                    AdbSyncResponseId.Data,
+                    AdbSyncDataResponse
+                );
+            },
+            async pull(controller) {
+                const { done, value } = await generator.next();
+                if (done) {
                     controller.close();
-                    break;
-                default:
-                    throw new Error('Unexpected response id');
-            }
-        },
-        cancel() {
-            throw new Error(`Sync commands don't support cancel.`);
+                    return;
+                }
+                controller.enqueue(value.data);
+            },
+            cancel() {
+                generator.return().catch((e) => {
+                    void e;
+                });
+                throw new Error(`Sync commands can't be canceled.`);
+            },
         },
-    }, {
-        highWaterMark: 16 * 1024,
-        size(chunk) { return chunk.byteLength; }
-    });
+        {
+            highWaterMark: 16 * 1024,
+            size(chunk) {
+                return chunk.byteLength;
+            },
+        }
+    );
 }

package/src/commands/sync/push.ts

@@ -1,39 +1,50 @@
-import Struct from '@yume-chan/struct';
-import { AdbBufferedStream, ChunkStream, pipeFrom, WritableStream, WritableStreamDefaultWriter } from '../../stream/index.js';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
-import { adbSyncReadResponse, AdbSyncResponseId } from './response.js';
-import { LinuxFileType } from './stat.js';
+import {
+    ChunkStream,
+    WritableStream,
+    pipeFrom,
+    type BufferedReadableStream,
+    type WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
+import Struct from "@yume-chan/struct";
 
-export const AdbSyncOkResponse =
-    new Struct({ littleEndian: true })
-        .uint32('unused');
+import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
+import { AdbSyncResponseId, adbSyncReadResponse } from "./response.js";
+import { LinuxFileType } from "./stat.js";
 
-const ResponseTypes = {
-    [AdbSyncResponseId.Ok]: AdbSyncOkResponse,
-};
+export const AdbSyncOkResponse = new Struct({ littleEndian: true }).uint32(
+    "unused"
+);
 
 export const ADB_SYNC_MAX_PACKET_SIZE = 64 * 1024;
 
 export function adbSyncPush(
-    stream: AdbBufferedStream,
+    stream: BufferedReadableStream,
     writer: WritableStreamDefaultWriter<Uint8Array>,
     filename: string,
     mode: number = (LinuxFileType.File << 12) | 0o666,
     mtime: number = (Date.now() / 1000) | 0,
-    packetSize: number = ADB_SYNC_MAX_PACKET_SIZE,
+    packetSize: number = ADB_SYNC_MAX_PACKET_SIZE
 ): WritableStream<Uint8Array> {
     return pipeFrom(
         new WritableStream<Uint8Array>({
             async start() {
                 const pathAndMode = `${filename},${mode.toString()}`;
-                await adbSyncWriteRequest(writer, AdbSyncRequestId.Send, pathAndMode);
+                await adbSyncWriteRequest(
+                    writer,
+                    AdbSyncRequestId.Send,
+                    pathAndMode
+                );
             },
             async write(chunk) {
                 await adbSyncWriteRequest(writer, AdbSyncRequestId.Data, chunk);
             },
             async close() {
                 await adbSyncWriteRequest(writer, AdbSyncRequestId.Done, mtime);
-                await adbSyncReadResponse(stream, ResponseTypes);
+                await adbSyncReadResponse(
+                    stream,
+                    AdbSyncResponseId.Ok,
+                    AdbSyncOkResponse
+                );
             },
         }),
         new ChunkStream(packetSize)

package/src/commands/sync/request.ts

@@ -1,28 +1,27 @@
-import Struct from '@yume-chan/struct';
-import type { WritableStreamDefaultWriter } from "../../stream/index.js";
+import { type WritableStreamDefaultWriter } from "@yume-chan/stream-extra";
+import Struct from "@yume-chan/struct";
+
 import { encodeUtf8 } from "../../utils/index.js";
 
 export enum AdbSyncRequestId {
-    List = 'LIST',
-    List2 = 'LIS2',
-    Send = 'SEND',
-    Lstat = 'STAT',
-    Stat = 'STA2',
-    Lstat2 = 'LST2',
-    Data = 'DATA',
-    Done = 'DONE',
-    Receive = 'RECV',
+    List = "LIST",
+    List2 = "LIS2",
+    Send = "SEND",
+    Lstat = "STAT",
+    Stat = "STA2",
+    Lstat2 = "LST2",
+    Data = "DATA",
+    Done = "DONE",
+    Receive = "RECV",
 }
 
-export const AdbSyncNumberRequest =
-    new Struct({ littleEndian: true })
-        .string('id', { length: 4 })
-        .uint32('arg');
+export const AdbSyncNumberRequest = new Struct({ littleEndian: true })
+    .string("id", { length: 4 })
+    .uint32("arg");
 
-export const AdbSyncDataRequest =
-    new Struct({ littleEndian: true })
-        .fields(AdbSyncNumberRequest)
-        .uint8Array('data', { lengthField: 'arg' });
+export const AdbSyncDataRequest = new Struct({ littleEndian: true })
+    .fields(AdbSyncNumberRequest)
+    .uint8Array("data", { lengthField: "arg" });
 
 export async function adbSyncWriteRequest(
     writer: WritableStreamDefaultWriter<Uint8Array>,
@@ -30,12 +29,12 @@ export async function adbSyncWriteRequest(
     value: number | string | Uint8Array
 ): Promise<void> {
     let buffer: Uint8Array;
-    if (typeof value === 'number') {
+    if (typeof value === "number") {
         buffer = AdbSyncNumberRequest.serialize({
             id,
             arg: value,
         });
-    } else if (typeof value === 'string') {
+    } else if (typeof value === "string") {
         buffer = AdbSyncDataRequest.serialize({
             id,
             data: encodeUtf8(value),