@yume-chan/adb 0.0.16 → 0.0.17

package/src/commands/subprocess/index.ts

@@ -1,139 +1,3 @@
-import type { Adb } from '../../adb.js';
-import { DecodeUtf8Stream, GatherStringStream } from "../../stream/index.js";
-import { AdbSubprocessNoneProtocol, AdbSubprocessShellProtocol, type AdbSubprocessProtocol, type AdbSubprocessProtocolConstructor } from './protocols/index.js';
-
+export * from './command.js';
 export * from './protocols/index.js';
 export * from './utils.js';
-
-export interface AdbSubprocessOptions {
-    /**
-     * A list of `AdbSubprocessProtocolConstructor`s to be used.
-     *
-     * Different `AdbSubprocessProtocol` has different capabilities, thus requires specific adaptations.
-     * Check their documentations for details.
-     *
-     * The first protocol whose `isSupported` returns `true` will be used.
-     * If no `AdbSubprocessProtocol` is supported, an error will be thrown.
-     *
-     * @default [AdbSubprocessShellProtocol, AdbSubprocessNoneProtocol]
-     */
-    protocols: AdbSubprocessProtocolConstructor[];
-}
-
-const DEFAULT_OPTIONS: AdbSubprocessOptions = {
-    protocols: [AdbSubprocessShellProtocol, AdbSubprocessNoneProtocol],
-};
-
-export interface AdbSubprocessWaitResult {
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-}
-
-export class AdbSubprocess {
-    public readonly adb: Adb;
-
-    public constructor(adb: Adb) {
-        this.adb = adb;
-    }
-
-    private async createProtocol(
-        mode: 'pty' | 'raw',
-        command?: string | string[],
-        options?: Partial<AdbSubprocessOptions>
-    ): Promise<AdbSubprocessProtocol> {
-        const { protocols } = { ...DEFAULT_OPTIONS, ...options };
-
-        let Constructor: AdbSubprocessProtocolConstructor | undefined;
-        for (const item of protocols) {
-            // It's async so can't use `Array#find`
-            if (await item.isSupported(this.adb)) {
-                Constructor = item;
-                break;
-            }
-        }
-
-        if (!Constructor) {
-            throw new Error('No specified protocol is supported by the device');
-        }
-
-        if (Array.isArray(command)) {
-            command = command.join(' ');
-        } else if (command === undefined) {
-            // spawn the default shell
-            command = '';
-        }
-        return await Constructor[mode](this.adb, command);
-    }
-
-    /**
-     * Spawns an executable in PTY (interactive) mode.
-     * @param command The command to run. If omitted, the default shell will be spawned.
-     * @param options The options for creating the `AdbSubprocessProtocol`
-     * @returns A new `AdbSubprocessProtocol` instance connecting to the spawned process.
-     */
-    public shell(
-        command?: string | string[],
-        options?: Partial<AdbSubprocessOptions>
-    ): Promise<AdbSubprocessProtocol> {
-        return this.createProtocol('pty', command, options);
-    }
-
-    /**
-     * Spawns an executable and pipe the output.
-     * @param command The command to run, or an array of strings containing both command and args.
-     * @param options The options for creating the `AdbSubprocessProtocol`
-     * @returns A new `AdbSubprocessProtocol` instance connecting to the spawned process.
-     */
-    public spawn(
-        command: string | string[],
-        options?: Partial<AdbSubprocessOptions>
-    ): Promise<AdbSubprocessProtocol> {
-        return this.createProtocol('raw', command, options);
-    }
-
-    /**
-     * Spawns a new process, waits until it exits, and returns the entire output.
-     * @param command The command to run
-     * @param options The options for creating the `AdbSubprocessProtocol`
-     * @returns The entire output of the command
-     */
-    public async spawnAndWait(
-        command: string | string[],
-        options?: Partial<AdbSubprocessOptions>
-    ): Promise<AdbSubprocessWaitResult> {
-        const shell = await this.spawn(command, options);
-
-        const stdout = new GatherStringStream();
-        const stderr = new GatherStringStream();
-
-        const [, , exitCode] = await Promise.all([
-            shell.stdout
-                .pipeThrough(new DecodeUtf8Stream())
-                .pipeTo(stdout),
-            shell.stderr
-                .pipeThrough(new DecodeUtf8Stream())
-                .pipeTo(stderr),
-            shell.exit
-        ]);
-
-        return {
-            stdout: stdout.result,
-            stderr: stderr.result,
-            exitCode,
-        };
-    }
-
-    /**
-     * Spawns a new process, waits until it exits, and returns the entire output.
-     * @param command The command to run
-     * @returns The entire output of the command
-     */
-    public async spawnAndWaitLegacy(command: string | string[]): Promise<string> {
-        const { stdout } = await this.spawnAndWait(
-            command,
-            { protocols: [AdbSubprocessNoneProtocol] }
-        );
-        return stdout;
-    }
-}

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

@@ -1,7 +1,8 @@
-import type { Adb } from "../../../adb.js";
-import type { AdbSocket } from "../../../socket/index.js";
-import { DuplexStreamFactory, ReadableStream } from "../../../stream/index.js";
-import type { AdbSubprocessProtocol } from "./types.js";
+import { DuplexStreamFactory, ReadableStream } from '@yume-chan/stream-extra';
+
+import type { Adb } from '../../../adb.js';
+import type { AdbSocket } from '../../../socket/index.js';
+import type { AdbSubprocessProtocol } from './types.js';
 
 /**
  * The legacy shell
@@ -20,7 +21,7 @@ export class AdbSubprocessNoneProtocol implements AdbSubprocessProtocol {
 
     public static async raw(adb: Adb, command: string) {
         // `shell,raw:${command}` also triggers raw mode,
-        // But is not supported before Android 7.
+        // But is not supported on Android version <7.
         return new AdbSubprocessNoneProtocol(await adb.createSocket(`exec:${command}`));
     }
 
@@ -49,6 +50,8 @@ export class AdbSubprocessNoneProtocol implements AdbSubprocessProtocol {
     public constructor(socket: AdbSocket) {
         this.socket = socket;
 
+        // Link `stdout`, `stderr` and `stdin` together,
+        // so closing any of them will close the others.
         this.duplex = new DuplexStreamFactory<Uint8Array, Uint8Array>({
             close: async () => {
                 await this.socket.close();
@@ -61,7 +64,7 @@ export class AdbSubprocessNoneProtocol implements AdbSubprocessProtocol {
     }
 
     public resize() {
-        // Not supported
+        // Not supported, but don't throw.
     }
 
     public kill() {

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

@@ -1,11 +1,12 @@
-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 { 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';
 
 export enum AdbShellProtocolId {
     Stdin,
@@ -102,7 +103,7 @@ 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) {
@@ -178,7 +179,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,22 @@
-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, 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`.

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,7 +1,8 @@
+import type { BufferedReadableStream, WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
 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 { adbSyncReadResponses, AdbSyncResponseId } from './response.js';
 import { AdbSyncLstatResponse, AdbSyncStatResponse, type AdbSyncStat } from './stat.js';
 
 export interface AdbSyncEntry extends AdbSyncStat {
@@ -26,61 +27,28 @@ export const AdbSyncEntry2Response =
 
 export type AdbSyncEntry2Response = typeof AdbSyncEntry2Response['TDeserializeResult'];
 
-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 async function* adbSyncOpenDir(
-    stream: AdbBufferedStream,
+    stream: BufferedReadableStream,
     writer: WritableStreamDefaultWriter<Uint8Array>,
     path: string,
     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);
+        yield* adbSyncReadResponses(stream, AdbSyncResponseId.Entry2, AdbSyncEntry2Response);
     } 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,7 +1,8 @@
+import { BufferedReadableStream, ReadableStream, WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
 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 { adbSyncReadResponses, AdbSyncResponseId } from './response.js';
 
 export const AdbSyncDataResponse =
     new Struct({ littleEndian: true })
@@ -9,35 +10,33 @@ export const AdbSyncDataResponse =
         .uint8Array('data', { lengthField: 'dataLength' })
         .extra({ id: AdbSyncResponseId.Data as const });
 
-const RESPONSE_TYPES = {
-    [AdbSyncResponseId.Data]: AdbSyncDataResponse,
-    [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncDataResponse.size),
-};
+export type AdbSyncDataResponse = typeof AdbSyncDataResponse['TDeserializeResult'];
 
 export function adbSyncPull(
-    stream: AdbBufferedStream,
+    stream: BufferedReadableStream,
     writer: WritableStreamDefaultWriter<Uint8Array>,
     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 response = await adbSyncReadResponse(stream, RESPONSE_TYPES);
-            switch (response.id) {
-                case AdbSyncResponseId.Data:
-                    controller.enqueue(response.data!);
-                    break;
-                case AdbSyncResponseId.Done:
-                    controller.close();
-                    break;
-                default:
-                    throw new Error('Unexpected response id');
+            const { done, value } = await generator.next();
+            if (done) {
+                controller.close();
+                return;
             }
+            controller.enqueue(value.data);
         },
         cancel() {
-            throw new Error(`Sync commands don't support cancel.`);
+            try {
+                generator.return();
+            } catch { }
+            throw new Error(`Sync commands can't be canceled.`);
         },
     }, {
         highWaterMark: 16 * 1024,

package/src/commands/sync/push.ts

@@ -1,5 +1,6 @@
+import { BufferedReadableStream, ChunkStream, pipeFrom, WritableStream, WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
 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';
@@ -8,14 +9,10 @@ export const AdbSyncOkResponse =
     new Struct({ littleEndian: true })
         .uint32('unused');
 
-const ResponseTypes = {
-    [AdbSyncResponseId.Ok]: AdbSyncOkResponse,
-};
-
 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,
@@ -33,7 +30,7 @@ export function adbSyncPush(
             },
             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,6 +1,7 @@
+import type { WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
 import Struct from '@yume-chan/struct';
-import type { WritableStreamDefaultWriter } from "../../stream/index.js";
-import { encodeUtf8 } from "../../utils/index.js";
+
+import { encodeUtf8 } from '../../utils/index.js';
 
 export enum AdbSyncRequestId {
     List = 'LIST',

package/src/commands/sync/response.ts

@@ -1,6 +1,7 @@
-import Struct, { type StructAsyncDeserializeStream, type StructLike, type StructValueType } from '@yume-chan/struct';
-import type { AdbBufferedStream } from '../../stream/index.js';
-import { decodeUtf8 } from "../../utils/index.js";
+import type { BufferedReadableStream } from '@yume-chan/stream-extra';
+import Struct, { StructValueType, type StructLike } from '@yume-chan/struct';
+
+import { decodeUtf8 } from '../../utils/index.js';
 
 export enum AdbSyncResponseId {
     Entry = 'DENT',
@@ -14,25 +15,6 @@ export enum AdbSyncResponseId {
     Fail = 'FAIL',
 }
 
-// DONE responses' size are always same as the request's normal response.
-// For example DONE responses for LIST requests are 16 bytes (same as DENT responses),
-// but DONE responses for STAT requests are 12 bytes (same as STAT responses)
-// So we need to know responses' size in advance.
-export class AdbSyncDoneResponse implements StructLike<AdbSyncDoneResponse> {
-    private length: number;
-
-    public readonly id = AdbSyncResponseId.Done;
-
-    public constructor(length: number) {
-        this.length = length;
-    }
-
-    public async deserialize(stream: StructAsyncDeserializeStream): Promise<this> {
-        await stream.read(this.length);
-        return this;
-    }
-}
-
 export const AdbSyncFailResponse =
     new Struct({ littleEndian: true })
         .uint32('messageLength')
@@ -41,24 +23,46 @@ export const AdbSyncFailResponse =
             throw new Error(object.message);
         });
 
-export async function adbSyncReadResponse<T extends Record<string, StructLike<any>>>(
-    stream: AdbBufferedStream,
-    types: T,
-    // When `T` is a union type, `T[keyof T]` only includes their common keys.
-    // For example, let `type T = { a: string, b: string } | { a: string, c: string}`,
-    // `keyof T` is `'a'`, not `'a' | 'b' | 'c'`.
-    // However, `T extends unknown ? keyof T : never` will distribute `T`,
-    // so returns all keys.
-): Promise<StructValueType<T extends unknown ? T[keyof T] : never>> {
-    const id = decodeUtf8(await stream.read(4));
-
-    if (id === AdbSyncResponseId.Fail) {
-        await AdbSyncFailResponse.deserialize(stream);
+export async function adbSyncReadResponse<T>(
+    stream: BufferedReadableStream,
+    id: AdbSyncResponseId,
+    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');
+        case id:
+            return await type.deserialize(stream);
+        default:
+            throw new Error(`Expected '${id}', but got '${actualId}'`);
     }
+}
 
-    if (types[id]) {
-        return types[id]!.deserialize(stream);
+export async function* adbSyncReadResponses<T extends Struct<any, any, any, any>>(
+    stream: BufferedReadableStream,
+    id: AdbSyncResponseId,
+    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');
+            case AdbSyncResponseId.Done:
+                // `DONE` responses' size are always same as the request's normal response.
+                //
+                // For example, `DONE` responses for `LIST` requests are 16 bytes (same as `DENT` responses),
+                // but `DONE` responses for `STAT` requests are 12 bytes (same as `STAT` responses).
+                await stream.read(type.size);
+                return;
+            case id:
+                yield await type.deserialize(stream);
+                break;
+            default:
+                throw new Error(`Expected '${id}' or '${AdbSyncResponseId.Done}', but got '${actualId}'`);
+        }
     }
-
-    throw new Error(`Expected '${Object.keys(types).join(', ')}', but got '${id}'`);
 }

package/src/commands/sync/stat.ts

@@ -1,5 +1,6 @@
+import type { BufferedReadableStream, WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
 import Struct, { placeholder } from '@yume-chan/struct';
-import type { AdbBufferedStream, WritableStreamDefaultWriter } from '../../stream/index.js';
+
 import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
 import { adbSyncReadResponse, AdbSyncResponseId } from './response.js';
 
@@ -95,57 +96,34 @@ export const AdbSyncStatResponse =
 
 export type AdbSyncStatResponse = typeof AdbSyncStatResponse['TDeserializeResult'];
 
-const STAT_RESPONSE_TYPES = {
-    [AdbSyncResponseId.Stat]: AdbSyncStatResponse,
-};
-
-const LSTAT_RESPONSE_TYPES = {
-    [AdbSyncResponseId.Lstat]: AdbSyncLstatResponse,
-};
-
-const LSTAT_V2_RESPONSE_TYPES = {
-    [AdbSyncResponseId.Lstat2]: AdbSyncStatResponse,
-};
-
 export async function adbSyncLstat(
-    stream: AdbBufferedStream,
+    stream: BufferedReadableStream,
     writer: WritableStreamDefaultWriter<Uint8Array>,
     path: string,
     v2: boolean,
 ): Promise<AdbSyncStat> {
-    let requestId: AdbSyncRequestId.Lstat | AdbSyncRequestId.Lstat2;
-    let responseType: typeof LSTAT_RESPONSE_TYPES | typeof LSTAT_V2_RESPONSE_TYPES;
-
     if (v2) {
-        requestId = AdbSyncRequestId.Lstat2;
-        responseType = LSTAT_V2_RESPONSE_TYPES;
+        await adbSyncWriteRequest(writer, AdbSyncRequestId.Lstat2, path);
+        return await adbSyncReadResponse(stream, AdbSyncResponseId.Lstat2, AdbSyncStatResponse);
     } else {
-        requestId = AdbSyncRequestId.Lstat;
-        responseType = LSTAT_RESPONSE_TYPES;
-    }
-
-    await adbSyncWriteRequest(writer, requestId, path);
-    const response = await adbSyncReadResponse(stream, responseType);
-
-    switch (response.id) {
-        case AdbSyncResponseId.Lstat:
-            return {
-                mode: response.mode,
-                size: BigInt(response.size),
-                mtime: BigInt(response.mtime),
-                get type() { return response.type; },
-                get permission() { return response.permission; },
-            };
-        default:
-            return response;
+        await adbSyncWriteRequest(writer, AdbSyncRequestId.Lstat, path);
+        const response = await adbSyncReadResponse(stream, AdbSyncResponseId.Lstat, AdbSyncLstatResponse);
+        return {
+            mode: response.mode,
+            // Convert to `BigInt` to make it compatible with `AdbSyncStatResponse`
+            size: BigInt(response.size),
+            mtime: BigInt(response.mtime),
+            get type() { return response.type; },
+            get permission() { return response.permission; },
+        };
     }
 }
 
 export async function adbSyncStat(
-    stream: AdbBufferedStream,
+    stream: BufferedReadableStream,
     writer: WritableStreamDefaultWriter<Uint8Array>,
     path: string,
 ): Promise<AdbSyncStatResponse> {
     await adbSyncWriteRequest(writer, AdbSyncRequestId.Stat, path);
-    return await adbSyncReadResponse(stream, STAT_RESPONSE_TYPES);
+    return await adbSyncReadResponse(stream, AdbSyncResponseId.Stat, AdbSyncStatResponse);
 }