@yume-chan/adb 0.0.13 → 0.0.16

package/src/commands/sync/stat.ts

@@ -1,150 +1,151 @@
-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';
-
-// https://github.com/python/cpython/blob/4e581d64b8aff3e2eda99b12f080c877bb78dfca/Lib/stat.py#L36
-export enum LinuxFileType {
-    Directory = 0o04,
-    File = 0o10,
-    Link = 0o12,
-}
-
-export interface AdbSyncStat {
-    mode: number;
-    size: bigint;
-    mtime: bigint;
-    get type(): LinuxFileType;
-    get permission(): number;
-
-    uid?: number;
-    gid?: number;
-    atime?: bigint;
-    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 enum AdbSyncStatErrorCode {
-    SUCCESS = 0,
-    EACCES = 13,
-    EEXIST = 17,
-    EFAULT = 14,
-    EFBIG = 27,
-    EINTR = 4,
-    EINVAL = 22,
-    EIO = 5,
-    EISDIR = 21,
-    ELOOP = 40,
-    EMFILE = 24,
-    ENAMETOOLONG = 36,
-    ENFILE = 23,
-    ENOENT = 2,
-    ENOMEM = 12,
-    ENOSPC = 28,
-    ENOTDIR = 20,
-    EOVERFLOW = 75,
-    EPERM = 1,
-    EROFS = 30,
-    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 async function adbSyncLstat(
-    stream: AdbBufferedStream,
-    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;
-    } 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;
-    }
-}
-
-export async function adbSyncStat(
-    stream: AdbBufferedStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
-    path: string,
-): Promise<AdbSyncStatResponse> {
-    await adbSyncWriteRequest(writer, AdbSyncRequestId.Stat, path);
-    return await adbSyncReadResponse(stream, STAT_RESPONSE_TYPES);
-}
+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';
+
+// https://github.com/python/cpython/blob/4e581d64b8aff3e2eda99b12f080c877bb78dfca/Lib/stat.py#L36
+export enum LinuxFileType {
+    Directory = 0o04,
+    File = 0o10,
+    Link = 0o12,
+}
+
+export interface AdbSyncStat {
+    mode: number;
+    size: bigint;
+    mtime: bigint;
+    get type(): LinuxFileType;
+    get permission(): number;
+
+    uid?: number;
+    gid?: number;
+    atime?: bigint;
+    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 enum AdbSyncStatErrorCode {
+    SUCCESS = 0,
+    EACCES = 13,
+    EEXIST = 17,
+    EFAULT = 14,
+    EFBIG = 27,
+    EINTR = 4,
+    EINVAL = 22,
+    EIO = 5,
+    EISDIR = 21,
+    ELOOP = 40,
+    EMFILE = 24,
+    ENAMETOOLONG = 36,
+    ENFILE = 23,
+    ENOENT = 2,
+    ENOMEM = 12,
+    ENOSPC = 28,
+    ENOTDIR = 20,
+    EOVERFLOW = 75,
+    EPERM = 1,
+    EROFS = 30,
+    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 async function adbSyncLstat(
+    stream: AdbBufferedStream,
+    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;
+    } 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;
+    }
+}
+
+export async function adbSyncStat(
+    stream: AdbBufferedStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
+    path: string,
+): Promise<AdbSyncStatResponse> {
+    await adbSyncWriteRequest(writer, AdbSyncRequestId.Stat, path);
+    return await adbSyncReadResponse(stream, STAT_RESPONSE_TYPES);
+}

package/src/commands/sync/sync.ts

@@ -1,181 +1,181 @@
-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';
-
-/**
- * A simplified `dirname` function that only handles absolute unix paths.
- * @param path an absolute unix path
- * @returns the directory name of the input path
- */
-export function dirname(path: string): string {
-    const end = path.lastIndexOf('/');
-    if (end === -1) {
-        throw new Error(`Invalid path`);
-    }
-    if (end === 0) {
-        return '/';
-    }
-    return path.substring(0, end);
-}
-
-export class AdbSync extends AutoDisposable {
-    protected adb: Adb;
-
-    protected stream: AdbBufferedStream;
-
-    protected writer: WritableStreamDefaultWriter<Uint8Array>;
-
-    protected sendLock = this.addDisposable(new AutoResetEvent());
-
-    public get supportsStat(): boolean {
-        return this.adb.features!.includes(AdbFeatures.StatV2);
-    }
-
-    public get supportsList2(): boolean {
-        return this.adb.features!.includes(AdbFeatures.ListV2);
-    }
-
-    public get fixedPushMkdir(): boolean {
-        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;
-    }
-
-    public constructor(adb: Adb, socket: AdbSocket) {
-        super();
-
-        this.adb = adb;
-        this.stream = new AdbBufferedStream(socket);
-        this.writer = socket.writable.getWriter();
-    }
-
-    public async lstat(path: string) {
-        await this.sendLock.wait();
-
-        try {
-            return adbSyncLstat(this.stream, this.writer, path, this.supportsStat);
-        } finally {
-            this.sendLock.notify();
-        }
-    }
-
-    public async stat(path: string) {
-        if (!this.supportsStat) {
-            throw new Error('Not supported');
-        }
-
-        await this.sendLock.wait();
-
-        try {
-            return adbSyncStat(this.stream, this.writer, path);
-        } finally {
-            this.sendLock.notify();
-        }
-    }
-
-    public async isDirectory(path: string): Promise<boolean> {
-        try {
-            await this.lstat(path + '/');
-            return true;
-        } catch (e) {
-            return false;
-        }
-    }
-
-    public async *opendir(
-        path: string
-    ): AsyncGenerator<AdbSyncEntry, void, void> {
-        await this.sendLock.wait();
-
-        try {
-            yield* adbSyncOpenDir(this.stream, this.writer, path, this.supportsList2);
-        } finally {
-            this.sendLock.notify();
-        }
-    }
-
-    public async readdir(path: string) {
-        const results: AdbSyncEntry[] = [];
-        for await (const entry of this.opendir(path)) {
-            results.push(entry);
-        }
-        return results;
-    }
-
-    /**
-     * Read the content of a file on device.
-     *
-     * @param filename The full path of the file on device to read.
-     * @returns A `ReadableStream` that reads from the file.
-     */
-    public read(filename: string): ReadableStream<Uint8Array> {
-        return new WrapReadableStream({
-            start: async () => {
-                await this.sendLock.wait();
-                return adbSyncPull(this.stream, this.writer, filename);
-            },
-            close: async () => {
-                this.sendLock.notify();
-            },
-        });
-    }
-
-    /**
-     * Write (or overwrite) a file on device.
-     *
-     * @param filename The full path of the file on device to write.
-     * @param mode The unix permissions of the file.
-     * @param mtime The modified time of the file.
-     * @returns A `WritableStream` that writes to the file.
-     */
-    public write(
-        filename: string,
-        mode?: number,
-        mtime?: number,
-    ): WritableStream<Uint8Array> {
-        return new WrapWritableStream({
-            start: async () => {
-                await this.sendLock.wait();
-
-                if (this.needPushMkdirWorkaround) {
-                    // It may fail if the path is already existed.
-                    // Ignore the result.
-                    // TODO: sync: test this
-                    await this.adb.subprocess.spawnAndWait([
-                        'mkdir',
-                        '-p',
-                        escapeArg(dirname(filename)),
-                    ]);
-                }
-
-                return adbSyncPush(
-                    this.stream,
-                    this.writer,
-                    filename,
-                    mode,
-                    mtime,
-                );
-            },
-            close: async () => {
-                this.sendLock.notify();
-            }
-        });
-    }
-
-    public override async dispose() {
-        super.dispose();
-        this.stream.close();
-        await this.writer.close();
-    }
-}
+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';
+
+/**
+ * A simplified `dirname` function that only handles absolute unix paths.
+ * @param path an absolute unix path
+ * @returns the directory name of the input path
+ */
+export function dirname(path: string): string {
+    const end = path.lastIndexOf('/');
+    if (end === -1) {
+        throw new Error(`Invalid path`);
+    }
+    if (end === 0) {
+        return '/';
+    }
+    return path.substring(0, end);
+}
+
+export class AdbSync extends AutoDisposable {
+    protected adb: Adb;
+
+    protected stream: AdbBufferedStream;
+
+    protected writer: WritableStreamDefaultWriter<Uint8Array>;
+
+    protected sendLock = this.addDisposable(new AutoResetEvent());
+
+    public get supportsStat(): boolean {
+        return this.adb.features!.includes(AdbFeatures.StatV2);
+    }
+
+    public get supportsList2(): boolean {
+        return this.adb.features!.includes(AdbFeatures.ListV2);
+    }
+
+    public get fixedPushMkdir(): boolean {
+        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;
+    }
+
+    public constructor(adb: Adb, socket: AdbSocket) {
+        super();
+
+        this.adb = adb;
+        this.stream = new AdbBufferedStream(socket);
+        this.writer = socket.writable.getWriter();
+    }
+
+    public async lstat(path: string) {
+        await this.sendLock.wait();
+
+        try {
+            return adbSyncLstat(this.stream, this.writer, path, this.supportsStat);
+        } finally {
+            this.sendLock.notify();
+        }
+    }
+
+    public async stat(path: string) {
+        if (!this.supportsStat) {
+            throw new Error('Not supported');
+        }
+
+        await this.sendLock.wait();
+
+        try {
+            return adbSyncStat(this.stream, this.writer, path);
+        } finally {
+            this.sendLock.notify();
+        }
+    }
+
+    public async isDirectory(path: string): Promise<boolean> {
+        try {
+            await this.lstat(path + '/');
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    public async *opendir(
+        path: string
+    ): AsyncGenerator<AdbSyncEntry, void, void> {
+        await this.sendLock.wait();
+
+        try {
+            yield* adbSyncOpenDir(this.stream, this.writer, path, this.supportsList2);
+        } finally {
+            this.sendLock.notify();
+        }
+    }
+
+    public async readdir(path: string) {
+        const results: AdbSyncEntry[] = [];
+        for await (const entry of this.opendir(path)) {
+            results.push(entry);
+        }
+        return results;
+    }
+
+    /**
+     * Read the content of a file on device.
+     *
+     * @param filename The full path of the file on device to read.
+     * @returns A `ReadableStream` that reads from the file.
+     */
+    public read(filename: string): ReadableStream<Uint8Array> {
+        return new WrapReadableStream({
+            start: async () => {
+                await this.sendLock.wait();
+                return adbSyncPull(this.stream, this.writer, filename);
+            },
+            close: async () => {
+                this.sendLock.notify();
+            },
+        });
+    }
+
+    /**
+     * Write (or overwrite) a file on device.
+     *
+     * @param filename The full path of the file on device to write.
+     * @param mode The unix permissions of the file.
+     * @param mtime The modified time of the file.
+     * @returns A `WritableStream` that writes to the file.
+     */
+    public write(
+        filename: string,
+        mode?: number,
+        mtime?: number,
+    ): WritableStream<Uint8Array> {
+        return new WrapWritableStream({
+            start: async () => {
+                await this.sendLock.wait();
+
+                if (this.needPushMkdirWorkaround) {
+                    // It may fail if the path is already existed.
+                    // Ignore the result.
+                    // TODO: sync: test this
+                    await this.adb.subprocess.spawnAndWait([
+                        'mkdir',
+                        '-p',
+                        escapeArg(dirname(filename)),
+                    ]);
+                }
+
+                return adbSyncPush(
+                    this.stream,
+                    this.writer,
+                    filename,
+                    mode,
+                    mtime,
+                );
+            },
+            close: async () => {
+                this.sendLock.notify();
+            }
+        });
+    }
+
+    public override async dispose() {
+        super.dispose();
+        await this.stream.close();
+        await this.writer.close();
+    }
+}