@yume-chan/adb 0.0.16 → 0.0.18

package/src/commands/sync/response.ts

@@ -1,64 +1,74 @@
-import Struct, { type StructAsyncDeserializeStream, type StructLike, type StructValueType } from '@yume-chan/struct';
-import type { AdbBufferedStream } from '../../stream/index.js';
+import { type BufferedReadableStream } from "@yume-chan/stream-extra";
+import Struct, {
+    type StructLike,
+    type StructValueType,
+} from "@yume-chan/struct";
+
 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",
 }
 
-// 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;
+export const AdbSyncFailResponse = new Struct({ littleEndian: true })
+    .uint32("messageLength")
+    .string("message", { lengthField: "messageLength" })
+    .postDeserialize((object) => {
+        throw new Error(object.message);
+    });
 
-    public constructor(length: number) {
-        this.length = length;
-    }
-
-    public async deserialize(stream: StructAsyncDeserializeStream): Promise<this> {
-        await stream.read(this.length);
-        return this;
+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}'`);
     }
 }
 
-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 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);
-    }
-
-    if (types[id]) {
-        return types[id]!.deserialize(stream);
+export async function* adbSyncReadResponses<
+    T extends Struct<object, PropertyKey, object, 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,7 +1,11 @@
-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';
+import {
+    type BufferedReadableStream,
+    type WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
+import Struct, { placeholder } from "@yume-chan/struct";
+
+import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
+import { AdbSyncResponseId, adbSyncReadResponse } from "./response.js";
 
 // https://github.com/python/cpython/blob/4e581d64b8aff3e2eda99b12f080c877bb78dfca/Lib/stat.py#L36
 export enum LinuxFileType {
@@ -23,27 +27,27 @@ export interface AdbSyncStat {
     ctime?: bigint;
 }
 
-export const AdbSyncLstatResponse =
-    new Struct({ littleEndian: true })
-        .int32('mode')
-        .int32('size')
-        .int32('mtime')
-        .extra({
-            id: AdbSyncResponseId.Lstat as const,
-            get type() { return this.mode >> 12 as LinuxFileType; },
-            get permission() { return this.mode & 0b00001111_11111111; },
-        })
-        .postDeserialize((object) => {
-            if (
-                object.mode === 0 &&
-                object.size === 0 &&
-                object.mtime === 0
-            ) {
-                throw new Error('lstat failed');
-            }
-        });
-
-export type AdbSyncLstatResponse = typeof AdbSyncLstatResponse['TDeserializeResult'];
+export const AdbSyncLstatResponse = new Struct({ littleEndian: true })
+    .int32("mode")
+    .int32("size")
+    .int32("mtime")
+    .extra({
+        id: AdbSyncResponseId.Lstat as const,
+        get type() {
+            return (this.mode >> 12) as LinuxFileType;
+        },
+        get permission() {
+            return this.mode & 0b00001111_11111111;
+        },
+    })
+    .postDeserialize((object) => {
+        if (object.mode === 0 && object.size === 0 && object.mtime === 0) {
+            throw new Error("lstat error");
+        }
+    });
+
+export type AdbSyncLstatResponse =
+    typeof AdbSyncLstatResponse["TDeserializeResult"];
 
 export enum AdbSyncStatErrorCode {
     SUCCESS = 0,
@@ -69,83 +73,80 @@ export enum AdbSyncStatErrorCode {
     ETXTBSY = 26,
 }
 
-export const AdbSyncStatResponse =
-    new Struct({ littleEndian: true })
-        .uint32('error', placeholder<AdbSyncStatErrorCode>())
-        .uint64('dev')
-        .uint64('ino')
-        .uint32('mode')
-        .uint32('nlink')
-        .uint32('uid')
-        .uint32('gid')
-        .uint64('size')
-        .uint64('atime')
-        .uint64('mtime')
-        .uint64('ctime')
-        .extra({
-            id: AdbSyncResponseId.Stat as const,
-            get type() { return this.mode >> 12 as LinuxFileType; },
-            get permission() { return this.mode & 0b00001111_11111111; },
-        })
-        .postDeserialize((object) => {
-            if (object.error) {
-                throw new Error(AdbSyncStatErrorCode[object.error]);
-            }
-        });
-
-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 const AdbSyncStatResponse = new Struct({ littleEndian: true })
+    .uint32("error", placeholder<AdbSyncStatErrorCode>())
+    .uint64("dev")
+    .uint64("ino")
+    .uint32("mode")
+    .uint32("nlink")
+    .uint32("uid")
+    .uint32("gid")
+    .uint64("size")
+    .uint64("atime")
+    .uint64("mtime")
+    .uint64("ctime")
+    .extra({
+        id: AdbSyncResponseId.Stat as const,
+        get type() {
+            return (this.mode >> 12) as LinuxFileType;
+        },
+        get permission() {
+            return this.mode & 0b00001111_11111111;
+        },
+    })
+    .postDeserialize((object) => {
+        if (object.error) {
+            throw new Error(AdbSyncStatErrorCode[object.error]);
+        }
+    });
+
+export type AdbSyncStatResponse =
+    typeof AdbSyncStatResponse["TDeserializeResult"];
 
 export async function adbSyncLstat(
-    stream: AdbBufferedStream,
+    stream: BufferedReadableStream,
     writer: WritableStreamDefaultWriter<Uint8Array>,
     path: string,
-    v2: boolean,
+    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,
+    path: string
 ): Promise<AdbSyncStatResponse> {
     await adbSyncWriteRequest(writer, AdbSyncRequestId.Stat, path);
-    return await adbSyncReadResponse(stream, STAT_RESPONSE_TYPES);
+    return await adbSyncReadResponse(
+        stream,
+        AdbSyncResponseId.Stat,
+        AdbSyncStatResponse
+    );
 }

package/src/commands/sync/sync.ts

@@ -1,14 +1,23 @@
-import { AutoDisposable } from '@yume-chan/event';
-import type { Adb } from '../../adb.js';
-import { AdbFeatures } from '../../features.js';
-import type { AdbSocket } from '../../socket/index.js';
-import { AdbBufferedStream, ReadableStream, WrapReadableStream, WrapWritableStream, WritableStream, WritableStreamDefaultWriter } from '../../stream/index.js';
-import { AutoResetEvent } from '../../utils/index.js';
-import { escapeArg } from "../index.js";
-import { adbSyncOpenDir, type AdbSyncEntry } from './list.js';
-import { adbSyncPull } from './pull.js';
-import { adbSyncPush } from './push.js';
-import { adbSyncLstat, adbSyncStat } from './stat.js';
+import { AutoDisposable } from "@yume-chan/event";
+import {
+    BufferedReadableStream,
+    WrapReadableStream,
+    WrapWritableStream,
+    type ReadableStream,
+    type WritableStream,
+    type WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
+
+import { type Adb } from "../../adb.js";
+import { AdbFeatures } from "../../features.js";
+import { type AdbSocket } from "../../socket/index.js";
+import { AutoResetEvent } from "../../utils/index.js";
+import { escapeArg } from "../subprocess/index.js";
+
+import { adbSyncOpenDir, type AdbSyncEntry } from "./list.js";
+import { adbSyncPull } from "./pull.js";
+import { adbSyncPush } from "./push.js";
+import { adbSyncLstat, adbSyncStat } from "./stat.js";
 
 /**
  * A simplified `dirname` function that only handles absolute unix paths.
@@ -16,12 +25,12 @@ import { adbSyncLstat, adbSyncStat } from './stat.js';
  * @returns the directory name of the input path
  */
 export function dirname(path: string): string {
-    const end = path.lastIndexOf('/');
+    const end = path.lastIndexOf("/");
     if (end === -1) {
         throw new Error(`Invalid path`);
     }
     if (end === 0) {
-        return '/';
+        return "/";
     }
     return path.substring(0, end);
 }
@@ -29,34 +38,38 @@ export function dirname(path: string): string {
 export class AdbSync extends AutoDisposable {
     protected adb: Adb;
 
-    protected stream: AdbBufferedStream;
-
+    protected stream: BufferedReadableStream;
+    // Getting another writer on a locked WritableStream will throw.
+    // We don't want this behavior on higher-level APIs.
+    // So we acquire the writer early and use a blocking lock to guard it.
     protected writer: WritableStreamDefaultWriter<Uint8Array>;
-
     protected sendLock = this.addDisposable(new AutoResetEvent());
 
     public get supportsStat(): boolean {
-        return this.adb.features!.includes(AdbFeatures.StatV2);
+        return this.adb.features.includes(AdbFeatures.StatV2);
     }
 
     public get supportsList2(): boolean {
-        return this.adb.features!.includes(AdbFeatures.ListV2);
+        return this.adb.features.includes(AdbFeatures.ListV2);
     }
 
     public get fixedPushMkdir(): boolean {
-        return this.adb.features!.includes(AdbFeatures.FixedPushMkdir);
+        return this.adb.features.includes(AdbFeatures.FixedPushMkdir);
     }
 
     public get needPushMkdirWorkaround(): boolean {
         // https://android.googlesource.com/platform/packages/modules/adb/+/91768a57b7138166e0a3d11f79cd55909dda7014/client/file_sync_client.cpp#1361
-        return this.adb.features!.includes(AdbFeatures.ShellV2) && !this.fixedPushMkdir;
+        return (
+            this.adb.features.includes(AdbFeatures.ShellV2) &&
+            !this.fixedPushMkdir
+        );
     }
 
     public constructor(adb: Adb, socket: AdbSocket) {
         super();
 
         this.adb = adb;
-        this.stream = new AdbBufferedStream(socket);
+        this.stream = new BufferedReadableStream(socket.readable);
         this.writer = socket.writable.getWriter();
     }
 
@@ -64,7 +77,12 @@ export class AdbSync extends AutoDisposable {
         await this.sendLock.wait();
 
         try {
-            return adbSyncLstat(this.stream, this.writer, path, this.supportsStat);
+            return adbSyncLstat(
+                this.stream,
+                this.writer,
+                path,
+                this.supportsStat
+            );
         } finally {
             this.sendLock.notify();
         }
@@ -72,7 +90,7 @@ export class AdbSync extends AutoDisposable {
 
     public async stat(path: string) {
         if (!this.supportsStat) {
-            throw new Error('Not supported');
+            throw new Error("Not supported");
         }
 
         await this.sendLock.wait();
@@ -86,7 +104,7 @@ export class AdbSync extends AutoDisposable {
 
     public async isDirectory(path: string): Promise<boolean> {
         try {
-            await this.lstat(path + '/');
+            await this.lstat(path + "/");
             return true;
         } catch (e) {
             return false;
@@ -99,7 +117,12 @@ export class AdbSync extends AutoDisposable {
         await this.sendLock.wait();
 
         try {
-            yield* adbSyncOpenDir(this.stream, this.writer, path, this.supportsList2);
+            yield* adbSyncOpenDir(
+                this.stream,
+                this.writer,
+                path,
+                this.supportsList2
+            );
         } finally {
             this.sendLock.notify();
         }
@@ -125,7 +148,7 @@ export class AdbSync extends AutoDisposable {
                 await this.sendLock.wait();
                 return adbSyncPull(this.stream, this.writer, filename);
             },
-            close: async () => {
+            close: () => {
                 this.sendLock.notify();
             },
         });
@@ -142,7 +165,7 @@ export class AdbSync extends AutoDisposable {
     public write(
         filename: string,
         mode?: number,
-        mtime?: number,
+        mtime?: number
     ): WritableStream<Uint8Array> {
         return new WrapWritableStream({
             start: async () => {
@@ -151,10 +174,10 @@ export class AdbSync extends AutoDisposable {
                 if (this.needPushMkdirWorkaround) {
                     // It may fail if the path is already existed.
                     // Ignore the result.
-                    // TODO: sync: test this
+                    // TODO: sync: test push mkdir workaround (need an Android 8 device)
                     await this.adb.subprocess.spawnAndWait([
-                        'mkdir',
-                        '-p',
+                        "mkdir",
+                        "-p",
                         escapeArg(dirname(filename)),
                     ]);
                 }
@@ -164,18 +187,17 @@ export class AdbSync extends AutoDisposable {
                     this.writer,
                     filename,
                     mode,
-                    mtime,
+                    mtime
                 );
             },
-            close: async () => {
+            close: () => {
                 this.sendLock.notify();
-            }
+            },
         });
     }
 
     public override async dispose() {
         super.dispose();
-        await this.stream.close();
         await this.writer.close();
     }
 }