@yume-chan/adb 0.0.17 → 0.0.18

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

@@ -1,12 +1,23 @@
 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 {
+    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 { type Adb } from "../../../adb.js";
 import { AdbFeatures } from '../../../features.js';
-import type { AdbSocket } from '../../../socket/index.js';
+import { type AdbSocket } from "../../../socket/index.js";
 import { encodeUtf8 } from '../../../utils/index.js';
-import type { AdbSubprocessProtocol } from './types.js';
+
+import { type AdbSubprocessProtocol } from "./types.js";
 
 export enum AdbShellProtocolId {
     Stdin,
@@ -56,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;
         });
     }
@@ -77,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();
@@ -108,27 +121,39 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
 
     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;
@@ -141,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);
 

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

@@ -1,8 +1,11 @@
-import type { ReadableStream, WritableStream } from '@yume-chan/stream-extra';
-import type { ValueOrPromise } from '@yume-chan/struct';
+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';
+import { type Adb } from "../../../adb.js";
+import { type AdbSocket } from "../../../socket/index.js";
 
 export interface AdbSubprocessProtocol {
     /**
@@ -56,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/list.ts

@@ -1,52 +1,79 @@
-import type { BufferedReadableStream, WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
-import Struct from '@yume-chan/struct';
+import {
+    type BufferedReadableStream,
+    type WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
+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 {
+    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 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* adbSyncOpenDir(
     stream: BufferedReadableStream,
     writer: WritableStreamDefaultWriter<Uint8Array>,
     path: string,
-    v2: boolean,
+    v2: boolean
 ): AsyncGenerator<AdbSyncEntry, void, void> {
     if (v2) {
         await adbSyncWriteRequest(writer, AdbSyncRequestId.List2, path);
-        yield* adbSyncReadResponses(stream, AdbSyncResponseId.Entry2, AdbSyncEntry2Response);
+        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 {
         await adbSyncWriteRequest(writer, AdbSyncRequestId.List, path);
-        for await (const item of adbSyncReadResponses(stream, AdbSyncResponseId.Entry, AdbSyncEntryResponse)) {
+        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; },
+                get type() {
+                    return item.type;
+                },
+                get permission() {
+                    return item.permission;
+                },
                 name: item.name,
             };
         }

package/src/commands/sync/pull.ts

@@ -1,45 +1,62 @@
-import { BufferedReadableStream, ReadableStream, WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
-import Struct from '@yume-chan/struct';
+import {
+    ReadableStream,
+    type BufferedReadableStream,
+    type WritableStreamDefaultWriter,
+} 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";
 
-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 function adbSyncPull(
     stream: BufferedReadableStream,
     writer: WritableStreamDefaultWriter<Uint8Array>,
-    path: string,
+    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);
+    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.`);
+            },
         },
-        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; }
-    });
+        {
+            highWaterMark: 16 * 1024,
+            size(chunk) {
+                return chunk.byteLength;
+            },
+        }
+    );
 }

package/src/commands/sync/push.ts

@@ -1,13 +1,19 @@
-import { BufferedReadableStream, ChunkStream, pipeFrom, WritableStream, WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
-import Struct from '@yume-chan/struct';
+import {
+    ChunkStream,
+    WritableStream,
+    pipeFrom,
+    type BufferedReadableStream,
+    type WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
+import Struct from "@yume-chan/struct";
 
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
-import { adbSyncReadResponse, AdbSyncResponseId } from './response.js';
-import { LinuxFileType } from './stat.js';
+import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
+import { AdbSyncResponseId, adbSyncReadResponse } from "./response.js";
+import { LinuxFileType } from "./stat.js";
 
-export const AdbSyncOkResponse =
-    new Struct({ littleEndian: true })
-        .uint32('unused');
+export const AdbSyncOkResponse = new Struct({ littleEndian: true }).uint32(
+    "unused"
+);
 
 export const ADB_SYNC_MAX_PACKET_SIZE = 64 * 1024;
 
@@ -17,20 +23,28 @@ export function adbSyncPush(
     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, AdbSyncResponseId.Ok, AdbSyncOkResponse);
+                await adbSyncReadResponse(
+                    stream,
+                    AdbSyncResponseId.Ok,
+                    AdbSyncOkResponse
+                );
             },
         }),
         new ChunkStream(packetSize)

package/src/commands/sync/request.ts

@@ -1,29 +1,27 @@
-import type { WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
-import Struct from '@yume-chan/struct';
+import { type WritableStreamDefaultWriter } from "@yume-chan/stream-extra";
+import Struct from "@yume-chan/struct";
 
-import { encodeUtf8 } from '../../utils/index.js';
+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>,
@@ -31,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),

package/src/commands/sync/response.ts

@@ -1,38 +1,40 @@
-import type { BufferedReadableStream } from '@yume-chan/stream-extra';
-import Struct, { StructValueType, type StructLike } from '@yume-chan/struct';
+import { type BufferedReadableStream } from "@yume-chan/stream-extra";
+import Struct, {
+    type StructLike,
+    type StructValueType,
+} from "@yume-chan/struct";
 
-import { decodeUtf8 } from '../../utils/index.js';
+import { decodeUtf8 } from "../../utils/index.js";
 
 export enum AdbSyncResponseId {
-    Entry = 'DENT',
-    Entry2 = 'DNT2',
-    Lstat = 'STAT',
-    Stat = 'STA2',
-    Lstat2 = 'LST2',
-    Done = 'DONE',
-    Data = 'DATA',
-    Ok = 'OKAY',
-    Fail = 'FAIL',
+    Entry = "DENT",
+    Entry2 = "DNT2",
+    Lstat = "STAT",
+    Stat = "STA2",
+    Lstat2 = "LST2",
+    Done = "DONE",
+    Data = "DATA",
+    Ok = "OKAY",
+    Fail = "FAIL",
 }
 
-export const AdbSyncFailResponse =
-    new Struct({ littleEndian: true })
-        .uint32('messageLength')
-        .string('message', { lengthField: 'messageLength' })
-        .postDeserialize(object => {
-            throw new Error(object.message);
-        });
+export const AdbSyncFailResponse = new Struct({ littleEndian: true })
+    .uint32("messageLength")
+    .string("message", { lengthField: "messageLength" })
+    .postDeserialize((object) => {
+        throw new Error(object.message);
+    });
 
 export async function adbSyncReadResponse<T>(
     stream: BufferedReadableStream,
     id: AdbSyncResponseId,
-    type: StructLike<T>,
+    type: StructLike<T>
 ): Promise<T> {
     const actualId = decodeUtf8(await stream.read(4));
     switch (actualId) {
         case AdbSyncResponseId.Fail:
             await AdbSyncFailResponse.deserialize(stream);
-            throw new Error('Unreachable');
+            throw new Error("Unreachable");
         case id:
             return await type.deserialize(stream);
         default:
@@ -40,17 +42,19 @@ export async function adbSyncReadResponse<T>(
     }
 }
 
-export async function* adbSyncReadResponses<T extends Struct<any, any, any, any>>(
+export async function* adbSyncReadResponses<
+    T extends Struct<object, PropertyKey, object, any>
+>(
     stream: BufferedReadableStream,
     id: AdbSyncResponseId,
-    type: T,
+    type: T
 ): AsyncGenerator<StructValueType<T>, void, void> {
     while (true) {
         const actualId = decodeUtf8(await stream.read(4));
         switch (actualId) {
             case AdbSyncResponseId.Fail:
                 await AdbSyncFailResponse.deserialize(stream);
-                throw new Error('Unreachable');
+                throw new Error("Unreachable");
             case AdbSyncResponseId.Done:
                 // `DONE` responses' size are always same as the request's normal response.
                 //
@@ -62,7 +66,9 @@ export async function* adbSyncReadResponses<T extends Struct<any, any, any, any>
                 yield await type.deserialize(stream);
                 break;
             default:
-                throw new Error(`Expected '${id}' or '${AdbSyncResponseId.Done}', but got '${actualId}'`);
+                throw new Error(
+                    `Expected '${id}' or '${AdbSyncResponseId.Done}', but got '${actualId}'`
+                );
         }
     }
 }