@yume-chan/adb 0.0.18 → 0.0.19

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

@@ -1,17 +1,18 @@
-import {
-    type ReadableStream,
-    type WritableStream,
+import type {
+    Consumable,
+    ReadableStream,
+    WritableStream,
 } from "@yume-chan/stream-extra";
-import { type ValueOrPromise } from "@yume-chan/struct";
+import type { ValueOrPromise } from "@yume-chan/struct";
 
-import { type Adb } from "../../../adb.js";
-import { type AdbSocket } from "../../../socket/index.js";
+import type { Adb } from "../../../adb.js";
+import type { AdbSocket } from "../../../socket/index.js";
 
 export interface AdbSubprocessProtocol {
     /**
      * A WritableStream that writes to the `stdin` stream.
      */
-    readonly stdin: WritableStream<Uint8Array>;
+    readonly stdin: WritableStream<Consumable<Uint8Array>>;
 
     /**
      * The `stdout` stream of the process.

package/src/commands/subprocess/utils.ts

@@ -1,5 +1,5 @@
 export function escapeArg(s: string) {
-    let result = '';
+    let result = "";
     result += `'`;
 
     let base = 0;

package/src/commands/sync/index.ts

@@ -1,7 +1,8 @@
-export * from './list.js';
-export * from './pull.js';
-export * from './push.js';
-export * from './request.js';
-export * from './response.js';
-export * from './stat.js';
-export * from './sync.js';
+export * from "./list.js";
+export * from "./pull.js";
+export * from "./push.js";
+export * from "./request.js";
+export * from "./response.js";
+export * from "./socket.js";
+export * from "./stat.js";
+export * from "./sync.js";

package/src/commands/sync/list.ts

@@ -1,16 +1,10 @@
-import {
-    type BufferedReadableStream,
-    type WritableStreamDefaultWriter,
-} from "@yume-chan/stream-extra";
 import Struct from "@yume-chan/struct";
 
 import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
 import { AdbSyncResponseId, adbSyncReadResponses } from "./response.js";
-import {
-    AdbSyncLstatResponse,
-    AdbSyncStatResponse,
-    type AdbSyncStat,
-} from "./stat.js";
+import type { AdbSyncSocket } from "./socket.js";
+import type { AdbSyncStat } from "./stat.js";
+import { AdbSyncLstatResponse, AdbSyncStatResponse } from "./stat.js";
 
 export interface AdbSyncEntry extends AdbSyncStat {
     name: string;
@@ -23,7 +17,7 @@ export const AdbSyncEntryResponse = new Struct({ littleEndian: true })
     .extra({ id: AdbSyncResponseId.Entry as const });
 
 export type AdbSyncEntryResponse =
-    typeof AdbSyncEntryResponse["TDeserializeResult"];
+    (typeof AdbSyncEntryResponse)["TDeserializeResult"];
 
 export const AdbSyncEntry2Response = new Struct({ littleEndian: true })
     .fields(AdbSyncStatResponse)
@@ -32,18 +26,17 @@ export const AdbSyncEntry2Response = new Struct({ littleEndian: true })
     .extra({ id: AdbSyncResponseId.Entry2 as const });
 
 export type AdbSyncEntry2Response =
-    typeof AdbSyncEntry2Response["TDeserializeResult"];
+    (typeof AdbSyncEntry2Response)["TDeserializeResult"];
 
-export async function* adbSyncOpenDir(
-    stream: BufferedReadableStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
-    path: string,
-    v2: boolean
-): AsyncGenerator<AdbSyncEntry, void, void> {
-    if (v2) {
-        await adbSyncWriteRequest(writer, AdbSyncRequestId.List2, path);
+export async function* adbSyncOpenDirV2(
+    socket: AdbSyncSocket,
+    path: string
+): AsyncGenerator<AdbSyncEntry2Response, void, void> {
+    const locked = await socket.lock();
+    try {
+        await adbSyncWriteRequest(locked, AdbSyncRequestId.ListV2, path);
         for await (const item of adbSyncReadResponses(
-            stream,
+            locked,
             AdbSyncResponseId.Entry2,
             AdbSyncEntry2Response
         )) {
@@ -55,13 +48,39 @@ export async function* adbSyncOpenDir(
             }
             yield item;
         }
-    } else {
-        await adbSyncWriteRequest(writer, AdbSyncRequestId.List, path);
+    } finally {
+        locked.release();
+    }
+}
+
+export async function* adbSyncOpenDirV1(
+    socket: AdbSyncSocket,
+    path: string
+): AsyncGenerator<AdbSyncEntryResponse, void, void> {
+    const locked = await socket.lock();
+    try {
+        await adbSyncWriteRequest(locked, AdbSyncRequestId.List, path);
         for await (const item of adbSyncReadResponses(
-            stream,
+            locked,
             AdbSyncResponseId.Entry,
             AdbSyncEntryResponse
         )) {
+            yield item;
+        }
+    } finally {
+        locked.release();
+    }
+}
+
+export async function* adbSyncOpenDir(
+    socket: AdbSyncSocket,
+    path: string,
+    v2: boolean
+): AsyncGenerator<AdbSyncEntry, void, void> {
+    if (v2) {
+        yield* adbSyncOpenDirV2(socket, path);
+    } else {
+        for await (const item of adbSyncOpenDirV1(socket, path)) {
             // Convert to same format as `AdbSyncEntry2Response` for easier consumption.
             // However it will add some overhead.
             yield {

package/src/commands/sync/pull.ts

@@ -1,12 +1,10 @@
-import {
-    ReadableStream,
-    type BufferedReadableStream,
-    type WritableStreamDefaultWriter,
-} from "@yume-chan/stream-extra";
+import type { ReadableStream } from "@yume-chan/stream-extra";
+import { PushReadableStream } from "@yume-chan/stream-extra";
 import Struct from "@yume-chan/struct";
 
 import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
 import { AdbSyncResponseId, adbSyncReadResponses } from "./response.js";
+import type { AdbSyncSocket } from "./socket.js";
 
 export const AdbSyncDataResponse = new Struct({ littleEndian: true })
     .uint32("dataLength")
@@ -14,49 +12,46 @@ export const AdbSyncDataResponse = new Struct({ littleEndian: true })
     .extra({ id: AdbSyncResponseId.Data as const });
 
 export type AdbSyncDataResponse =
-    typeof AdbSyncDataResponse["TDeserializeResult"];
+    (typeof AdbSyncDataResponse)["TDeserializeResult"];
+
+export async function* adbSyncPullGenerator(
+    socket: AdbSyncSocket,
+    path: string
+): AsyncGenerator<Uint8Array, void, void> {
+    const locked = await socket.lock();
+    let done = false;
+    try {
+        await adbSyncWriteRequest(locked, AdbSyncRequestId.Receive, path);
+        for await (const packet of adbSyncReadResponses(
+            locked,
+            AdbSyncResponseId.Data,
+            AdbSyncDataResponse
+        )) {
+            yield packet.data;
+        }
+        done = true;
+    } finally {
+        if (!done) {
+            // sync pull can't be cancelled, so we have to read all data
+            for await (const packet of adbSyncReadResponses(
+                locked,
+                AdbSyncResponseId.Data,
+                AdbSyncDataResponse
+            )) {
+                void packet;
+            }
+        }
+        locked.release();
+    }
+}
 
 export function adbSyncPull(
-    stream: BufferedReadableStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
+    socket: AdbSyncSocket,
     path: string
 ): ReadableStream<Uint8Array> {
-    let generator!: AsyncGenerator<AdbSyncDataResponse, void, void>;
-    return new ReadableStream<Uint8Array>(
-        {
-            async start() {
-                // TODO: If `ReadableStream.from(AsyncGenerator)` is added to spec, use it instead.
-                await adbSyncWriteRequest(
-                    writer,
-                    AdbSyncRequestId.Receive,
-                    path
-                );
-                generator = adbSyncReadResponses(
-                    stream,
-                    AdbSyncResponseId.Data,
-                    AdbSyncDataResponse
-                );
-            },
-            async pull(controller) {
-                const { done, value } = await generator.next();
-                if (done) {
-                    controller.close();
-                    return;
-                }
-                controller.enqueue(value.data);
-            },
-            cancel() {
-                generator.return().catch((e) => {
-                    void e;
-                });
-                throw new Error(`Sync commands can't be canceled.`);
-            },
-        },
-        {
-            highWaterMark: 16 * 1024,
-            size(chunk) {
-                return chunk.byteLength;
-            },
+    return new PushReadableStream(async (controller) => {
+        for await (const data of adbSyncPullGenerator(socket, path)) {
+            await controller.enqueue(data);
         }
-    );
+    });
 }

package/src/commands/sync/push.ts

@@ -1,52 +1,159 @@
+import type { Consumable, ReadableStream } from "@yume-chan/stream-extra";
 import {
-    ChunkStream,
-    WritableStream,
-    pipeFrom,
-    type BufferedReadableStream,
-    type WritableStreamDefaultWriter,
+    AbortController,
+    ConsumableWritableStream,
+    DistributionStream,
 } from "@yume-chan/stream-extra";
-import Struct from "@yume-chan/struct";
+import Struct, { placeholder } from "@yume-chan/struct";
 
 import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
 import { AdbSyncResponseId, adbSyncReadResponse } from "./response.js";
+import type { AdbSyncSocket, AdbSyncSocketLocked } from "./socket.js";
 import { LinuxFileType } from "./stat.js";
 
+const NOOP = () => {
+    // no-op
+};
+
+export const ADB_SYNC_MAX_PACKET_SIZE = 64 * 1024;
+
+export interface AdbSyncPushV1Options {
+    socket: AdbSyncSocket;
+    filename: string;
+    file: ReadableStream<Consumable<Uint8Array>>;
+    mode?: number;
+    mtime?: number;
+    packetSize?: number;
+}
+
 export const AdbSyncOkResponse = new Struct({ littleEndian: true }).uint32(
     "unused"
 );
 
-export const ADB_SYNC_MAX_PACKET_SIZE = 64 * 1024;
+async function pipeFile(
+    locked: AdbSyncSocketLocked,
+    file: ReadableStream<Consumable<Uint8Array>>,
+    packetSize: number,
+    mtime: number
+) {
+    // Read and write in parallel,
+    // allow error response to abort the write.
+    const abortController = new AbortController();
+    file.pipeThrough(new DistributionStream(packetSize, true))
+        .pipeTo(
+            new ConsumableWritableStream({
+                write: async (chunk) => {
+                    await adbSyncWriteRequest(
+                        locked,
+                        AdbSyncRequestId.Data,
+                        chunk
+                    );
+                },
+            }),
+            { signal: abortController.signal }
+        )
+        .then(async () => {
+            await adbSyncWriteRequest(locked, AdbSyncRequestId.Done, mtime);
+            await locked.flush();
+        }, NOOP);
+
+    await adbSyncReadResponse(
+        locked,
+        AdbSyncResponseId.Ok,
+        AdbSyncOkResponse
+    ).catch((e) => {
+        abortController.abort();
+        throw e;
+    });
+}
+
+export async function adbSyncPushV1({
+    socket,
+    filename,
+    file,
+    mode = (LinuxFileType.File << 12) | 0o666,
+    mtime = (Date.now() / 1000) | 0,
+    packetSize = ADB_SYNC_MAX_PACKET_SIZE,
+}: AdbSyncPushV1Options) {
+    const locked = await socket.lock();
+    try {
+        const pathAndMode = `${filename},${mode.toString()}`;
+        await adbSyncWriteRequest(locked, AdbSyncRequestId.Send, pathAndMode);
+        await pipeFile(locked, file, packetSize, mtime);
+    } finally {
+        locked.release();
+    }
+}
+
+export enum AdbSyncSendV2Flags {
+    None = 0,
+    Brotli = 1,
+    /**
+     * 2
+     */
+    Lz4 = 1 << 1,
+    /**
+     * 4
+     */
+    Zstd = 1 << 2,
+    /**
+     * 0x80000000
+     */
+    DryRun = (1 << 31) >>> 0,
+}
+
+export interface AdbSyncPushV2Options extends AdbSyncPushV1Options {
+    dryRun?: boolean;
+}
+
+export const AdbSyncSendV2Request = new Struct({ littleEndian: true })
+    .uint32("id", placeholder<AdbSyncRequestId>())
+    .uint32("mode")
+    .uint32("flags", placeholder<AdbSyncSendV2Flags>());
+
+export async function adbSyncPushV2({
+    socket,
+    filename,
+    file,
+    mode = (LinuxFileType.File << 12) | 0o666,
+    mtime = (Date.now() / 1000) | 0,
+    packetSize = ADB_SYNC_MAX_PACKET_SIZE,
+    dryRun = false,
+}: AdbSyncPushV2Options) {
+    const locked = await socket.lock();
+    try {
+        await adbSyncWriteRequest(locked, AdbSyncRequestId.SendV2, filename);
+
+        let flags: AdbSyncSendV2Flags = AdbSyncSendV2Flags.None;
+        if (dryRun) {
+            flags |= AdbSyncSendV2Flags.DryRun;
+        }
+        await locked.write(
+            AdbSyncSendV2Request.serialize({
+                id: AdbSyncRequestId.SendV2,
+                mode,
+                flags,
+            })
+        );
+
+        await pipeFile(locked, file, packetSize, mtime);
+    } finally {
+        locked.release();
+    }
+}
+
+export interface AdbSyncPushOptions extends AdbSyncPushV2Options {
+    v2: boolean;
+}
+
+export function adbSyncPush(options: AdbSyncPushOptions) {
+    if (options.v2) {
+        return adbSyncPushV2(options);
+    }
+
+    if (options.dryRun) {
+        throw new Error("dryRun is not supported in v1");
+    }
 
-export function adbSyncPush(
-    stream: BufferedReadableStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
-    filename: string,
-    mode: number = (LinuxFileType.File << 12) | 0o666,
-    mtime: number = (Date.now() / 1000) | 0,
-    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,
-                    AdbSyncResponseId.Ok,
-                    AdbSyncOkResponse
-                );
-            },
-        }),
-        new ChunkStream(packetSize)
-    );
+    return adbSyncPushV1(options);
 }

package/src/commands/sync/request.ts

@@ -1,15 +1,15 @@
-import { type WritableStreamDefaultWriter } from "@yume-chan/stream-extra";
 import Struct from "@yume-chan/struct";
 
 import { encodeUtf8 } from "../../utils/index.js";
 
 export enum AdbSyncRequestId {
     List = "LIST",
-    List2 = "LIS2",
+    ListV2 = "LIS2",
     Send = "SEND",
+    SendV2 = "SND2",
     Lstat = "STAT",
     Stat = "STA2",
-    Lstat2 = "LST2",
+    LstatV2 = "LST2",
     Data = "DATA",
     Done = "DONE",
     Receive = "RECV",
@@ -23,27 +23,32 @@ export const AdbSyncDataRequest = new Struct({ littleEndian: true })
     .fields(AdbSyncNumberRequest)
     .uint8Array("data", { lengthField: "arg" });
 
+export interface AdbSyncWritable {
+    write(buffer: Uint8Array): Promise<void>;
+}
+
 export async function adbSyncWriteRequest(
-    writer: WritableStreamDefaultWriter<Uint8Array>,
+    writable: AdbSyncWritable,
     id: AdbSyncRequestId | string,
     value: number | string | Uint8Array
 ): Promise<void> {
-    let buffer: Uint8Array;
     if (typeof value === "number") {
-        buffer = AdbSyncNumberRequest.serialize({
+        const buffer = AdbSyncNumberRequest.serialize({
             id,
             arg: value,
         });
+        await writable.write(buffer);
     } else if (typeof value === "string") {
-        buffer = AdbSyncDataRequest.serialize({
-            id,
-            data: encodeUtf8(value),
-        });
+        // Let `writable` buffer writes
+        const buffer = encodeUtf8(value);
+        await writable.write(
+            AdbSyncNumberRequest.serialize({ id, arg: buffer.byteLength })
+        );
+        await writable.write(buffer);
     } else {
-        buffer = AdbSyncDataRequest.serialize({
-            id,
-            data: value,
-        });
+        await writable.write(
+            AdbSyncNumberRequest.serialize({ id, arg: value.byteLength })
+        );
+        await writable.write(value);
     }
-    await writer.write(buffer);
 }

package/src/commands/sync/response.ts

@@ -1,8 +1,9 @@
-import { type BufferedReadableStream } from "@yume-chan/stream-extra";
-import Struct, {
-    type StructLike,
-    type StructValueType,
+import type {
+    StructAsyncDeserializeStream,
+    StructLike,
+    StructValueType,
 } from "@yume-chan/struct";
+import Struct from "@yume-chan/struct";
 
 import { decodeUtf8 } from "../../utils/index.js";
 
@@ -26,7 +27,7 @@ export const AdbSyncFailResponse = new Struct({ littleEndian: true })
     });
 
 export async function adbSyncReadResponse<T>(
-    stream: BufferedReadableStream,
+    stream: StructAsyncDeserializeStream,
     id: AdbSyncResponseId,
     type: StructLike<T>
 ): Promise<T> {
@@ -45,7 +46,7 @@ export async function adbSyncReadResponse<T>(
 export async function* adbSyncReadResponses<
     T extends Struct<object, PropertyKey, object, any>
 >(
-    stream: BufferedReadableStream,
+    stream: StructAsyncDeserializeStream,
     id: AdbSyncResponseId,
     type: T
 ): AsyncGenerator<StructValueType<T>, void, void> {

package/src/commands/sync/socket.ts

@@ -0,0 +1,97 @@
+import type {
+    Consumable,
+    WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
+import {
+    BufferCombiner,
+    BufferedReadableStream,
+    ConsumableWritableStream,
+} from "@yume-chan/stream-extra";
+import type { StructAsyncDeserializeStream } from "@yume-chan/struct";
+
+import type { AdbSocket } from "../../index.js";
+import { AutoResetEvent } from "../../index.js";
+
+export class AdbSyncSocketLocked implements StructAsyncDeserializeStream {
+    private readonly _writer: WritableStreamDefaultWriter<
+        Consumable<Uint8Array>
+    >;
+    private readonly _readable: BufferedReadableStream;
+    private readonly _socketLock: AutoResetEvent;
+    private readonly _writeLock = new AutoResetEvent();
+    private readonly _combiner: BufferCombiner;
+
+    public constructor(
+        writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>,
+        readable: BufferedReadableStream,
+        bufferSize: number,
+        lock: AutoResetEvent
+    ) {
+        this._writer = writer;
+        this._readable = readable;
+        this._socketLock = lock;
+        this._combiner = new BufferCombiner(bufferSize);
+    }
+
+    private async writeInnerStream(buffer: Uint8Array) {
+        await ConsumableWritableStream.write(this._writer, buffer);
+    }
+
+    public async flush() {
+        try {
+            await this._writeLock.wait();
+            const buffer = this._combiner.flush();
+            if (buffer) {
+                await this.writeInnerStream(buffer);
+            }
+        } finally {
+            this._writeLock.notifyOne();
+        }
+    }
+
+    public async write(data: Uint8Array) {
+        try {
+            await this._writeLock.wait();
+            for (const buffer of this._combiner.push(data)) {
+                await this.writeInnerStream(buffer);
+            }
+        } finally {
+            this._writeLock.notifyOne();
+        }
+    }
+
+    public async read(length: number) {
+        await this.flush();
+        return await this._readable.read(length);
+    }
+
+    public release(): void {
+        this._combiner.flush();
+        this._socketLock.notifyOne();
+    }
+}
+
+export class AdbSyncSocket {
+    private _lock = new AutoResetEvent();
+    private _socket: AdbSocket;
+    private _locked: AdbSyncSocketLocked;
+
+    public constructor(socket: AdbSocket, bufferSize: number) {
+        this._socket = socket;
+        this._locked = new AdbSyncSocketLocked(
+            socket.writable.getWriter(),
+            new BufferedReadableStream(socket.readable),
+            bufferSize,
+            this._lock
+        );
+    }
+
+    public async lock() {
+        await this._lock.wait();
+        return this._locked;
+    }
+
+    public async close() {
+        await this._socket.close();
+    }
+}