@yume-chan/adb 0.0.18 → 0.0.20

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

@@ -1,23 +1,26 @@
-import { PromiseResolver } from '@yume-chan/async';
+import { PromiseResolver } from "@yume-chan/async";
+import type {
+    Consumable,
+    PushReadableStreamController,
+    ReadableStream,
+    WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
 import {
+    ConsumableTransformStream,
+    ConsumableWritableStream,
     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 { StructValueType } from "@yume-chan/struct";
+import Struct, { placeholder } 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 { Adb, AdbSocket } from "../../../adb.js";
+import { AdbFeature } from "../../../features.js";
+import { encodeUtf8 } from "../../../utils/index.js";
 
-import { type AdbSubprocessProtocol } from "./types.js";
+import type { AdbSubprocessProtocol } from "./types.js";
 
 export enum AdbShellProtocolId {
     Stdin,
@@ -29,39 +32,29 @@ export enum AdbShellProtocolId {
 }
 
 // This packet format is used in both direction.
-const AdbShellProtocolPacket =
-    new Struct({ littleEndian: true })
-        .uint8('id', placeholder<AdbShellProtocolId>())
-        .uint32('length')
-        .uint8Array('data', { lengthField: 'length' });
+const AdbShellProtocolPacket = new Struct({ littleEndian: true })
+    .uint8("id", placeholder<AdbShellProtocolId>())
+    .uint32("length")
+    .uint8Array("data", { lengthField: "length" });
 
-type AdbShellProtocolPacketInit = typeof AdbShellProtocolPacket['TInit'];
+type AdbShellProtocolPacketInit = (typeof AdbShellProtocolPacket)["TInit"];
 
 type AdbShellProtocolPacket = StructValueType<typeof AdbShellProtocolPacket>;
 
-class StdinSerializeStream extends TransformStream<Uint8Array, AdbShellProtocolPacketInit>{
+class StdinSerializeStream extends ConsumableTransformStream<
+    Uint8Array,
+    AdbShellProtocolPacketInit
+> {
     constructor() {
         super({
-            transform(chunk, controller) {
-                controller.enqueue({
+            async transform(chunk, controller) {
+                await controller.enqueue({
                     id: AdbShellProtocolId.Stdin,
                     data: chunk,
                 });
             },
             flush() {
                 // TODO: AdbShellSubprocessProtocol: support closing stdin
-            }
-        });
-    }
-}
-
-class StdoutDeserializeStream extends TransformStream<AdbShellProtocolPacket, Uint8Array>{
-    constructor(type: AdbShellProtocolId.Stdout | AdbShellProtocolId.Stderr) {
-        super({
-            transform(chunk, controller) {
-                if (chunk.id === type) {
-                    controller.enqueue(chunk.data);
-                }
             },
         });
     }
@@ -116,7 +109,7 @@ class MultiplexStream<T> {
  */
 export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
     public static isSupported(adb: Adb) {
-        return adb.features.includes(AdbFeatures.ShellV2);
+        return adb.supportsFeature(AdbFeature.ShellV2);
     }
 
     public static async pty(adb: Adb, command: string) {
@@ -132,81 +125,108 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
         );
     }
 
-    private readonly _socket: AdbSocket;
-    private _socketWriter: WritableStreamDefaultWriter<AdbShellProtocolPacketInit>;
+    readonly #socket: AdbSocket;
+    #socketWriter: WritableStreamDefaultWriter<
+        Consumable<AdbShellProtocolPacketInit>
+    >;
 
-    private _stdin: WritableStream<Uint8Array>;
+    #stdin: WritableStream<Consumable<Uint8Array>>;
     public get stdin() {
-        return this._stdin;
+        return this.#stdin;
     }
 
-    private _stdout: ReadableStream<Uint8Array>;
+    #stdout: ReadableStream<Uint8Array>;
     public get stdout() {
-        return this._stdout;
+        return this.#stdout;
     }
 
-    private _stderr: ReadableStream<Uint8Array>;
+    #stderr: ReadableStream<Uint8Array>;
     public get stderr() {
-        return this._stderr;
+        return this.#stderr;
     }
 
-    private readonly _exit = new PromiseResolver<number>();
+    readonly #exit = new PromiseResolver<number>();
     public get exit() {
-        return this._exit.promise;
+        return this.#exit.promise;
     }
 
     public constructor(socket: AdbSocket) {
-        this._socket = socket;
+        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<AdbShellProtocolPacketInit>();
+        const multiplexer = new MultiplexStream<
+            Consumable<AdbShellProtocolPacketInit>
+        >();
         void multiplexer.readable
-            .pipeThrough(new StructSerializeStream(AdbShellProtocolPacket))
+            .pipeThrough(
+                new ConsumableTransformStream({
+                    async transform(chunk, controller) {
+                        await controller.enqueue(
+                            AdbShellProtocolPacket.serialize(chunk)
+                        );
+                    },
+                })
+            )
             .pipeTo(socket.writable);
 
-        this._stdin = pipeFrom(
+        this.#stdin = pipeFrom(
             multiplexer.createWriteable(),
             new StdinSerializeStream()
         );
 
-        this._socketWriter = multiplexer.createWriteable().getWriter();
+        this.#socketWriter = multiplexer.createWriteable().getWriter();
     }
 
     public async resize(rows: number, cols: number) {
-        await this._socketWriter.write({
+        await ConsumableWritableStream.write(this.#socketWriter, {
             id: AdbShellProtocolId.WindowSizeChange,
             data: encodeUtf8(
                 // The "correct" format is `${rows}x${cols},${x_pixels}x${y_pixels}`
@@ -218,6 +238,6 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
     }
 
     public kill() {
-        return this._socket.close();
+        return this.#socket.close();
     }
 }

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

@@ -1,17 +1,17 @@
-import {
-    type ReadableStream,
-    type WritableStream,
+import type {
+    Consumable,
+    ReadableStream,
+    WritableStream,
 } from "@yume-chan/stream-extra";
-import { type ValueOrPromise } from "@yume-chan/struct";
+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 {
     /**
      * A WritableStream that writes to the `stdin` stream.
      */
-    readonly stdin: WritableStream<Uint8Array>;
+    readonly stdin: WritableStream<Consumable<Uint8Array>>;
 
     /**
      * The `stdout` stream of the process.

package/src/commands/subprocess/utils.ts

@@ -1,5 +1,5 @@
 export function escapeArg(s: string) {
-    let result = '';
+    let result = "";
     result += `'`;
 
     let base = 0;

package/src/commands/sync/index.ts

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

package/src/commands/sync/list.ts

@@ -1,49 +1,42 @@
-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";
+import type { AdbSyncSocket } from "./socket.js";
+import type { AdbSyncStat } from "./stat.js";
+import { AdbSyncLstatResponse, AdbSyncStatResponse } from "./stat.js";
 
 export interface AdbSyncEntry extends AdbSyncStat {
     name: string;
 }
 
 export const AdbSyncEntryResponse = new Struct({ littleEndian: true })
-    .fields(AdbSyncLstatResponse)
+    .concat(AdbSyncLstatResponse)
     .uint32("nameLength")
     .string("name", { lengthField: "nameLength" })
     .extra({ id: AdbSyncResponseId.Entry as const });
 
 export type AdbSyncEntryResponse =
-    typeof AdbSyncEntryResponse["TDeserializeResult"];
+    (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 });
 
 export type AdbSyncEntry2Response =
-    typeof AdbSyncEntry2Response["TDeserializeResult"];
+    (typeof AdbSyncEntry2Response)["TDeserializeResult"];
 
-export async function* adbSyncOpenDir(
-    stream: BufferedReadableStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
-    path: string,
-    v2: boolean
-): AsyncGenerator<AdbSyncEntry, void, void> {
-    if (v2) {
-        await adbSyncWriteRequest(writer, AdbSyncRequestId.List2, path);
+export async function* adbSyncOpenDirV2(
+    socket: AdbSyncSocket,
+    path: string
+): AsyncGenerator<AdbSyncEntry2Response, void, void> {
+    const locked = await socket.lock();
+    try {
+        await adbSyncWriteRequest(locked, AdbSyncRequestId.ListV2, path);
         for await (const item of adbSyncReadResponses(
-            stream,
+            locked,
             AdbSyncResponseId.Entry2,
             AdbSyncEntry2Response
         )) {
@@ -55,13 +48,39 @@ export async function* adbSyncOpenDir(
             }
             yield item;
         }
-    } else {
-        await adbSyncWriteRequest(writer, AdbSyncRequestId.List, path);
+    } finally {
+        locked.release();
+    }
+}
+
+export async function* adbSyncOpenDirV1(
+    socket: AdbSyncSocket,
+    path: string
+): AsyncGenerator<AdbSyncEntryResponse, void, void> {
+    const locked = await socket.lock();
+    try {
+        await adbSyncWriteRequest(locked, AdbSyncRequestId.List, path);
         for await (const item of adbSyncReadResponses(
-            stream,
+            locked,
             AdbSyncResponseId.Entry,
             AdbSyncEntryResponse
         )) {
+            yield item;
+        }
+    } finally {
+        locked.release();
+    }
+}
+
+export async function* adbSyncOpenDir(
+    socket: AdbSyncSocket,
+    path: string,
+    v2: boolean
+): AsyncGenerator<AdbSyncEntry, void, void> {
+    if (v2) {
+        yield* adbSyncOpenDirV2(socket, path);
+    } else {
+        for await (const item of adbSyncOpenDirV1(socket, path)) {
             // Convert to same format as `AdbSyncEntry2Response` for easier consumption.
             // However it will add some overhead.
             yield {

package/src/commands/sync/pull.ts

@@ -1,12 +1,10 @@
-import {
-    ReadableStream,
-    type BufferedReadableStream,
-    type WritableStreamDefaultWriter,
-} from "@yume-chan/stream-extra";
+import type { ReadableStream } from "@yume-chan/stream-extra";
+import { PushReadableStream } from "@yume-chan/stream-extra";
 import Struct from "@yume-chan/struct";
 
 import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
 import { AdbSyncResponseId, adbSyncReadResponses } from "./response.js";
+import type { AdbSyncSocket } from "./socket.js";
 
 export const AdbSyncDataResponse = new Struct({ littleEndian: true })
     .uint32("dataLength")
@@ -14,49 +12,46 @@ export const AdbSyncDataResponse = new Struct({ littleEndian: true })
     .extra({ id: AdbSyncResponseId.Data as const });
 
 export type AdbSyncDataResponse =
-    typeof AdbSyncDataResponse["TDeserializeResult"];
+    (typeof AdbSyncDataResponse)["TDeserializeResult"];
+
+export async function* adbSyncPullGenerator(
+    socket: AdbSyncSocket,
+    path: string
+): AsyncGenerator<Uint8Array, void, void> {
+    const locked = await socket.lock();
+    let done = false;
+    try {
+        await adbSyncWriteRequest(locked, AdbSyncRequestId.Receive, path);
+        for await (const packet of adbSyncReadResponses(
+            locked,
+            AdbSyncResponseId.Data,
+            AdbSyncDataResponse
+        )) {
+            yield packet.data;
+        }
+        done = true;
+    } finally {
+        if (!done) {
+            // sync pull can't be cancelled, so we have to read all data
+            for await (const packet of adbSyncReadResponses(
+                locked,
+                AdbSyncResponseId.Data,
+                AdbSyncDataResponse
+            )) {
+                void packet;
+            }
+        }
+        locked.release();
+    }
+}
 
 export function adbSyncPull(
-    stream: BufferedReadableStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
+    socket: AdbSyncSocket,
     path: string
 ): ReadableStream<Uint8Array> {
-    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();
-                    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;
-            },
+    return new PushReadableStream(async (controller) => {
+        for await (const data of adbSyncPullGenerator(socket, path)) {
+            await controller.enqueue(data);
         }
-    );
+    });
 }