@yume-chan/adb 0.0.15 → 0.0.17

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

@@ -1,59 +1,60 @@
-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 `AdbSubprocessProtocol` 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 `AdbSubprocessProtocol` doesn't support exit code,
-     * They will always resolve it with `0`.
-     */
-    readonly exit: Promise<number>;
-
-    /**
-     * Resizes the current shell.
-     *
-     * Some `AdbSubprocessProtocol`s may not support resizing
-     * and will 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>;
-
-    /** Spawns an executable in PTY (interactive) mode. */
-    pty(adb: Adb, command: string): ValueOrPromise<AdbSubprocessProtocol>;
-
-    /** Spawns an executable and pipe the output. */
-    raw(adb: Adb, command: string): ValueOrPromise<AdbSubprocessProtocol>;
-
-    /** Creates a new `AdbShell` by attaching to an exist `AdbSocket` */
-    new(socket: AdbSocket): AdbSubprocessProtocol;
-}
+import type { ReadableStream, WritableStream } from '@yume-chan/stream-extra';
+import type { ValueOrPromise } from '@yume-chan/struct';
+
+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>;
+
+    /**
+     * The `stdout` stream of the process.
+     */
+    readonly stdout: ReadableStream<Uint8Array>;
+
+    /**
+     * The `stderr` stream of the process.
+     *
+     * Note: Some `AdbSubprocessProtocol` 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 `AdbSubprocessProtocol` doesn't support exit code,
+     * They will always resolve it with `0`.
+     */
+    readonly exit: Promise<number>;
+
+    /**
+     * Resizes the current shell.
+     *
+     * Some `AdbSubprocessProtocol`s may not support resizing
+     * and will 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>;
+
+    /** Spawns an executable in PTY (interactive) mode. */
+    pty(adb: Adb, command: string): ValueOrPromise<AdbSubprocessProtocol>;
+
+    /** Spawns an executable and pipe the output. */
+    raw(adb: Adb, command: string): ValueOrPromise<AdbSubprocessProtocol>;
+
+    /** Creates a new `AdbShell` by attaching to an exist `AdbSocket` */
+    new(socket: AdbSocket): AdbSubprocessProtocol;
+}

package/src/commands/subprocess/utils.ts

@@ -1,20 +1,20 @@
-export function escapeArg(s: string) {
-    let result = '';
-    result += `'`;
-
-    let base = 0;
-    while (true) {
-        const found = s.indexOf(`'`, base);
-        if (found === -1) {
-            result += s.substring(base);
-            break;
-        }
-        result += s.substring(base, found);
-        // a'b becomes a'\'b
-        result += String.raw`'\''`;
-        base = found + 1;
-    }
-
-    result += `'`;
-    return result;
-}
+export function escapeArg(s: string) {
+    let result = '';
+    result += `'`;
+
+    let base = 0;
+    while (true) {
+        const found = s.indexOf(`'`, base);
+        if (found === -1) {
+            result += s.substring(base);
+            break;
+        }
+        result += s.substring(base, found);
+        // a'b becomes a'\'b
+        result += String.raw`'\''`;
+        base = found + 1;
+    }
+
+    result += `'`;
+    return result;
+}

package/src/commands/sync/index.ts

@@ -1,7 +1,7 @@
-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';
+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';

package/src/commands/sync/list.ts

@@ -1,86 +1,54 @@
-import Struct from '@yume-chan/struct';
-import type { AdbBufferedStream, WritableStreamDefaultWriter } from '../../stream/index.js';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
-import { AdbSyncDoneResponse, adbSyncReadResponse, AdbSyncResponseId } from './response.js';
-import { AdbSyncLstatResponse, AdbSyncStatResponse, type AdbSyncStat } from './stat.js';
-
-export interface AdbSyncEntry extends AdbSyncStat {
-    name: string;
-}
-
-export const AdbSyncEntryResponse =
-    new Struct({ littleEndian: true })
-        .fields(AdbSyncLstatResponse)
-        .uint32('nameLength')
-        .string('name', { lengthField: 'nameLength' })
-        .extra({ id: AdbSyncResponseId.Entry as const });
-
-export type AdbSyncEntryResponse = typeof AdbSyncEntryResponse['TDeserializeResult'];
-
-export const AdbSyncEntry2Response =
-    new Struct({ littleEndian: true })
-        .fields(AdbSyncStatResponse)
-        .uint32('nameLength')
-        .string('name', { lengthField: 'nameLength' })
-        .extra({ id: AdbSyncResponseId.Entry2 as const });
-
-export type AdbSyncEntry2Response = typeof AdbSyncEntry2Response['TDeserializeResult'];
-
-const LIST_V1_RESPONSE_TYPES = {
-    [AdbSyncResponseId.Entry]: AdbSyncEntryResponse,
-    [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncEntryResponse.size),
-};
-
-const LIST_V2_RESPONSE_TYPES = {
-    [AdbSyncResponseId.Entry2]: AdbSyncEntry2Response,
-    [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncEntry2Response.size),
-};
-
-export async function* adbSyncOpenDir(
-    stream: AdbBufferedStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
-    path: string,
-    v2: boolean,
-): AsyncGenerator<AdbSyncEntry, void, void> {
-    let requestId: AdbSyncRequestId.List | AdbSyncRequestId.List2;
-    let responseType: typeof LIST_V1_RESPONSE_TYPES | typeof LIST_V2_RESPONSE_TYPES;
-
-    if (v2) {
-        requestId = AdbSyncRequestId.List2;
-        responseType = LIST_V2_RESPONSE_TYPES;
-    } else {
-        requestId = AdbSyncRequestId.List;
-        responseType = LIST_V1_RESPONSE_TYPES;
-    }
-
-    await adbSyncWriteRequest(writer, requestId, path);
-
-    while (true) {
-        const response = await adbSyncReadResponse(stream, responseType);
-        switch (response.id) {
-            case AdbSyncResponseId.Entry:
-                yield {
-                    mode: response.mode,
-                    size: BigInt(response.size),
-                    mtime: BigInt(response.mtime),
-                    get type() { return response.type; },
-                    get permission() { return response.permission; },
-                    name: response.name,
-                };
-                break;
-            case AdbSyncResponseId.Entry2:
-                // `LST2` can return error codes for failed `lstat` calls.
-                // `LIST` just ignores them.
-                // But they only contain `name` so still pretty useless.
-                if (response.error !== 0) {
-                    continue;
-                }
-                yield response;
-                break;
-            case AdbSyncResponseId.Done:
-                return;
-            default:
-                throw new Error('Unexpected response id');
-        }
-    }
-}
+import type { BufferedReadableStream, WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
+import Struct from '@yume-chan/struct';
+
+import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
+import { adbSyncReadResponses, AdbSyncResponseId } from './response.js';
+import { AdbSyncLstatResponse, AdbSyncStatResponse, type AdbSyncStat } from './stat.js';
+
+export interface AdbSyncEntry extends AdbSyncStat {
+    name: string;
+}
+
+export const AdbSyncEntryResponse =
+    new Struct({ littleEndian: true })
+        .fields(AdbSyncLstatResponse)
+        .uint32('nameLength')
+        .string('name', { lengthField: 'nameLength' })
+        .extra({ id: AdbSyncResponseId.Entry as const });
+
+export type AdbSyncEntryResponse = typeof AdbSyncEntryResponse['TDeserializeResult'];
+
+export const AdbSyncEntry2Response =
+    new Struct({ littleEndian: true })
+        .fields(AdbSyncStatResponse)
+        .uint32('nameLength')
+        .string('name', { lengthField: 'nameLength' })
+        .extra({ id: AdbSyncResponseId.Entry2 as const });
+
+export type AdbSyncEntry2Response = 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);
+        yield* adbSyncReadResponses(stream, AdbSyncResponseId.Entry2, AdbSyncEntry2Response);
+    } else {
+        await adbSyncWriteRequest(writer, AdbSyncRequestId.List, path);
+        for await (const item of adbSyncReadResponses(stream, AdbSyncResponseId.Entry, AdbSyncEntryResponse)) {
+            // Convert to same format as `AdbSyncEntry2Response` for easier consumption.
+            // However it will add some overhead.
+            yield {
+                mode: item.mode,
+                size: BigInt(item.size),
+                mtime: BigInt(item.mtime),
+                get type() { return item.type; },
+                get permission() { return item.permission; },
+                name: item.name,
+            };
+        }
+    }
+}

package/src/commands/sync/pull.ts

@@ -1,46 +1,45 @@
-import Struct from '@yume-chan/struct';
-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')
-        .uint8Array('data', { lengthField: 'dataLength' })
-        .extra({ id: AdbSyncResponseId.Data as const });
-
-const RESPONSE_TYPES = {
-    [AdbSyncResponseId.Data]: AdbSyncDataResponse,
-    [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncDataResponse.size),
-};
-
-export function adbSyncPull(
-    stream: AdbBufferedStream,
-    writer: WritableStreamDefaultWriter<Uint8Array>,
-    path: string,
-): ReadableStream<Uint8Array> {
-    return new ReadableStream<Uint8Array>({
-        async start() {
-            await adbSyncWriteRequest(writer, AdbSyncRequestId.Receive, path);
-        },
-        async pull(controller) {
-            const response = await adbSyncReadResponse(stream, RESPONSE_TYPES);
-            switch (response.id) {
-                case AdbSyncResponseId.Data:
-                    controller.enqueue(response.data!);
-                    break;
-                case AdbSyncResponseId.Done:
-                    controller.close();
-                    break;
-                default:
-                    throw new Error('Unexpected response id');
-            }
-        },
-        cancel() {
-            throw new Error(`Sync commands don't support cancel.`);
-        },
-    }, {
-        highWaterMark: 16 * 1024,
-        size(chunk) { return chunk.byteLength; }
-    });
-}
+import { BufferedReadableStream, ReadableStream, WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
+import Struct from '@yume-chan/struct';
+
+import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
+import { adbSyncReadResponses, AdbSyncResponseId } from './response.js';
+
+export const AdbSyncDataResponse =
+    new Struct({ littleEndian: true })
+        .uint32('dataLength')
+        .uint8Array('data', { lengthField: 'dataLength' })
+        .extra({ id: AdbSyncResponseId.Data as const });
+
+export type AdbSyncDataResponse = typeof AdbSyncDataResponse['TDeserializeResult'];
+
+export function adbSyncPull(
+    stream: BufferedReadableStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
+    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() {
+            try {
+                generator.return();
+            } catch { }
+            throw new Error(`Sync commands can't be canceled.`);
+        },
+    }, {
+        highWaterMark: 16 * 1024,
+        size(chunk) { return chunk.byteLength; }
+    });
+}

package/src/commands/sync/push.ts

@@ -1,41 +1,38 @@
-import Struct from '@yume-chan/struct';
-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 })
-        .uint32('unused');
-
-const ResponseTypes = {
-    [AdbSyncResponseId.Ok]: AdbSyncOkResponse,
-};
-
-export const ADB_SYNC_MAX_PACKET_SIZE = 64 * 1024;
-
-export function adbSyncPush(
-    stream: AdbBufferedStream,
-    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, ResponseTypes);
-            },
-        }),
-        new ChunkStream(packetSize)
-    );
-}
+import { BufferedReadableStream, ChunkStream, pipeFrom, WritableStream, WritableStreamDefaultWriter } from '@yume-chan/stream-extra';
+import Struct from '@yume-chan/struct';
+
+import { AdbSyncRequestId, adbSyncWriteRequest } from './request.js';
+import { adbSyncReadResponse, AdbSyncResponseId } from './response.js';
+import { LinuxFileType } from './stat.js';
+
+export const AdbSyncOkResponse =
+    new Struct({ littleEndian: true })
+        .uint32('unused');
+
+export const ADB_SYNC_MAX_PACKET_SIZE = 64 * 1024;
+
+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)
+    );
+}

package/src/commands/sync/request.ts

@@ -1,50 +1,51 @@
-import Struct from '@yume-chan/struct';
-import type { WritableStreamDefaultWriter } from "../../stream/index.js";
-import { encodeUtf8 } from "../../utils/index.js";
-
-export enum AdbSyncRequestId {
-    List = 'LIST',
-    List2 = 'LIS2',
-    Send = 'SEND',
-    Lstat = 'STAT',
-    Stat = 'STA2',
-    Lstat2 = 'LST2',
-    Data = 'DATA',
-    Done = 'DONE',
-    Receive = 'RECV',
-}
-
-export const AdbSyncNumberRequest =
-    new Struct({ littleEndian: true })
-        .string('id', { length: 4 })
-        .uint32('arg');
-
-export const AdbSyncDataRequest =
-    new Struct({ littleEndian: true })
-        .fields(AdbSyncNumberRequest)
-        .uint8Array('data', { lengthField: 'arg' });
-
-export async function adbSyncWriteRequest(
-    writer: WritableStreamDefaultWriter<Uint8Array>,
-    id: AdbSyncRequestId | string,
-    value: number | string | Uint8Array
-): Promise<void> {
-    let buffer: Uint8Array;
-    if (typeof value === 'number') {
-        buffer = AdbSyncNumberRequest.serialize({
-            id,
-            arg: value,
-        });
-    } else if (typeof value === 'string') {
-        buffer = AdbSyncDataRequest.serialize({
-            id,
-            data: encodeUtf8(value),
-        });
-    } else {
-        buffer = AdbSyncDataRequest.serialize({
-            id,
-            data: value,
-        });
-    }
-    await writer.write(buffer);
-}
+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',
+    Send = 'SEND',
+    Lstat = 'STAT',
+    Stat = 'STA2',
+    Lstat2 = 'LST2',
+    Data = 'DATA',
+    Done = 'DONE',
+    Receive = 'RECV',
+}
+
+export const AdbSyncNumberRequest =
+    new Struct({ littleEndian: true })
+        .string('id', { length: 4 })
+        .uint32('arg');
+
+export const AdbSyncDataRequest =
+    new Struct({ littleEndian: true })
+        .fields(AdbSyncNumberRequest)
+        .uint8Array('data', { lengthField: 'arg' });
+
+export async function adbSyncWriteRequest(
+    writer: WritableStreamDefaultWriter<Uint8Array>,
+    id: AdbSyncRequestId | string,
+    value: number | string | Uint8Array
+): Promise<void> {
+    let buffer: Uint8Array;
+    if (typeof value === 'number') {
+        buffer = AdbSyncNumberRequest.serialize({
+            id,
+            arg: value,
+        });
+    } else if (typeof value === 'string') {
+        buffer = AdbSyncDataRequest.serialize({
+            id,
+            data: encodeUtf8(value),
+        });
+    } else {
+        buffer = AdbSyncDataRequest.serialize({
+            id,
+            data: value,
+        });
+    }
+    await writer.write(buffer);
+}