@yume-chan/adb 0.0.17 → 0.0.19

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

@@ -1,12 +1,28 @@
-import { PromiseResolver } from '@yume-chan/async';
-import { pipeFrom, PushReadableStream, StructDeserializeStream, StructSerializeStream, TransformStream, WritableStream, 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';
+import { PromiseResolver } from "@yume-chan/async";
+import type {
+    Consumable,
+    PushReadableStreamController,
+    ReadableStream,
+    WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
+import {
+    ConsumableTransformStream,
+    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 { AdbFeature } 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,
@@ -18,33 +34,38 @@ 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>{
+class StdoutDeserializeStream extends TransformStream<
+    AdbShellProtocolPacket,
+    Uint8Array
+> {
     constructor(type: AdbShellProtocolId.Stdout | AdbShellProtocolId.Stderr) {
         super({
             transform(chunk, controller) {
@@ -56,15 +77,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;
         });
     }
@@ -77,13 +100,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();
@@ -103,32 +126,46 @@ 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) {
         // 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 _socketWriter: WritableStreamDefaultWriter<
+        Consumable<AdbShellProtocolPacketInit>
+    >;
 
-    private _stdin: WritableStream<Uint8Array>;
-    public get stdin() { return this._stdin; }
+    private _stdin: WritableStream<Consumable<Uint8Array>>;
+    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;
@@ -141,28 +178,45 @@ 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));
-
-        const multiplexer = new MultiplexStream<AdbShellProtocolPacketInit>();
-        multiplexer.readable
-            .pipeThrough(new StructSerializeStream(AdbShellProtocolPacket))
+        this._stdout = stdout.pipeThrough(
+            new StdoutDeserializeStream(AdbShellProtocolId.Stdout)
+        );
+        this._stderr = stderr.pipeThrough(
+            new StdoutDeserializeStream(AdbShellProtocolId.Stderr)
+        );
+
+        const multiplexer = new MultiplexStream<
+            Consumable<AdbShellProtocolPacketInit>
+        >();
+        void multiplexer.readable
+            .pipeThrough(
+                new ConsumableTransformStream({
+                    async transform(chunk, controller) {
+                        await controller.enqueue(
+                            AdbShellProtocolPacket.serialize(chunk)
+                        );
+                    },
+                })
+            )
             .pipeTo(socket.writable);
 
         this._stdin = pipeFrom(
@@ -174,7 +228,7 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
     }
 
     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}`

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

@@ -1,14 +1,18 @@
-import type { ReadableStream, WritableStream } from '@yume-chan/stream-extra';
-import type { ValueOrPromise } from '@yume-chan/struct';
+import type {
+    Consumable,
+    ReadableStream,
+    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';
+import type { Adb } from "../../../adb.js";
+import type { AdbSocket } from "../../../socket/index.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.
@@ -56,5 +60,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/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,52 +1,98 @@
-import type { BufferedReadableStream, WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
-import Struct from '@yume-chan/struct';
+import Struct from "@yume-chan/struct";
 
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
-import { adbSyncReadResponses, AdbSyncResponseId } from './response.js';
-import { AdbSyncLstatResponse, AdbSyncStatResponse, type AdbSyncStat } from './stat.js';
+import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
+import { AdbSyncResponseId, adbSyncReadResponses } from "./response.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)
-        .uint32('nameLength')
-        .string('name', { lengthField: 'nameLength' })
-        .extra({ id: AdbSyncResponseId.Entry as const });
+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 type AdbSyncEntryResponse =
+    (typeof AdbSyncEntryResponse)["TDeserializeResult"];
 
-export const AdbSyncEntry2Response =
-    new Struct({ littleEndian: true })
-        .fields(AdbSyncStatResponse)
-        .uint32('nameLength')
-        .string('name', { lengthField: 'nameLength' })
-        .extra({ id: AdbSyncResponseId.Entry2 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 AdbSyncEntry2Response = typeof AdbSyncEntry2Response['TDeserializeResult'];
+export type AdbSyncEntry2Response =
+    (typeof AdbSyncEntry2Response)["TDeserializeResult"];
+
+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(
+            locked,
+            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;
+        }
+    } 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(
+            locked,
+            AdbSyncResponseId.Entry,
+            AdbSyncEntryResponse
+        )) {
+            yield item;
+        }
+    } finally {
+        locked.release();
+    }
+}
 
 export async function* adbSyncOpenDir(
-    stream: BufferedReadableStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
+    socket: AdbSyncSocket,
     path: string,
-    v2: boolean,
+    v2: boolean
 ): AsyncGenerator<AdbSyncEntry, void, void> {
     if (v2) {
-        await adbSyncWriteRequest(writer, AdbSyncRequestId.List2, path);
-        yield* adbSyncReadResponses(stream, AdbSyncResponseId.Entry2, AdbSyncEntry2Response);
+        yield* adbSyncOpenDirV2(socket, path);
     } else {
-        await adbSyncWriteRequest(writer, AdbSyncRequestId.List, path);
-        for await (const item of adbSyncReadResponses(stream, AdbSyncResponseId.Entry, AdbSyncEntryResponse)) {
+        for await (const item of adbSyncOpenDirV1(socket, path)) {
             // 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; },
+                get type() {
+                    return item.type;
+                },
+                get permission() {
+                    return item.permission;
+                },
                 name: item.name,
             };
         }

package/src/commands/sync/pull.ts

@@ -1,45 +1,57 @@
-import { BufferedReadableStream, ReadableStream, WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
-import Struct from '@yume-chan/struct';
+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 { adbSyncReadResponses, AdbSyncResponseId } from './response.js';
+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')
-        .uint8Array('data', { lengthField: 'dataLength' })
-        .extra({ id: AdbSyncResponseId.Data as const });
+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 type AdbSyncDataResponse =
+    (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>,
-    path: string,
+    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() {
-            try {
-                generator.return();
-            } catch { }
-            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);
+        }
     });
 }