@yume-chan/adb 0.0.20 → 0.0.22

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

@@ -61,38 +61,38 @@ class StdinSerializeStream extends ConsumableTransformStream<
 }
 
 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();
                 }
             },
         });
@@ -108,20 +108,20 @@ 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}`),
         );
     }
 
@@ -131,26 +131,26 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
     >;
 
     #stdin: WritableStream<Consumable<Uint8Array>>;
-    public get stdin() {
+    get stdin() {
         return this.#stdin;
     }
 
     #stdout: ReadableStream<Uint8Array>;
-    public get stdout() {
+    get stdout() {
         return this.#stdout;
     }
 
     #stderr: ReadableStream<Uint8Array>;
-    public get stderr() {
+    get stderr() {
         return this.#stderr;
     }
 
     readonly #exit = new PromiseResolver<number>();
-    public get exit() {
+    get exit() {
         return this.#exit.promise;
     }
 
-    public constructor(socket: AdbSocket) {
+    constructor(socket: AdbSocket) {
         this.#socket = socket;
 
         // Check this image to help you understand the stream graph
@@ -159,6 +159,7 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
 
         let stdoutController!: PushReadableStreamController<Uint8Array>;
         let stderrController!: PushReadableStreamController<Uint8Array>;
+
         this.#stdout = new PushReadableStream<Uint8Array>((controller) => {
             stdoutController = controller;
         });
@@ -176,14 +177,18 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
                                 this.#exit.resolve(chunk.data[0]!);
                                 break;
                             case AdbShellProtocolId.Stdout:
-                                await stdoutController.enqueue(chunk.data);
+                                if (!stdoutController.abortSignal.aborted) {
+                                    await stdoutController.enqueue(chunk.data);
+                                }
                                 break;
                             case AdbShellProtocolId.Stderr:
-                                await stderrController.enqueue(chunk.data);
+                                if (!stderrController.abortSignal.aborted) {
+                                    await stderrController.enqueue(chunk.data);
+                                }
                                 break;
                         }
                     },
-                })
+                }),
             )
             .then(
                 () => {
@@ -191,7 +196,7 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
                     stderrController.close();
                     // If `#exit` has already resolved, this will be a no-op
                     this.#exit.reject(
-                        new Error("Socket ended without exit message")
+                        new Error("Socket ended without exit message"),
                     );
                 },
                 (e) => {
@@ -199,7 +204,7 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
                     stderrController.error(e);
                     // If `#exit` has already resolved, this will be a no-op
                     this.#exit.reject(e);
-                }
+                },
             );
 
         const multiplexer = new MultiplexStream<
@@ -210,34 +215,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(
             multiplexer.createWriteable(),
-            new StdinSerializeStream()
+            new StdinSerializeStream(),
         );
 
         this.#socketWriter = multiplexer.createWriteable().getWriter();
     }
 
-    public async resize(rows: number, cols: number) {
+    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() {
+    kill() {
         return this.#socket.close();
     }
 }

package/src/commands/sync/list.ts

@@ -4,7 +4,11 @@ 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";
+import {
+    AdbSyncLstatResponse,
+    AdbSyncStatErrorCode,
+    AdbSyncStatResponse,
+} from "./stat.js";
 
 export interface AdbSyncEntry extends AdbSyncStat {
     name: string;
@@ -30,7 +34,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,12 +42,12 @@ 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.
             // But they only contain `name` so still pretty useless.
-            if (item.error !== 0) {
+            if (item.error !== AdbSyncStatErrorCode.SUCCESS) {
                 continue;
             }
             yield item;
@@ -55,7 +59,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 +67,7 @@ export async function* adbSyncOpenDirV1(
         for await (const item of adbSyncReadResponses(
             locked,
             AdbSyncResponseId.Entry,
-            AdbSyncEntryResponse
+            AdbSyncEntryResponse,
         )) {
             yield item;
         }
@@ -75,7 +79,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,18 +25,21 @@ export async function* adbSyncPullGenerator(
         for await (const packet of adbSyncReadResponses(
             locked,
             AdbSyncResponseId.Data,
-            AdbSyncDataResponse
+            AdbSyncDataResponse,
         )) {
             yield packet.data;
         }
         done = true;
+    } catch (e) {
+        done = true;
+        throw e;
     } 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
+                AdbSyncDataResponse,
             )) {
                 void packet;
             }
@@ -47,7 +50,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

@@ -26,14 +26,14 @@ export interface AdbSyncPushV1Options {
 }
 
 export const AdbSyncOkResponse = new Struct({ littleEndian: true }).uint32(
-    "unused"
+    "unused",
 );
 
 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.
@@ -45,11 +45,11 @@ async function pipeFileData(
                     await adbSyncWriteRequest(
                         locked,
                         AdbSyncRequestId.Data,
-                        chunk
+                        chunk,
                     );
                 },
             }),
-            { signal: abortController.signal }
+            { signal: abortController.signal },
         )
         .then(async () => {
             await adbSyncWriteRequest(locked, AdbSyncRequestId.Done, mtime);
@@ -59,7 +59,7 @@ async function pipeFileData(
     await adbSyncReadResponse(
         locked,
         AdbSyncResponseId.Ok,
-        AdbSyncOkResponse
+        AdbSyncOkResponse,
     ).catch((e) => {
         abortController.abort();
         throw e;
@@ -142,7 +142,7 @@ export async function adbSyncPushV2({
                 id: AdbSyncRequestId.SendV2,
                 mode,
                 flags,
-            })
+            }),
         );
 
         await pipeFileData(locked, file, packetSize, mtime);

package/src/commands/sync/request.ts

@@ -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

@@ -19,17 +19,19 @@ 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: AsyncExactReadable,
     id: AdbSyncResponseId,
-    type: StructLike<T>
+    type: StructLike<T>,
 ): Promise<T> {
     const actualId = decodeUtf8(await stream.readExactly(4));
     switch (actualId) {
@@ -44,11 +46,11 @@ export async function adbSyncReadResponse<T>(
 }
 
 export async function* adbSyncReadResponses<
-    T extends Struct<object, PropertyKey, object, any>
+    T extends Struct<object, PropertyKey, object, unknown>,
 >(
     stream: AsyncExactReadable,
     id: AdbSyncResponseId,
-    type: T
+    type: T,
 ): AsyncGenerator<StructValueType<T>, void, void> {
     while (true) {
         const actualId = decodeUtf8(await stream.readExactly(4));
@@ -64,11 +66,11 @@ export async function* adbSyncReadResponses<
                 await stream.readExactly(type.size);
                 return;
             case id:
-                yield await type.deserialize(stream);
+                yield (await type.deserialize(stream)) as StructValueType<T>;
                 break;
             default:
                 throw new Error(
-                    `Expected '${id}' or '${AdbSyncResponseId.Done}', but got '${actualId}'`
+                    `Expected '${id}' or '${AdbSyncResponseId.Done}', but got '${actualId}'`,
                 );
         }
     }

package/src/commands/sync/socket.ts

@@ -19,15 +19,15 @@ export class AdbSyncSocketLocked implements AsyncExactReadable {
     readonly #writeLock = new AutoResetEvent();
     readonly #combiner: BufferCombiner;
 
-    public get position() {
+    get position() {
         return this.#readable.position;
     }
 
-    public constructor(
+    constructor(
         writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>,
         readable: BufferedReadableStream,
         bufferSize: number,
-        lock: AutoResetEvent
+        lock: AutoResetEvent,
     ) {
         this.#writer = writer;
         this.#readable = readable;
@@ -35,42 +35,46 @@ export class AdbSyncSocketLocked implements AsyncExactReadable {
         this.#combiner = new BufferCombiner(bufferSize);
     }
 
-    private async writeInnerStream(buffer: Uint8Array) {
+    async #writeInnerStream(buffer: Uint8Array) {
         await ConsumableWritableStream.write(this.#writer, buffer);
     }
 
-    public async flush() {
+    async flush() {
         try {
             await this.#writeLock.wait();
             const buffer = this.#combiner.flush();
             if (buffer) {
-                await this.writeInnerStream(buffer);
+                await this.#writeInnerStream(buffer);
             }
         } finally {
             this.#writeLock.notifyOne();
         }
     }
 
-    public async write(data: Uint8Array) {
+    async write(data: Uint8Array) {
         try {
             await this.#writeLock.wait();
             for (const buffer of this.#combiner.push(data)) {
-                await this.writeInnerStream(buffer);
+                await this.#writeInnerStream(buffer);
             }
         } finally {
             this.#writeLock.notifyOne();
         }
     }
 
-    public async readExactly(length: number) {
+    async readExactly(length: number) {
         await this.flush();
         return await this.#readable.readExactly(length);
     }
 
-    public release(): void {
+    release(): void {
         this.#combiner.flush();
         this.#socketLock.notifyOne();
     }
+
+    async close() {
+        await this.#readable.cancel();
+    }
 }
 
 export class AdbSyncSocket {
@@ -78,22 +82,23 @@ export class AdbSyncSocket {
     readonly #socket: AdbSocket;
     readonly #locked: AdbSyncSocketLocked;
 
-    public constructor(socket: AdbSocket, bufferSize: number) {
+    constructor(socket: AdbSocket, bufferSize: number) {
         this.#socket = socket;
         this.#locked = new AdbSyncSocketLocked(
             socket.writable.getWriter(),
             new BufferedReadableStream(socket.readable),
             bufferSize,
-            this.#lock
+            this.#lock,
         );
     }
 
-    public async lock() {
+    async lock() {
         await this.#lock.wait();
         return this.#locked;
     }
 
-    public async close() {
+    async close() {
+        await this.#locked.close();
         await this.#socket.close();
     }
 }

package/src/commands/sync/stat.ts

@@ -103,7 +103,7 @@ export type AdbSyncStatResponse =
 export async function adbSyncLstat(
     socket: AdbSyncSocket,
     path: string,
-    v2: boolean
+    v2: boolean,
 ): Promise<AdbSyncStat> {
     const locked = await socket.lock();
     try {
@@ -112,14 +112,14 @@ export async function adbSyncLstat(
             return await adbSyncReadResponse(
                 locked,
                 AdbSyncResponseId.Lstat2,
-                AdbSyncStatResponse
+                AdbSyncStatResponse,
             );
         } else {
             await adbSyncWriteRequest(locked, AdbSyncRequestId.Lstat, path);
             const response = await adbSyncReadResponse(
                 locked,
                 AdbSyncResponseId.Lstat,
-                AdbSyncLstatResponse
+                AdbSyncLstatResponse,
             );
             return {
                 mode: response.mode,
@@ -141,7 +141,7 @@ export async function adbSyncLstat(
 
 export async function adbSyncStat(
     socket: AdbSyncSocket,
-    path: string
+    path: string,
 ): Promise<AdbSyncStatResponse> {
     const locked = await socket.lock();
     try {
@@ -149,7 +149,7 @@ export async function adbSyncStat(
         return await adbSyncReadResponse(
             locked,
             AdbSyncResponseId.Stat,
-            AdbSyncStatResponse
+            AdbSyncStatResponse,
         );
     } finally {
         locked.release();