@yume-chan/adb 0.0.9 → 0.0.12

package/src/commands/subprocess/types.ts

@@ -0,0 +1,55 @@
+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 `AdbShell` 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 `AdbShell` doesn't support exit code,
+     * They will always resolve with `0`.
+     */
+    readonly exit: Promise<number>;
+
+    /**
+     * Resizes the current shell.
+     *
+     * Some `AdbShell`s may not support resizing and will always 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>;
+
+    /** Creates a new `AdbShell` using the specified `Adb` and `command` */
+    spawn(adb: Adb, command: string): ValueOrPromise<AdbSubprocessProtocol>;
+
+    /** Creates a new `AdbShell` by attaching to an exist `AdbSocket` */
+    new(socket: AdbSocket): AdbSubprocessProtocol;
+}

package/src/commands/{shell → 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';
-export * from './pull';
-export * from './request';
-export * from './response';
-export * from './push';
-export * from './stat';
-export * from './sync';
+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';

package/src/commands/sync/list.ts

@@ -1,39 +1,40 @@
-import Struct from '@yume-chan/struct';
-import { AdbBufferedStream } from '../../stream';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request';
-import { AdbSyncDoneResponse, adbSyncReadResponse, AdbSyncResponseId } from './response';
-import { AdbSyncLstatResponse } from './stat';
-
-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'];
-
-const ResponseTypes = {
-    [AdbSyncResponseId.Entry]: AdbSyncEntryResponse,
-    [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncEntryResponse.size),
-};
-
-export async function* adbSyncOpenDir(
-    stream: AdbBufferedStream,
-    path: string
-): AsyncGenerator<AdbSyncEntryResponse, void, void> {
-    await adbSyncWriteRequest(stream, AdbSyncRequestId.List, path);
-
-    while (true) {
-        const response = await adbSyncReadResponse(stream, ResponseTypes);
-        switch (response.id) {
-            case AdbSyncResponseId.Entry:
-                yield response;
-                break;
-            case AdbSyncResponseId.Done:
-                return;
-            default:
-                throw new Error('Unexpected response id');
-        }
-    }
-}
+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 } from './stat.js';
+
+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'];
+
+const ResponseTypes = {
+    [AdbSyncResponseId.Entry]: AdbSyncEntryResponse,
+    [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncEntryResponse.size),
+};
+
+export async function* adbSyncOpenDir(
+    stream: AdbBufferedStream,
+    writer: WritableStreamDefaultWriter<Uint8Array>,
+    path: string,
+): AsyncGenerator<AdbSyncEntryResponse, void, void> {
+    await adbSyncWriteRequest(writer, AdbSyncRequestId.List, path);
+
+    while (true) {
+        const response = await adbSyncReadResponse(stream, ResponseTypes);
+        switch (response.id) {
+            case AdbSyncResponseId.Entry:
+                yield response;
+                break;
+            case AdbSyncResponseId.Done:
+                return;
+            default:
+                throw new Error('Unexpected response id');
+        }
+    }
+}

package/src/commands/sync/pull.ts

@@ -1,34 +1,43 @@
-import Struct from '@yume-chan/struct';
-import { AdbBufferedStream } from '../../stream';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request';
-import { AdbSyncDoneResponse, adbSyncReadResponse, AdbSyncResponseId } from './response';
-
-export const AdbSyncDataResponse =
-    new Struct({ littleEndian: true })
-        .uint32('dataLength')
-        .arrayBuffer('data', { lengthField: 'dataLength' })
-        .extra({ id: AdbSyncResponseId.Data as const });
-
-const ResponseTypes = {
-    [AdbSyncResponseId.Data]: AdbSyncDataResponse,
-    [AdbSyncResponseId.Done]: new AdbSyncDoneResponse(AdbSyncDataResponse.size),
-};
-
-export async function* adbSyncPull(
-    stream: AdbBufferedStream,
-    path: string,
-): AsyncGenerator<ArrayBuffer, void, void> {
-    await adbSyncWriteRequest(stream, AdbSyncRequestId.Receive, path);
-    while (true) {
-        const response = await adbSyncReadResponse(stream, ResponseTypes);
-        switch (response.id) {
-            case AdbSyncResponseId.Data:
-                yield response.data!;
-                break;
-            case AdbSyncResponseId.Done:
-                return;
-            default:
-                throw new Error('Unexpected response id');
-        }
-    }
-}
+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 ResponseTypes = {
+    [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, ResponseTypes);
+            switch (response.id) {
+                case AdbSyncResponseId.Data:
+                    controller.enqueue(response.data!);
+                    break;
+                case AdbSyncResponseId.Done:
+                    controller.close();
+                    break;
+                default:
+                    throw new Error('Unexpected response id');
+            }
+        }
+    }, {
+        highWaterMark: 16 * 1024,
+        size(chunk) { return chunk.byteLength; }
+    });
+}

package/src/commands/sync/push.ts

@@ -1,46 +1,41 @@
-import Struct from '@yume-chan/struct';
-import { AdbBufferedStream } from '../../stream';
-import { chunkArrayLike, chunkAsyncIterable } from '../../utils';
-import { AdbSyncRequestId, adbSyncWriteRequest } from './request';
-import { adbSyncReadResponse, AdbSyncResponseId } from './response';
-import { LinuxFileType } from './stat';
-
-export const AdbSyncOkResponse =
-    new Struct({ littleEndian: true })
-        .uint32('unused');
-
-const ResponseTypes = {
-    [AdbSyncResponseId.Ok]: AdbSyncOkResponse,
-};
-
-export const AdbSyncMaxPacketSize = 64 * 1024;
-
-export async function adbSyncPush(
-    stream: AdbBufferedStream,
-    filename: string,
-    content: ArrayLike<number> | ArrayBufferLike | AsyncIterable<ArrayBuffer>,
-    mode: number = (LinuxFileType.File << 12) | 0o666,
-    mtime: number = (Date.now() / 1000) | 0,
-    packetSize: number = AdbSyncMaxPacketSize,
-    onProgress?: (uploaded: number) => void,
-): Promise<void> {
-    const pathAndMode = `${filename},${mode.toString()}`;
-    await adbSyncWriteRequest(stream, AdbSyncRequestId.Send, pathAndMode);
-
-    let chunkReader: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>;
-    if ('length' in content || 'byteLength' in content) {
-        chunkReader = chunkArrayLike(content, packetSize);
-    } else {
-        chunkReader = chunkAsyncIterable(content, packetSize);
-    }
-
-    let uploaded = 0;
-    for await (const buffer of chunkReader) {
-        await adbSyncWriteRequest(stream, AdbSyncRequestId.Data, buffer);
-        uploaded += buffer.byteLength;
-        onProgress?.(uploaded);
-    }
-
-    await adbSyncWriteRequest(stream, AdbSyncRequestId.Done, mtime);
-    await adbSyncReadResponse(stream, ResponseTypes);
-}
+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)
+    );
+}

package/src/commands/sync/request.ts

@@ -1,48 +1,49 @@
-import Struct from '@yume-chan/struct';
-import { AdbBufferedStream } from '../../stream';
-
-export enum AdbSyncRequestId {
-    List = 'LIST',
-    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)
-        .arrayBuffer('data', { lengthField: 'arg' });
-
-export async function adbSyncWriteRequest(
-    stream: AdbBufferedStream,
-    id: AdbSyncRequestId | string,
-    value: number | string | ArrayBuffer
-): Promise<void> {
-    let buffer: ArrayBuffer;
-    if (typeof value === 'number') {
-        buffer = AdbSyncNumberRequest.serialize({
-            id,
-            arg: value,
-        }, stream);
-    } else if (typeof value === 'string') {
-        buffer = AdbSyncDataRequest.serialize({
-            id,
-            data: stream.encodeUtf8(value),
-        }, stream);
-    } else {
-        buffer = AdbSyncDataRequest.serialize({
-            id,
-            data: value,
-        }, stream);
-    }
-    await stream.write(buffer);
-}
+import Struct from '@yume-chan/struct';
+import type { WritableStreamDefaultWriter } from "../../stream/index.js";
+import { encodeUtf8 } from "../../utils/index.js";
+
+export enum AdbSyncRequestId {
+    List = 'LIST',
+    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);
+}

package/src/commands/sync/response.ts

@@ -1,57 +1,58 @@
-import Struct, { StructDeserializationContext, StructLike, StructValueType } from '@yume-chan/struct';
-import { AdbBufferedStream } from '../../stream';
-
-export enum AdbSyncResponseId {
-    Entry = 'DENT',
-    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;
-
-    public constructor(length: number) {
-        this.length = length;
-    }
-
-    public async deserialize(context: StructDeserializationContext): Promise<this> {
-        await context.read(this.length);
-        return this;
-    }
-}
-
-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,
-): Promise<StructValueType<T[keyof T]>> {
-    const id = stream.backend.decodeUtf8(await stream.read(4));
-
-    if (id === AdbSyncResponseId.Fail) {
-        await AdbSyncFailResponse.deserialize(stream);
-    }
-
-    if (types[id]) {
-        return types[id].deserialize(stream);
-    }
-
-    throw new Error('Unexpected response id');
-}
+import Struct, { type StructAsyncDeserializeStream, type StructLike, type StructValueType } from '@yume-chan/struct';
+import type { AdbBufferedStream } from '../../stream/index.js';
+import { decodeUtf8 } from "../../utils/index.js";
+
+export enum AdbSyncResponseId {
+    Entry = 'DENT',
+    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;
+
+    public constructor(length: number) {
+        this.length = length;
+    }
+
+    public async deserialize(stream: StructAsyncDeserializeStream): Promise<this> {
+        await stream.read(this.length);
+        return this;
+    }
+}
+
+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,
+): Promise<StructValueType<T[keyof T]>> {
+    const id = decodeUtf8(await stream.read(4));
+
+    if (id === AdbSyncResponseId.Fail) {
+        await AdbSyncFailResponse.deserialize(stream);
+    }
+
+    if (types[id]) {
+        return types[id]!.deserialize(stream);
+    }
+
+    throw new Error('Unexpected response id');
+}