@yume-chan/adb 0.0.9 → 0.0.12

package/src/commands/sync/stat.ts

@@ -1,121 +1,123 @@
-import Struct, { placeholder } from '@yume-chan/struct';
-import { AdbBufferedStream } from '../../stream';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request';
-import { adbSyncReadResponse, AdbSyncResponseId } from './response';
-
-// https://github.com/python/cpython/blob/4e581d64b8aff3e2eda99b12f080c877bb78dfca/Lib/stat.py#L36
-export enum LinuxFileType {
-    Directory = 0o04,
-    File = 0o10,
-    Link = 0o12,
-}
-
-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 {
-    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 StatResponseType = {
-    [AdbSyncResponseId.Stat]: AdbSyncStatResponse,
-};
-
-const LstatResponseType = {
-    [AdbSyncResponseId.Lstat]: AdbSyncLstatResponse,
-};
-
-const Lstat2ResponseType = {
-    [AdbSyncResponseId.Lstat2]: AdbSyncStatResponse,
-};
-
-export async function adbSyncLstat(
-    stream: AdbBufferedStream,
-    path: string,
-    v2: boolean,
-): Promise<AdbSyncLstatResponse | AdbSyncStatResponse> {
-    let requestId: AdbSyncRequestId.Lstat | AdbSyncRequestId.Lstat2;
-    let responseType: typeof LstatResponseType | typeof Lstat2ResponseType;
-
-    if (v2) {
-        requestId = AdbSyncRequestId.Lstat2;
-        responseType = Lstat2ResponseType;
-    } else {
-        requestId = AdbSyncRequestId.Lstat;
-        responseType = LstatResponseType;
-    }
-
-    await adbSyncWriteRequest(stream, requestId, path);
-    return adbSyncReadResponse(stream, responseType);
-}
-
-export async function adbSyncStat(
-    stream: AdbBufferedStream,
-    path: string,
-): Promise<AdbSyncStatResponse> {
-    await adbSyncWriteRequest(stream, AdbSyncRequestId.Stat, path);
-    return adbSyncReadResponse(stream, StatResponseType);
-}
+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 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 {
+    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 StatResponseType = {
+    [AdbSyncResponseId.Stat]: AdbSyncStatResponse,
+};
+
+const LstatResponseType = {
+    [AdbSyncResponseId.Lstat]: AdbSyncLstatResponse,
+};
+
+const Lstat2ResponseType = {
+    [AdbSyncResponseId.Lstat2]: AdbSyncStatResponse,
+};
+
+export async function adbSyncLstat(
+    stream: AdbBufferedStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
+    path: string,
+    v2: boolean,
+): Promise<AdbSyncLstatResponse | AdbSyncStatResponse> {
+    let requestId: AdbSyncRequestId.Lstat | AdbSyncRequestId.Lstat2;
+    let responseType: typeof LstatResponseType | typeof Lstat2ResponseType;
+
+    if (v2) {
+        requestId = AdbSyncRequestId.Lstat2;
+        responseType = Lstat2ResponseType;
+    } else {
+        requestId = AdbSyncRequestId.Lstat;
+        responseType = LstatResponseType;
+    }
+
+    await adbSyncWriteRequest(writer, requestId, path);
+    return adbSyncReadResponse(stream, responseType);
+}
+
+export async function adbSyncStat(
+    stream: AdbBufferedStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
+    path: string,
+): Promise<AdbSyncStatResponse> {
+    await adbSyncWriteRequest(writer, AdbSyncRequestId.Stat, path);
+    return await adbSyncReadResponse(stream, StatResponseType);
+}

package/src/commands/sync/sync.ts

@@ -1,113 +1,145 @@
-import { AutoDisposable } from '@yume-chan/event';
-import { Adb } from '../../adb';
-import { AdbFeatures } from '../../features';
-import { AdbSocket } from '../../socket';
-import { AdbBufferedStream } from '../../stream';
-import { AutoResetEvent } from '../../utils';
-import { AdbSyncEntryResponse, adbSyncOpenDir } from './list';
-import { adbSyncPull } from './pull';
-import { adbSyncPush } from './push';
-import { adbSyncLstat, adbSyncStat } from './stat';
-
-export class AdbSync extends AutoDisposable {
-    protected adb: Adb;
-
-    protected stream: AdbBufferedStream;
-
-    protected sendLock = this.addDisposable(new AutoResetEvent());
-
-    public get supportsStat(): boolean {
-        return this.adb.features!.includes(AdbFeatures.StatV2);
-    }
-
-    public constructor(adb: Adb, socket: AdbSocket) {
-        super();
-
-        this.adb = adb;
-        this.stream = new AdbBufferedStream(socket);
-    }
-
-    public async lstat(path: string) {
-        await this.sendLock.wait();
-
-        try {
-            return adbSyncLstat(this.stream, 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, 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<AdbSyncEntryResponse, void, void> {
-        await this.sendLock.wait();
-
-        try {
-            yield* adbSyncOpenDir(this.stream, path);
-        } finally {
-            this.sendLock.notify();
-        }
-    }
-
-    public async readdir(path: string) {
-        const results: AdbSyncEntryResponse[] = [];
-        for await (const entry of this.opendir(path)) {
-            results.push(entry);
-        }
-        return results;
-    }
-
-    public async *read(filename: string): AsyncGenerator<ArrayBuffer, void, void> {
-        await this.sendLock.wait();
-
-        try {
-            yield* adbSyncPull(this.stream, filename);
-        } finally {
-            this.sendLock.notify();
-        }
-    }
-
-    public async write(
-        filename: string,
-        content: ArrayLike<number> | ArrayBufferLike | AsyncIterable<ArrayBuffer>,
-        mode?: number,
-        mtime?: number,
-        onProgress?: (uploaded: number) => void,
-    ): Promise<void> {
-        await this.sendLock.wait();
-
-        try {
-            await adbSyncPush(this.stream, filename, content, mode, mtime, undefined, onProgress);
-        } finally {
-            this.sendLock.notify();
-        }
-    }
-
-    public dispose() {
-        super.dispose();
-        this.stream.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 { AdbSyncEntryResponse, adbSyncOpenDir } from './list.js';
+import { adbSyncPull } from './pull.js';
+import { adbSyncPush } from './push.js';
+import { adbSyncLstat, adbSyncStat } from './stat.js';
+
+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 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<AdbSyncEntryResponse, void, void> {
+        await this.sendLock.wait();
+
+        try {
+            yield* adbSyncOpenDir(this.stream, this.writer, path);
+        } finally {
+            this.sendLock.notify();
+        }
+    }
+
+    public async readdir(path: string) {
+        const results: AdbSyncEntryResponse[] = [];
+        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<Uint8Array, ReadableStream<Uint8Array>, undefined>({
+            start: async () => {
+                await this.sendLock.wait();
+                return {
+                    readable: adbSyncPull(this.stream, this.writer, filename),
+                    state: undefined,
+                };
+            },
+            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();
+                return {
+                    writable: adbSyncPush(
+                        this.stream,
+                        this.writer,
+                        filename,
+                        mode,
+                        mtime,
+                    ),
+                    state: undefined,
+                };
+            },
+            close: async () => {
+                this.sendLock.notify();
+            }
+        });
+    }
+
+    public override async dispose() {
+        super.dispose();
+        this.stream.close();
+        await this.writer.close();
+    }
+}

package/src/commands/tcpip.ts

@@ -1,21 +1,21 @@
-import { AdbCommandBase } from './base';
-
-export class AdbTcpIpCommand extends AdbCommandBase {
-    public async setPort(port: number): Promise<void> {
-        if (port <= 0) {
-            throw new Error(`Invalid port ${port}`);
-        }
-
-        const output = await this.adb.createSocketAndReadAll(`tcpip:${port}`);
-        if (output !== `restarting in TCP mode port: ${port}\n`) {
-            throw new Error('Invalid response');
-        }
-    }
-
-    public async disable(): Promise<void> {
-        const output = await this.adb.createSocketAndReadAll('usb:');
-        if (output !== 'restarting in USB mode\n') {
-            throw new Error('Invalid response');
-        }
-    }
-}
+import { AdbCommandBase } from './base.js';
+
+export class AdbTcpIpCommand extends AdbCommandBase {
+    public async setPort(port: number): Promise<void> {
+        if (port <= 0) {
+            throw new Error(`Invalid port ${port}`);
+        }
+
+        const output = await this.adb.createSocketAndWait(`tcpip:${port}`);
+        if (output !== `restarting in TCP mode port: ${port}\n`) {
+            throw new Error('Invalid response');
+        }
+    }
+
+    public async disable(): Promise<void> {
+        const output = await this.adb.createSocketAndWait('usb:');
+        if (output !== 'restarting in USB mode\n') {
+            throw new Error('Invalid response');
+        }
+    }
+}