@yume-chan/adb 0.0.10 → 0.0.11

package/src/commands/reverse.ts

@@ -1,12 +1,14 @@
+// cspell: ignore killforward
+
 import { AutoDisposable } from '@yume-chan/event';
 import Struct from '@yume-chan/struct';
-import type { AdbPacket } from '../packet';
-import type { AdbIncomingSocketEventArgs, AdbPacketDispatcher, AdbSocket } from '../socket';
-import { AdbBufferedStream } from '../stream';
-import { decodeUtf8 } from "../utils";
+import type { AdbPacketCore } from '../packet.js';
+import type { AdbIncomingSocketEventArgs, AdbPacketDispatcher, AdbSocket } from '../socket/index.js';
+import { AdbBufferedStream } from '../stream/index.js';
+import { decodeUtf8 } from "../utils/index.js";
 
 export interface AdbReverseHandler {
-    onSocket(packet: AdbPacket, socket: AdbSocket): void;
+    onSocket(packet: AdbPacketCore, socket: AdbSocket): void;
 }
 
 export interface AdbForwardListener {
@@ -50,8 +52,8 @@ export class AdbReverseCommand extends AutoDisposable {
             return;
         }
 
-        const address = decodeUtf8(e.packet.payload!);
-        // tcp:1234\0
+        const address = decodeUtf8(e.packet.payload);
+        // Address format: `tcp:12345\0`
         const port = Number.parseInt(address.substring(4));
         if (this.localPortToHandler.has(port)) {
             this.localPortToHandler.get(port)!.onSocket(e.packet, e.socket);
@@ -78,7 +80,7 @@ export class AdbReverseCommand extends AutoDisposable {
 
         const response = await AdbReverseStringResponse.deserialize(stream);
         return response.content!.split('\n').map(line => {
-            const [deviceSerial, localName, remoteName] = line.split(' ');
+            const [deviceSerial, localName, remoteName] = line.split(' ') as [string, string, string];
             return { deviceSerial, localName, remoteName };
         });
 

package/src/commands/subprocess/index.ts

@@ -0,0 +1,124 @@
+import type { Adb } from '../../adb.js';
+import { DecodeUtf8Stream, GatherStringStream } from "../../stream/index.js";
+import { AdbNoneSubprocessProtocol } from './legacy.js';
+import { AdbShellSubprocessProtocol } from './protocol.js';
+import type { AdbSubprocessProtocol, AdbSubprocessProtocolConstructor } from './types.js';
+
+export * from './legacy.js';
+export * from './protocol.js';
+export * from './types.js';
+export * from './utils.js';
+
+export interface AdbSubprocessOptions {
+    /**
+     * A list of `AdbShellConstructor`s to be used.
+     *
+     * Different `AdbShell` has different capabilities, thus requires specific adaptations.
+     * Check each `AdbShell`'s documentation for details.
+     *
+     * The first one whose `isSupported` returns `true` will be used.
+     * If no `AdbShell` is supported, an error will be thrown.
+     *
+     * The default value is `[AdbShellProtocol, AdbLegacyShell]`.
+     */
+    protocols: AdbSubprocessProtocolConstructor[];
+}
+
+const DefaultOptions: AdbSubprocessOptions = {
+    protocols: [AdbShellSubprocessProtocol, AdbNoneSubprocessProtocol],
+};
+
+export interface SubprocessResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+
+export class AdbSubprocess {
+    public readonly adb: Adb;
+
+    public constructor(adb: Adb) {
+        this.adb = adb;
+    }
+
+    private async createProtocol(command: string, options?: Partial<AdbSubprocessOptions>): Promise<AdbSubprocessProtocol> {
+        let { protocols } = { ...DefaultOptions, ...options };
+
+        let Constructor: AdbSubprocessProtocolConstructor | undefined;
+        for (const item of protocols) {
+            if (await item.isSupported(this.adb)) {
+                Constructor = item;
+                break;
+            }
+        }
+
+        if (!Constructor) {
+            throw new Error('No specified protocol is supported by the device');
+        }
+
+        return await Constructor.spawn(this.adb, command);
+    }
+
+    /**
+     * Spawns the default shell in interactive mode.
+     * @param options The options for creating the `AdbShell`
+     * @returns A new `AdbShell` instance connecting to the spawned shell process.
+     */
+    public shell(options?: Partial<AdbSubprocessOptions>): Promise<AdbSubprocessProtocol> {
+        return this.createProtocol('', options);
+    }
+
+    /**
+     * Spawns a new process using the given `command`.
+     * @param command The command to run, or an array of strings containing both command and args.
+     * @param options The options for creating the `AdbShell`
+     * @returns A new `AdbShell` instance connecting to the spawned process.
+     */
+    public spawn(command: string | string[], options?: Partial<AdbSubprocessOptions>): Promise<AdbSubprocessProtocol> {
+        if (Array.isArray(command)) {
+            command = command.join(' ');
+        }
+        return this.createProtocol(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 `AdbShell`
+     * @returns The entire output of the command
+     */
+    public async spawnAndWait(
+        command: string | string[],
+        options?: Partial<AdbSubprocessOptions>
+    ): Promise<SubprocessResult> {
+        const shell = await this.spawn(command, options);
+
+        const stdout = new GatherStringStream();
+        shell.stdout
+            .pipeThrough(new DecodeUtf8Stream())
+            .pipeThrough(stdout);
+
+        const stderr = new GatherStringStream();
+        shell.stderr
+            .pipeThrough(new DecodeUtf8Stream())
+            .pipeThrough(stderr);
+
+        const exitCode = await 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: [AdbNoneSubprocessProtocol] });
+        return stdout;
+    }
+}

package/src/commands/subprocess/legacy.ts

@@ -0,0 +1,58 @@
+import type { Adb } from "../../adb.js";
+import type { AdbSocket } from "../../socket/index.js";
+import { DuplexStreamFactory, type ReadableStream } from "../../stream/index.js";
+import type { AdbSubprocessProtocol } from "./types.js";
+
+/**
+ * The legacy shell
+ *
+ * Features:
+ * * `stderr`: No
+ * * `exit` exit code: No
+ * * `resize`: No
+ */
+export class AdbNoneSubprocessProtocol implements AdbSubprocessProtocol {
+    public static isSupported() { return true; }
+
+    public static async spawn(adb: Adb, command: string) {
+        return new AdbNoneSubprocessProtocol(await adb.createSocket(`shell:${command}`));
+    }
+
+    private readonly socket: AdbSocket;
+
+    // Legacy shell forwards all data to stdin.
+    public get stdin() { return this.socket.writable; }
+
+    private _stdout: ReadableStream<Uint8Array>;
+    // Legacy shell doesn't support splitting output streams.
+    public get stdout() { return this._stdout; }
+
+    // `stderr` of Legacy shell is always empty.
+    private _stderr: ReadableStream<Uint8Array>;
+    public get stderr() { return this._stderr; }
+
+    private _exit: Promise<number>;
+    public get exit() { return this._exit; }
+
+    public constructor(socket: AdbSocket) {
+        this.socket = socket;
+
+        const factory = new DuplexStreamFactory<Uint8Array, Uint8Array>({
+            close: async () => {
+                await this.socket.close();
+            },
+        });
+
+        this._stdout = factory.createWrapReadable(this.socket.readable);
+        this._stderr = factory.createReadable();
+        this._exit = factory.closed.then(() => 0);
+    }
+
+    public resize() {
+        // Not supported
+    }
+
+    public kill() {
+        return this.socket.close();
+    }
+}

package/src/commands/subprocess/protocol.ts

@@ -0,0 +1,185 @@
+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 { 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";
+
+export enum AdbShellProtocolId {
+    Stdin,
+    Stdout,
+    Stderr,
+    Exit,
+    CloseStdin,
+    WindowSizeChange,
+}
+
+// This packet format is used in both direction.
+const AdbShellProtocolPacket = new Struct({ littleEndian: true })
+    .uint8('id', placeholder<AdbShellProtocolId>())
+    .uint32('length')
+    .uint8Array('data', { lengthField: 'length' });
+
+type AdbShellProtocolPacketInit = typeof AdbShellProtocolPacket['TInit'];
+
+type AdbShellProtocolPacket = StructValueType<typeof AdbShellProtocolPacket>;
+
+class StdinSerializeStream extends TransformStream<Uint8Array, AdbShellProtocolPacketInit>{
+    constructor() {
+        super({
+            transform(chunk, controller) {
+                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);
+                }
+            },
+        });
+    }
+}
+
+class MultiplexStream<T>{
+    private _readable: PushReadableStream<T>;
+    private _readableController!: PushReadableStreamController<T>;
+    public get readable() { return this._readable; }
+
+    private _activeCount = 0;
+
+    constructor() {
+        this._readable = new PushReadableStream(controller => {
+            this._readableController = controller;
+        });
+    }
+
+    public createWriteable() {
+        return new WritableStream<T>({
+            start: () => {
+                this._activeCount += 1;
+            },
+            write: async (chunk) => {
+                await this._readableController.enqueue(chunk);
+            },
+            abort: async (e) => {
+                this._activeCount -= 1;
+                if (this._activeCount === 0) {
+                    this._readableController.close();
+                }
+            },
+            close: async () => {
+                this._activeCount -= 1;
+                if (this._activeCount === 0) {
+                    this._readableController.close();
+                }
+            },
+        });
+    }
+}
+
+/**
+ * Shell v2 a.k.a Shell Protocol
+ *
+ * Features:
+ * * `stderr`: Yes
+ * * `exit` exit code: Yes
+ * * `resize`: Yes
+ */
+export class AdbShellSubprocessProtocol implements AdbSubprocessProtocol {
+    public static isSupported(adb: Adb) {
+        return adb.features!.includes(AdbFeatures.ShellV2);
+    }
+
+    public static async spawn(adb: Adb, command: string) {
+        // TODO: AdbShellSubprocessProtocol: Support raw mode
+        // TODO: AdbShellSubprocessProtocol: Support setting `XTERM` environment variable
+        return new AdbShellSubprocessProtocol(await adb.createSocket(`shell,v2,pty:${command}`));
+    }
+
+    private readonly _socket: AdbSocket;
+    private _socketWriter: WritableStreamDefaultWriter<AdbShellProtocolPacketInit>;
+
+    private _stdin: WritableStream<Uint8Array>;
+    public get stdin() { return this._stdin; }
+
+    private _stdout: ReadableStream<Uint8Array>;
+    public get stdout() { return this._stdout; }
+
+    private _stderr: ReadableStream<Uint8Array>;
+    public get stderr() { return this._stderr; }
+
+    private readonly _exit = new PromiseResolver<number>();
+    public get exit() { return this._exit.promise; }
+
+    public constructor(socket: AdbSocket) {
+        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
+
+        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 `StdoutTransformStream` 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))
+            .pipeTo(socket.writable);
+
+        const { readable, writable } = new StdinSerializeStream();
+        this._stdin = writable;
+        readable.pipeTo(multiplexer.createWriteable());
+
+        this._socketWriter = multiplexer.createWriteable().getWriter();
+    }
+
+    public async resize(rows: number, cols: number) {
+        await this._socketWriter.write({
+            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 not used, so always passing `0` is fine.
+                `${rows}x${cols},0x0\0`
+            ),
+        });
+    }
+
+    public kill() {
+        return this._socket.close();
+    }
+}

package/src/commands/subprocess/types.ts

@@ -0,0 +1,55 @@
+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";
+
+export interface AdbSubprocessProtocol {
+    /**
+     * A WritableStream that writes to the `stdin` pipe.
+     */
+    readonly stdin: WritableStream<Uint8Array>;
+
+    /**
+     * The `stdout` pipe of the process.
+     */
+    readonly stdout: ReadableStream<Uint8Array>;
+
+    /**
+     * The `stderr` pipe of the process.
+     *
+     * Note: Some `AdbShell` doesn't separate `stdout` and `stderr`,
+     * All output will be sent to `stdout`.
+     */
+    readonly stderr: ReadableStream<Uint8Array>;
+
+    /**
+     * A `Promise` that resolves to the exit code of the process.
+     *
+     * Note: Some `AdbShell` doesn't support exit code,
+     * They will always resolve with `0`.
+     */
+    readonly exit: Promise<number>;
+
+    /**
+     * Resizes the current shell.
+     *
+     * Some `AdbShell`s may not support resizing and will always ignore calls to this method.
+     */
+    resize(rows: number, cols: number): ValueOrPromise<void>;
+
+    /**
+     * Kills the current process.
+     */
+    kill(): ValueOrPromise<void>;
+}
+
+export interface AdbSubprocessProtocolConstructor {
+    /** Returns `true` if the `adb` instance supports this shell */
+    isSupported(adb: Adb): ValueOrPromise<boolean>;
+
+    /** Creates a new `AdbShell` using the specified `Adb` and `command` */
+    spawn(adb: Adb, command: string): ValueOrPromise<AdbSubprocessProtocol>;
+
+    /** Creates a new `AdbShell` by attaching to an exist `AdbSocket` */
+    new(socket: AdbSocket): AdbSubprocessProtocol;
+}

package/src/commands/sync/index.ts

@@ -1,7 +1,7 @@
-export * from './list';
-export * from './pull';
-export * from './request';
-export * from './response';
-export * from './push';
-export * from './stat';
-export * from './sync';
+export * from './list.js';
+export * from './pull.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,8 +1,8 @@
 import Struct from '@yume-chan/struct';
-import { AdbBufferedStream } from '../../stream';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request';
-import { AdbSyncDoneResponse, adbSyncReadResponse, AdbSyncResponseId } from './response';
-import { AdbSyncLstatResponse } from './stat';
+import type { AdbBufferedStream, WritableStreamDefaultWriter } from '../../stream/index.js';
+import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
+import { AdbSyncDoneResponse, adbSyncReadResponse, AdbSyncResponseId } from './response.js';
+import { AdbSyncLstatResponse } from './stat.js';
 
 export const AdbSyncEntryResponse =
     new Struct({ littleEndian: true })
@@ -20,9 +20,10 @@ const ResponseTypes = {
 
 export async function* adbSyncOpenDir(
     stream: AdbBufferedStream,
-    path: string
+    writer: WritableStreamDefaultWriter<Uint8Array>,
+    path: string,
 ): AsyncGenerator<AdbSyncEntryResponse, void, void> {
-    await adbSyncWriteRequest(stream, AdbSyncRequestId.List, path);
+    await adbSyncWriteRequest(writer, AdbSyncRequestId.List, path);
 
     while (true) {
         const response = await adbSyncReadResponse(stream, ResponseTypes);

package/src/commands/sync/pull.ts

@@ -1,12 +1,12 @@
 import Struct from '@yume-chan/struct';
-import { AdbBufferedStream } from '../../stream';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request';
-import { AdbSyncDoneResponse, adbSyncReadResponse, AdbSyncResponseId } from './response';
+import { AdbBufferedStream, ReadableStream, WritableStreamDefaultWriter } from '../../stream/index.js';
+import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
+import { AdbSyncDoneResponse, adbSyncReadResponse, AdbSyncResponseId } from './response.js';
 
 export const AdbSyncDataResponse =
     new Struct({ littleEndian: true })
         .uint32('dataLength')
-        .arrayBuffer('data', { lengthField: 'dataLength' })
+        .uint8Array('data', { lengthField: 'dataLength' })
         .extra({ id: AdbSyncResponseId.Data as const });
 
 const ResponseTypes = {
@@ -14,21 +14,30 @@ const ResponseTypes = {
     [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncDataResponse.size),
 };
 
-export async function* adbSyncPull(
+export function adbSyncPull(
     stream: AdbBufferedStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
     path: string,
-): AsyncGenerator<ArrayBuffer, void, void> {
-    await adbSyncWriteRequest(stream, AdbSyncRequestId.Receive, path);
-    while (true) {
-        const response = await adbSyncReadResponse(stream, ResponseTypes);
-        switch (response.id) {
-            case AdbSyncResponseId.Data:
-                yield response.data!;
-                break;
-            case AdbSyncResponseId.Done:
-                return;
-            default:
-                throw new Error('Unexpected response id');
+): ReadableStream<Uint8Array> {
+    return new ReadableStream<Uint8Array>({
+        async start() {
+            await adbSyncWriteRequest(writer, AdbSyncRequestId.Receive, path);
+        },
+        async pull(controller) {
+            const response = await adbSyncReadResponse(stream, ResponseTypes);
+            switch (response.id) {
+                case AdbSyncResponseId.Data:
+                    controller.enqueue(response.data!);
+                    break;
+                case AdbSyncResponseId.Done:
+                    controller.close();
+                    break;
+                default:
+                    throw new Error('Unexpected response id');
+            }
         }
-    }
+    }, {
+        highWaterMark: 16 * 1024,
+        size(chunk) { return chunk.byteLength; }
+    });
 }

package/src/commands/sync/push.ts

@@ -1,9 +1,8 @@
 import Struct from '@yume-chan/struct';
-import { AdbBufferedStream } from '../../stream';
-import { chunkArrayLike, chunkAsyncIterable } from '../../utils';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request';
-import { adbSyncReadResponse, AdbSyncResponseId } from './response';
-import { LinuxFileType } from './stat';
+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';
 
 export const AdbSyncOkResponse =
     new Struct({ littleEndian: true })
@@ -13,34 +12,30 @@ const ResponseTypes = {
     [AdbSyncResponseId.Ok]: AdbSyncOkResponse,
 };
 
-export const AdbSyncMaxPacketSize = 64 * 1024;
+export const ADB_SYNC_MAX_PACKET_SIZE = 64 * 1024;
 
-export async function adbSyncPush(
+export function adbSyncPush(
     stream: AdbBufferedStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
     filename: string,
-    content: ArrayLike<number> | ArrayBufferLike | AsyncIterable<ArrayBuffer>,
     mode: number = (LinuxFileType.File << 12) | 0o666,
     mtime: number = (Date.now() / 1000) | 0,
-    packetSize: number = AdbSyncMaxPacketSize,
-    onProgress?: (uploaded: number) => void,
-): Promise<void> {
-    const pathAndMode = `${filename},${mode.toString()}`;
-    await adbSyncWriteRequest(stream, AdbSyncRequestId.Send, pathAndMode);
-
-    let chunkReader: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>;
-    if ('length' in content || 'byteLength' in content) {
-        chunkReader = chunkArrayLike(content, packetSize);
-    } else {
-        chunkReader = chunkAsyncIterable(content, packetSize);
-    }
-
-    let uploaded = 0;
-    for await (const buffer of chunkReader) {
-        await adbSyncWriteRequest(stream, AdbSyncRequestId.Data, buffer);
-        uploaded += buffer.byteLength;
-        onProgress?.(uploaded);
-    }
-
-    await adbSyncWriteRequest(stream, AdbSyncRequestId.Done, mtime);
-    await adbSyncReadResponse(stream, ResponseTypes);
+    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);
+            },
+            async write(chunk) {
+                await adbSyncWriteRequest(writer, AdbSyncRequestId.Data, chunk);
+            },
+            async close() {
+                await adbSyncWriteRequest(writer, AdbSyncRequestId.Done, mtime);
+                await adbSyncReadResponse(stream, ResponseTypes);
+            },
+        }),
+        new ChunkStream(packetSize)
+    );
 }

package/src/commands/sync/request.ts

@@ -1,6 +1,6 @@
 import Struct from '@yume-chan/struct';
-import type { AdbBufferedStream } from '../../stream';
-import { encodeUtf8 } from "../../utils";
+import type { WritableStreamDefaultWriter } from "../../stream/index.js";
+import { encodeUtf8 } from "../../utils/index.js";
 
 export enum AdbSyncRequestId {
     List = 'LIST',
@@ -21,14 +21,14 @@ export const AdbSyncNumberRequest =
 export const AdbSyncDataRequest =
     new Struct({ littleEndian: true })
         .fields(AdbSyncNumberRequest)
-        .arrayBuffer('data', { lengthField: 'arg' });
+        .uint8Array('data', { lengthField: 'arg' });
 
 export async function adbSyncWriteRequest(
-    stream: AdbBufferedStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
     id: AdbSyncRequestId | string,
-    value: number | string | ArrayBuffer
+    value: number | string | Uint8Array
 ): Promise<void> {
-    let buffer: ArrayBuffer;
+    let buffer: Uint8Array;
     if (typeof value === 'number') {
         buffer = AdbSyncNumberRequest.serialize({
             id,
@@ -45,5 +45,5 @@ export async function adbSyncWriteRequest(
             data: value,
         });
     }
-    await stream.write(buffer);
+    await writer.write(buffer);
 }