@yume-chan/adb 2.6.0 → 3.0.0-beta.0

package/src/commands/subprocess/utils.ts

@@ -1,61 +0,0 @@
-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 (the backslash is not a escape character)
-        result += String.raw`'\''`;
-        base = found + 1;
-    }
-
-    result += `'`;
-    return result;
-}
-
-export function splitCommand(command: string): string[] {
-    const result: string[] = [];
-    let quote: string | undefined;
-    let isEscaped = false;
-    let start = 0;
-
-    for (let i = 0, len = command.length; i < len; i += 1) {
-        if (isEscaped) {
-            isEscaped = false;
-            continue;
-        }
-
-        const char = command.charAt(i);
-        switch (char) {
-            case " ":
-                if (!quote && i !== start) {
-                    result.push(command.substring(start, i));
-                    start = i + 1;
-                }
-                break;
-            case "'":
-            case '"':
-                if (!quote) {
-                    quote = char;
-                } else if (char === quote) {
-                    quote = undefined;
-                }
-                break;
-            case "\\":
-                isEscaped = true;
-                break;
-        }
-    }
-
-    if (start < command.length) {
-        result.push(command.substring(start));
-    }
-
-    return result;
-}

package/src/commands/sync/index.ts

@@ -1,8 +0,0 @@
-export * from "./list.js";
-export * from "./pull.js";
-export * from "./push.js";
-export * from "./request.js";
-export * from "./response.js";
-export * from "./socket.js";
-export * from "./stat.js";
-export * from "./sync.js";

package/src/commands/sync/list.ts

@@ -1,99 +0,0 @@
-import type { StructValue } from "@yume-chan/struct";
-import { extend, string, u32 } from "@yume-chan/struct";
-
-import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
-import { AdbSyncResponseId, adbSyncReadResponses } from "./response.js";
-import type { AdbSyncSocket } from "./socket.js";
-import type { AdbSyncStat } from "./stat.js";
-import {
-    AdbSyncLstatResponse,
-    AdbSyncStatErrorCode,
-    AdbSyncStatResponse,
-} from "./stat.js";
-
-export interface AdbSyncEntry extends AdbSyncStat {
-    name: string;
-}
-
-export const AdbSyncEntryResponse = extend(AdbSyncLstatResponse, {
-    name: string(u32),
-});
-
-export type AdbSyncEntryResponse = StructValue<typeof AdbSyncEntryResponse>;
-
-export const AdbSyncEntry2Response = extend(AdbSyncStatResponse, {
-    name: string(u32),
-});
-
-export type AdbSyncEntry2Response = StructValue<typeof AdbSyncEntry2Response>;
-
-export async function* adbSyncOpenDirV2(
-    socket: AdbSyncSocket,
-    path: string,
-): AsyncGenerator<AdbSyncEntry2Response, void, void> {
-    const locked = await socket.lock();
-    try {
-        await adbSyncWriteRequest(locked, AdbSyncRequestId.ListV2, path);
-        for await (const item of adbSyncReadResponses(
-            locked,
-            AdbSyncResponseId.Entry2,
-            AdbSyncEntry2Response,
-        )) {
-            // `LST2` can return error codes for failed `lstat` calls.
-            // `LIST` just ignores them.
-            // But they only contain `name` so still pretty useless.
-            if (item.error !== AdbSyncStatErrorCode.SUCCESS) {
-                continue;
-            }
-            yield item;
-        }
-    } finally {
-        locked.release();
-    }
-}
-
-export async function* adbSyncOpenDirV1(
-    socket: AdbSyncSocket,
-    path: string,
-): AsyncGenerator<AdbSyncEntryResponse, void, void> {
-    const locked = await socket.lock();
-    try {
-        await adbSyncWriteRequest(locked, AdbSyncRequestId.List, path);
-        for await (const item of adbSyncReadResponses(
-            locked,
-            AdbSyncResponseId.Entry,
-            AdbSyncEntryResponse,
-        )) {
-            yield item;
-        }
-    } finally {
-        locked.release();
-    }
-}
-
-export async function* adbSyncOpenDir(
-    socket: AdbSyncSocket,
-    path: string,
-    v2: boolean,
-): AsyncGenerator<AdbSyncEntry, void, void> {
-    if (v2) {
-        yield* adbSyncOpenDirV2(socket, path);
-    } else {
-        for await (const item of adbSyncOpenDirV1(socket, path)) {
-            // 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,55 +0,0 @@
-import { ReadableStream } from "@yume-chan/stream-extra";
-import type { StructValue } from "@yume-chan/struct";
-import { buffer, struct, u32 } from "@yume-chan/struct";
-
-import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
-import { adbSyncReadResponses, AdbSyncResponseId } from "./response.js";
-import type { AdbSyncSocket } from "./socket.js";
-
-export const AdbSyncDataResponse = struct(
-    { data: buffer(u32) },
-    { littleEndian: true },
-);
-
-export type AdbSyncDataResponse = StructValue<typeof AdbSyncDataResponse>;
-
-export async function* adbSyncPullGenerator(
-    socket: AdbSyncSocket,
-    path: string,
-): AsyncGenerator<Uint8Array, void, void> {
-    const locked = await socket.lock();
-    let done = false;
-    try {
-        await adbSyncWriteRequest(locked, AdbSyncRequestId.Receive, path);
-        for await (const packet of adbSyncReadResponses(
-            locked,
-            AdbSyncResponseId.Data,
-            AdbSyncDataResponse,
-        )) {
-            yield packet.data;
-        }
-        done = true;
-    } catch (e) {
-        done = true;
-        throw e;
-    } finally {
-        if (!done) {
-            // sync pull can't be cancelled, so we have to read all data
-            for await (const packet of adbSyncReadResponses(
-                locked,
-                AdbSyncResponseId.Data,
-                AdbSyncDataResponse,
-            )) {
-                void packet;
-            }
-        }
-        locked.release();
-    }
-}
-
-export function adbSyncPull(
-    socket: AdbSyncSocket,
-    path: string,
-): ReadableStream<Uint8Array> {
-    return ReadableStream.from(adbSyncPullGenerator(socket, path));
-}

package/src/commands/sync/push.ts

@@ -1,172 +0,0 @@
-import type { ReadableStream } from "@yume-chan/stream-extra";
-import {
-    AbortController,
-    DistributionStream,
-    MaybeConsumable,
-} from "@yume-chan/stream-extra";
-import { struct, u32 } from "@yume-chan/struct";
-
-import { NOOP } from "../../utils/index.js";
-
-import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
-import { AdbSyncResponseId, adbSyncReadResponse } from "./response.js";
-import type { AdbSyncSocket, AdbSyncSocketLocked } from "./socket.js";
-import { LinuxFileType } from "./stat.js";
-
-export const ADB_SYNC_MAX_PACKET_SIZE = 64 * 1024;
-
-export interface AdbSyncPushV1Options {
-    socket: AdbSyncSocket;
-    filename: string;
-    file: ReadableStream<MaybeConsumable<Uint8Array>>;
-    type?: LinuxFileType;
-    permission?: number;
-    mtime?: number;
-    packetSize?: number;
-}
-
-export const AdbSyncOkResponse = struct(
-    { unused: u32 },
-    { littleEndian: true },
-);
-
-async function pipeFileData(
-    locked: AdbSyncSocketLocked,
-    file: ReadableStream<MaybeConsumable<Uint8Array>>,
-    packetSize: number,
-    mtime: number,
-) {
-    // Read and write in parallel,
-    // allow error response to abort the write.
-    const abortController = new AbortController();
-    file.pipeThrough(new DistributionStream(packetSize, true))
-        .pipeTo(
-            new MaybeConsumable.WritableStream({
-                write(chunk) {
-                    return adbSyncWriteRequest(
-                        locked,
-                        AdbSyncRequestId.Data,
-                        chunk,
-                    );
-                },
-            }),
-            { signal: abortController.signal },
-        )
-        .then(async () => {
-            await adbSyncWriteRequest(locked, AdbSyncRequestId.Done, mtime);
-            await locked.flush();
-        }, NOOP);
-
-    await adbSyncReadResponse(
-        locked,
-        AdbSyncResponseId.Ok,
-        AdbSyncOkResponse,
-    ).catch((e) => {
-        abortController.abort();
-        throw e;
-    });
-}
-
-export async function adbSyncPushV1({
-    socket,
-    filename,
-    file,
-    type = LinuxFileType.File,
-    permission = 0o666,
-    mtime = (Date.now() / 1000) | 0,
-    packetSize = ADB_SYNC_MAX_PACKET_SIZE,
-}: AdbSyncPushV1Options) {
-    const locked = await socket.lock();
-    try {
-        const mode = (type << 12) | permission;
-        const pathAndMode = `${filename},${mode.toString()}`;
-        await adbSyncWriteRequest(locked, AdbSyncRequestId.Send, pathAndMode);
-        await pipeFileData(locked, file, packetSize, mtime);
-    } finally {
-        locked.release();
-    }
-}
-
-export const AdbSyncSendV2Flags = {
-    None: 0,
-    Brotli: 1,
-    /**
-     * 2
-     */
-    Lz4: 1 << 1,
-    /**
-     * 4
-     */
-    Zstd: 1 << 2,
-    DryRun: 0x80000000,
-} as const;
-
-export type AdbSyncSendV2Flags =
-    (typeof AdbSyncSendV2Flags)[keyof typeof AdbSyncSendV2Flags];
-
-export interface AdbSyncPushV2Options extends AdbSyncPushV1Options {
-    /**
-     * Don't write the file to disk. Requires the `sendrecv_v2` feature.
-     *
-     * It was used during ADB development to benchmark the performance of
-     * compression algorithms.
-     */
-    dryRun?: boolean;
-}
-
-export const AdbSyncSendV2Request = struct(
-    { id: u32, mode: u32, flags: u32<AdbSyncSendV2Flags>() },
-    { littleEndian: true },
-);
-
-export async function adbSyncPushV2({
-    socket,
-    filename,
-    file,
-    type = LinuxFileType.File,
-    permission = 0o666,
-    mtime = (Date.now() / 1000) | 0,
-    packetSize = ADB_SYNC_MAX_PACKET_SIZE,
-    dryRun = false,
-}: AdbSyncPushV2Options) {
-    const locked = await socket.lock();
-    try {
-        await adbSyncWriteRequest(locked, AdbSyncRequestId.SendV2, filename);
-
-        const mode = (type << 12) | permission;
-        let flags: AdbSyncSendV2Flags = AdbSyncSendV2Flags.None;
-        if (dryRun) {
-            flags |= AdbSyncSendV2Flags.DryRun;
-        }
-        await locked.write(
-            AdbSyncSendV2Request.serialize({
-                id: AdbSyncRequestId.SendV2,
-                mode,
-                flags,
-            }),
-        );
-
-        await pipeFileData(locked, file, packetSize, mtime);
-    } finally {
-        locked.release();
-    }
-}
-
-export interface AdbSyncPushOptions extends AdbSyncPushV2Options {
-    /**
-     * Whether to use the v2 protocol. Requires the `sendrecv_v2` feature.
-     */
-    v2: boolean;
-}
-
-export function adbSyncPush(options: AdbSyncPushOptions) {
-    if (options.v2) {
-        return adbSyncPushV2(options);
-    }
-
-    if (options.dryRun) {
-        throw new Error("dryRun is not supported in v1");
-    }
-
-    return adbSyncPushV1(options);
-}

package/src/commands/sync/request.ts

@@ -1,53 +0,0 @@
-import { encodeUtf8, struct, u32 } from "@yume-chan/struct";
-
-import { adbSyncEncodeId } from "./response.js";
-
-export const AdbSyncRequestId = {
-    List: adbSyncEncodeId("LIST"),
-    ListV2: adbSyncEncodeId("LIS2"),
-    Send: adbSyncEncodeId("SEND"),
-    SendV2: adbSyncEncodeId("SND2"),
-    Lstat: adbSyncEncodeId("STAT"),
-    Stat: adbSyncEncodeId("STA2"),
-    LstatV2: adbSyncEncodeId("LST2"),
-    Data: adbSyncEncodeId("DATA"),
-    Done: adbSyncEncodeId("DONE"),
-    Receive: adbSyncEncodeId("RECV"),
-} as const;
-
-export const AdbSyncNumberRequest = struct(
-    { id: u32, arg: u32 },
-    { littleEndian: true },
-);
-
-export interface AdbSyncWritable {
-    write(buffer: Uint8Array): Promise<void>;
-}
-
-export async function adbSyncWriteRequest(
-    writable: AdbSyncWritable,
-    id: number | string,
-    value: number | string | Uint8Array,
-): Promise<void> {
-    if (typeof id === "string") {
-        id = adbSyncEncodeId(id);
-    }
-
-    if (typeof value === "number") {
-        await writable.write(
-            AdbSyncNumberRequest.serialize({ id, arg: value }),
-        );
-        return;
-    }
-
-    if (typeof value === "string") {
-        value = encodeUtf8(value);
-    }
-
-    // `writable` is buffered, it copies inputs to an internal buffer,
-    // so don't concatenate headers and data here, that will be an unnecessary copy.
-    await writable.write(
-        AdbSyncNumberRequest.serialize({ id, arg: value.length }),
-    );
-    await writable.write(value);
-}

package/src/commands/sync/response.ts

@@ -1,105 +0,0 @@
-import { getUint32LittleEndian } from "@yume-chan/no-data-view";
-import type { AsyncExactReadable, StructDeserializer } from "@yume-chan/struct";
-import { decodeUtf8, string, struct, u32 } from "@yume-chan/struct";
-
-import { unreachable } from "../../utils/no-op.js";
-
-function encodeAsciiUnchecked(value: string): Uint8Array<ArrayBuffer> {
-    const result = new Uint8Array(value.length);
-    for (let i = 0; i < value.length; i += 1) {
-        result[i] = value.charCodeAt(i);
-    }
-    return result;
-}
-
-/**
- * Encode ID to numbers for faster comparison
- * @param value A 4-character string
- * @returns A 32-bit integer by encoding the string as little-endian
- *
- * #__NO_SIDE_EFFECTS__
- */
-export function adbSyncEncodeId(value: string): number {
-    const buffer = encodeAsciiUnchecked(value);
-    return getUint32LittleEndian(buffer, 0);
-}
-
-export const AdbSyncResponseId = {
-    Entry: adbSyncEncodeId("DENT"),
-    Entry2: adbSyncEncodeId("DNT2"),
-    Lstat: adbSyncEncodeId("STAT"),
-    Stat: adbSyncEncodeId("STA2"),
-    Lstat2: adbSyncEncodeId("LST2"),
-    Done: adbSyncEncodeId("DONE"),
-    Data: adbSyncEncodeId("DATA"),
-    Ok: adbSyncEncodeId("OKAY"),
-    Fail: adbSyncEncodeId("FAIL"),
-};
-
-export class AdbSyncError extends Error {}
-
-export const AdbSyncFailResponse = struct(
-    { message: string(u32) },
-    {
-        littleEndian: true,
-        postDeserialize(value) {
-            throw new AdbSyncError(value.message);
-        },
-    },
-);
-
-export async function adbSyncReadResponse<T>(
-    stream: AsyncExactReadable,
-    id: number | string,
-    type: StructDeserializer<T>,
-): Promise<T> {
-    if (typeof id === "string") {
-        id = adbSyncEncodeId(id);
-    }
-
-    const buffer = await stream.readExactly(4);
-    switch (getUint32LittleEndian(buffer, 0)) {
-        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 '${decodeUtf8(buffer)}'`,
-            );
-    }
-}
-
-export async function* adbSyncReadResponses<T>(
-    stream: AsyncExactReadable,
-    id: number | string,
-    type: StructDeserializer<T>,
-): AsyncGenerator<T, void, void> {
-    if (typeof id === "string") {
-        id = adbSyncEncodeId(id);
-    }
-
-    while (true) {
-        const buffer = await stream.readExactly(4);
-        switch (getUint32LittleEndian(buffer, 0)) {
-            case AdbSyncResponseId.Fail:
-                await AdbSyncFailResponse.deserialize(stream);
-                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.readExactly(type.size);
-                return;
-            case id:
-                yield await type.deserialize(stream);
-                break;
-            default:
-                throw new Error(
-                    `Expected '${id}' or '${AdbSyncResponseId.Done}', but got '${decodeUtf8(buffer)}'`,
-                );
-        }
-    }
-}

package/src/commands/sync/socket.ts

@@ -1,109 +0,0 @@
-import type {
-    MaybeConsumable,
-    WritableStreamDefaultWriter,
-} from "@yume-chan/stream-extra";
-import {
-    BufferCombiner,
-    BufferedReadableStream,
-    Consumable,
-} from "@yume-chan/stream-extra";
-import type { AsyncExactReadable } from "@yume-chan/struct";
-
-import type { AdbSocket } from "../../adb.js";
-import { AutoResetEvent } from "../../utils/index.js";
-
-export class AdbSyncSocketLocked implements AsyncExactReadable {
-    readonly #writer: WritableStreamDefaultWriter<MaybeConsumable<Uint8Array>>;
-    readonly #readable: BufferedReadableStream;
-    readonly #socketLock: AutoResetEvent;
-    readonly #writeLock = new AutoResetEvent();
-    readonly #combiner: BufferCombiner;
-
-    get position() {
-        return this.#readable.position;
-    }
-
-    constructor(
-        writer: WritableStreamDefaultWriter<MaybeConsumable<Uint8Array>>,
-        readable: BufferedReadableStream,
-        bufferSize: number,
-        lock: AutoResetEvent,
-    ) {
-        this.#writer = writer;
-        this.#readable = readable;
-        this.#socketLock = lock;
-        this.#combiner = new BufferCombiner(bufferSize);
-    }
-
-    #write(buffer: Uint8Array) {
-        // `#combiner` will reuse the buffer, so we need to use the Consumable pattern
-        return Consumable.WritableStream.write(this.#writer, buffer);
-    }
-
-    async flush() {
-        try {
-            await this.#writeLock.wait();
-            const buffer = this.#combiner.flush();
-            if (buffer) {
-                await this.#write(buffer);
-            }
-        } finally {
-            this.#writeLock.notifyOne();
-        }
-    }
-
-    async write(data: Uint8Array) {
-        try {
-            await this.#writeLock.wait();
-            for (const buffer of this.#combiner.push(data)) {
-                await this.#write(buffer);
-            }
-        } finally {
-            this.#writeLock.notifyOne();
-        }
-    }
-
-    async readExactly(length: number) {
-        // The request may still be in the internal buffer.
-        // Call `flush` to send it before starting reading
-        await this.flush();
-        return await this.#readable.readExactly(length);
-    }
-
-    release(): void {
-        // In theory, the writer shouldn't leave anything in the buffer,
-        // but to be safe, call `flush` to throw away any remaining data.
-        this.#combiner.flush();
-        this.#socketLock.notifyOne();
-    }
-
-    async close() {
-        await this.#readable.cancel();
-    }
-}
-
-export class AdbSyncSocket {
-    readonly #lock = new AutoResetEvent();
-    readonly #socket: AdbSocket;
-    readonly #locked: AdbSyncSocketLocked;
-
-    constructor(socket: AdbSocket, bufferSize: number) {
-        this.#socket = socket;
-        this.#locked = new AdbSyncSocketLocked(
-            socket.writable.getWriter(),
-            new BufferedReadableStream(socket.readable),
-            bufferSize,
-            this.#lock,
-        );
-    }
-
-    async lock() {
-        await this.#lock.wait();
-        return this.#locked;
-    }
-
-    async close() {
-        await this.#locked.close();
-        await this.#socket.close();
-    }
-}