@yume-chan/adb 0.0.20 → 0.0.21

package/src/commands/framebuffer.ts

@@ -1,5 +1,5 @@
 import { BufferedReadableStream } from "@yume-chan/stream-extra";
-import Struct from "@yume-chan/struct";
+import Struct, { StructEmptyError } from "@yume-chan/struct";
 
 import type { Adb } from "../adb.js";
 
@@ -58,10 +58,38 @@ export type AdbFrameBufferV2 = (typeof AdbFrameBufferV2)["TDeserializeResult"];
  */
 export type AdbFrameBuffer = AdbFrameBufferV1 | AdbFrameBufferV2;
 
+export class AdbFrameBufferError extends Error {
+    constructor(message: string, options?: ErrorOptions) {
+        super(message, options);
+    }
+}
+
+export class AdbFrameBufferUnsupportedVersionError extends AdbFrameBufferError {
+    constructor(version: number) {
+        super(`Unsupported FrameBuffer version ${version}`);
+    }
+}
+
+export class AdbFrameBufferForbiddenError extends AdbFrameBufferError {
+    constructor() {
+        super("FrameBuffer is disabled by current app");
+    }
+}
+
 export async function framebuffer(adb: Adb): Promise<AdbFrameBuffer> {
     const socket = await adb.createSocket("framebuffer:");
     const stream = new BufferedReadableStream(socket.readable);
-    const { version } = await Version.deserialize(stream);
+
+    let version: number;
+    try {
+        ({ version } = await Version.deserialize(stream));
+    } catch (e) {
+        if (e instanceof StructEmptyError) {
+            throw new AdbFrameBufferForbiddenError();
+        }
+        throw e;
+    }
+
     switch (version) {
         case 1:
             // TODO: AdbFrameBuffer: does all v1 responses uses the same color space? Add it so the command returns same format for all versions.
@@ -69,6 +97,6 @@ export async function framebuffer(adb: Adb): Promise<AdbFrameBuffer> {
         case 2:
             return AdbFrameBufferV2.deserialize(stream);
         default:
-            throw new Error("Unsupported FrameBuffer version");
+            throw new AdbFrameBufferUnsupportedVersionError(version);
     }
 }

package/src/commands/power.ts

@@ -6,23 +6,23 @@
 import { AdbCommandBase } from "./base.js";
 
 export class AdbPower extends AdbCommandBase {
-    public reboot(mode = "") {
+    reboot(mode = "") {
         return this.adb.createSocketAndWait(`reboot:${mode}`);
     }
 
-    public bootloader() {
+    bootloader() {
         return this.reboot("bootloader");
     }
 
-    public fastboot() {
+    fastboot() {
         return this.reboot("fastboot");
     }
 
-    public recovery() {
+    recovery() {
         return this.reboot("recovery");
     }
 
-    public sideload() {
+    sideload() {
         return this.reboot("sideload");
     }
 
@@ -31,15 +31,15 @@ export class AdbPower extends AdbCommandBase {
      *
      * Only works on some Qualcomm devices.
      */
-    public qualcommEdlMode() {
+    qualcommEdlMode() {
         return this.reboot("edl");
     }
 
-    public powerOff() {
+    powerOff() {
         return this.adb.subprocess.spawnAndWaitLegacy(["reboot", "-p"]);
     }
 
-    public powerButton(longPress = false) {
+    powerButton(longPress = false) {
         return this.adb.subprocess.spawnAndWaitLegacy([
             "input",
             "keyevent",
@@ -52,7 +52,7 @@ export class AdbPower extends AdbCommandBase {
      *
      * Only works on Samsung devices.
      */
-    public samsungOdin() {
+    samsungOdin() {
         return this.reboot("download");
     }
 }

package/src/commands/reverse.ts

@@ -20,16 +20,16 @@ const AdbReverseStringResponse = new Struct()
     .string("content", { lengthField: "length", lengthFieldRadix: 16 });
 
 export class AdbReverseError extends Error {
-    public constructor(message: string) {
+    constructor(message: string) {
         super(message);
         Object.setPrototypeOf(this, new.target.prototype);
     }
 }
 
 export class AdbReverseNotSupportedError extends AdbReverseError {
-    public constructor() {
+    constructor() {
         super(
-            "ADB reverse tunnel is not supported on this device when connected wirelessly."
+            "ADB reverse tunnel is not supported on this device when connected wirelessly.",
         );
     }
 }
@@ -57,7 +57,7 @@ export class AdbReverseCommand extends AutoDisposable {
 
     readonly #deviceAddressToLocalAddress = new Map<string, string>();
 
-    public constructor(adb: Adb) {
+    constructor(adb: Adb) {
         super();
 
         this.adb = adb;
@@ -77,7 +77,7 @@ export class AdbReverseCommand extends AutoDisposable {
         return stream;
     }
 
-    public async list(): Promise<AdbForwardListener[]> {
+    async list(): Promise<AdbForwardListener[]> {
         const stream = await this.createBufferedStream("reverse:list-forward");
 
         const response = await AdbReverseStringResponse.deserialize(stream);
@@ -85,7 +85,7 @@ export class AdbReverseCommand extends AutoDisposable {
             const [deviceSerial, localName, remoteName] = line.split(" ") as [
                 string,
                 string,
-                string
+                string,
             ];
             return { deviceSerial, localName, remoteName };
         });
@@ -99,9 +99,9 @@ export class AdbReverseCommand extends AutoDisposable {
      * @param localAddress The address that listens on the local machine.
      * @returns `tcp:{ACTUAL_LISTENING_PORT}`, If `deviceAddress` is `tcp:0`; otherwise, `deviceAddress`.
      */
-    public async addExternal(deviceAddress: string, localAddress: string) {
+    async addExternal(deviceAddress: string, localAddress: string) {
         const stream = await this.sendRequest(
-            `reverse:forward:${deviceAddress};${localAddress}`
+            `reverse:forward:${deviceAddress};${localAddress}`,
         );
 
         // `tcp:0` tells the device to pick an available port.
@@ -137,14 +137,14 @@ export class AdbReverseCommand extends AutoDisposable {
      * @throws {AdbReverseNotSupportedError} If ADB reverse tunnel is not supported on this device when connected wirelessly.
      * @throws {AdbReverseError} If ADB daemon returns an error.
      */
-    public async add(
+    async add(
         deviceAddress: string,
         handler: AdbIncomingSocketHandler,
-        localAddress?: string
+        localAddress?: string,
     ): Promise<string> {
         localAddress = await this.adb.transport.addReverseTunnel(
             handler,
-            localAddress
+            localAddress,
         );
 
         try {
@@ -157,7 +157,7 @@ export class AdbReverseCommand extends AutoDisposable {
         }
     }
 
-    public async remove(deviceAddress: string): Promise<void> {
+    async remove(deviceAddress: string): Promise<void> {
         const localAddress =
             this.#deviceAddressToLocalAddress.get(deviceAddress);
         if (localAddress) {
@@ -169,7 +169,7 @@ export class AdbReverseCommand extends AutoDisposable {
         // No need to close the stream, device will close it
     }
 
-    public async removeAll(): Promise<void> {
+    async removeAll(): Promise<void> {
         await this.adb.transport.clearReverseTunnels();
         this.#deviceAddressToLocalAddress.clear();
 

package/src/commands/subprocess/command.ts

@@ -1,4 +1,4 @@
-import { DecodeUtf8Stream, GatherStringStream } from "@yume-chan/stream-extra";
+import { ConcatStringStream, DecodeUtf8Stream } from "@yume-chan/stream-extra";
 
 import { AdbCommandBase } from "../base.js";
 
@@ -37,10 +37,10 @@ export interface AdbSubprocessWaitResult {
 }
 
 export class AdbSubprocess extends AdbCommandBase {
-    private async createProtocol(
+    async #createProtocol(
         mode: "pty" | "raw",
         command?: string | string[],
-        options?: Partial<AdbSubprocessOptions>
+        options?: Partial<AdbSubprocessOptions>,
     ): Promise<AdbSubprocessProtocol> {
         const { protocols } = { ...DEFAULT_OPTIONS, ...options };
 
@@ -75,11 +75,11 @@ export class AdbSubprocess extends AdbCommandBase {
      * @param options The options for creating the `AdbSubprocessProtocol`
      * @returns A new `AdbSubprocessProtocol` instance connecting to the spawned process.
      */
-    public shell(
+    shell(
         command?: string | string[],
-        options?: Partial<AdbSubprocessOptions>
+        options?: Partial<AdbSubprocessOptions>,
     ): Promise<AdbSubprocessProtocol> {
-        return this.createProtocol("pty", command, options);
+        return this.#createProtocol("pty", command, options);
     }
 
     /**
@@ -91,11 +91,11 @@ export class AdbSubprocess extends AdbCommandBase {
      * @param options The options for creating the `AdbSubprocessProtocol`
      * @returns A new `AdbSubprocessProtocol` instance connecting to the spawned process.
      */
-    public spawn(
+    spawn(
         command: string | string[],
-        options?: Partial<AdbSubprocessOptions>
+        options?: Partial<AdbSubprocessOptions>,
     ): Promise<AdbSubprocessProtocol> {
-        return this.createProtocol("raw", command, options);
+        return this.#createProtocol("raw", command, options);
     }
 
     /**
@@ -104,24 +104,25 @@ export class AdbSubprocess extends AdbCommandBase {
      * @param options The options for creating the `AdbSubprocessProtocol`
      * @returns The entire output of the command
      */
-    public async spawnAndWait(
+    async spawnAndWait(
         command: string | string[],
-        options?: Partial<AdbSubprocessOptions>
+        options?: Partial<AdbSubprocessOptions>,
     ): Promise<AdbSubprocessWaitResult> {
-        const shell = await this.spawn(command, options);
-
-        const stdout = new GatherStringStream();
-        const stderr = new GatherStringStream();
-
-        const [, , exitCode] = await Promise.all([
-            shell.stdout.pipeThrough(new DecodeUtf8Stream()).pipeTo(stdout),
-            shell.stderr.pipeThrough(new DecodeUtf8Stream()).pipeTo(stderr),
-            shell.exit,
+        const process = await this.spawn(command, options);
+
+        const [stdout, stderr, exitCode] = await Promise.all([
+            process.stdout
+                .pipeThrough(new DecodeUtf8Stream())
+                .pipeThrough(new ConcatStringStream()),
+            process.stderr
+                .pipeThrough(new DecodeUtf8Stream())
+                .pipeThrough(new ConcatStringStream()),
+            process.exit,
         ]);
 
         return {
-            stdout: stdout.result,
-            stderr: stderr.result,
+            stdout,
+            stderr,
             exitCode,
         };
     }
@@ -131,9 +132,7 @@ export class AdbSubprocess extends AdbCommandBase {
      * @param command The command to run
      * @returns The entire output of the command
      */
-    public async spawnAndWaitLegacy(
-        command: string | string[]
-    ): Promise<string> {
+    async spawnAndWaitLegacy(command: string | string[]): Promise<string> {
         const { stdout } = await this.spawnAndWait(command, {
             protocols: [AdbSubprocessNoneProtocol],
         });

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

@@ -13,21 +13,21 @@ import type { AdbSubprocessProtocol } from "./types.js";
  * * `resize`: No
  */
 export class AdbSubprocessNoneProtocol implements AdbSubprocessProtocol {
-    public static isSupported() {
+    static isSupported() {
         return true;
     }
 
-    public static async pty(adb: Adb, command: string) {
+    static async pty(adb: Adb, command: string) {
         return new AdbSubprocessNoneProtocol(
-            await adb.createSocket(`shell:${command}`)
+            await adb.createSocket(`shell:${command}`),
         );
     }
 
-    public static async raw(adb: Adb, command: string) {
+    static async raw(adb: Adb, command: string) {
         // `shell,raw:${command}` also triggers raw mode,
         // But is not supported on Android version <7.
         return new AdbSubprocessNoneProtocol(
-            await adb.createSocket(`exec:${command}`)
+            await adb.createSocket(`exec:${command}`),
         );
     }
 
@@ -36,7 +36,7 @@ export class AdbSubprocessNoneProtocol implements AdbSubprocessProtocol {
     readonly #duplex: DuplexStreamFactory<Uint8Array, Uint8Array>;
 
     // Legacy shell forwards all data to stdin.
-    public get stdin() {
+    get stdin() {
         return this.#socket.writable;
     }
 
@@ -44,7 +44,7 @@ export class AdbSubprocessNoneProtocol implements AdbSubprocessProtocol {
     /**
      * Legacy shell mixes stdout and stderr.
      */
-    public get stdout() {
+    get stdout() {
         return this.#stdout;
     }
 
@@ -52,16 +52,16 @@ export class AdbSubprocessNoneProtocol implements AdbSubprocessProtocol {
     /**
      * `stderr` will always be empty.
      */
-    public get stderr() {
+    get stderr() {
         return this.#stderr;
     }
 
     #exit: Promise<number>;
-    public get exit() {
+    get exit() {
         return this.#exit;
     }
 
-    public constructor(socket: AdbSocket) {
+    constructor(socket: AdbSocket) {
         this.#socket = socket;
 
         // Link `stdout`, `stderr` and `stdin` together,
@@ -77,11 +77,11 @@ export class AdbSubprocessNoneProtocol implements AdbSubprocessProtocol {
         this.#exit = this.#duplex.closed.then(() => 0);
     }
 
-    public resize() {
+    resize() {
         // Not supported, but don't throw.
     }
 
-    public kill() {
+    kill() {
         return this.#duplex.close();
     }
 }

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

@@ -61,38 +61,38 @@ class StdinSerializeStream extends ConsumableTransformStream<
 }
 
 class MultiplexStream<T> {
-    private _readable: PushReadableStream<T>;
-    private _readableController!: PushReadableStreamController<T>;
-    public get readable() {
-        return this._readable;
+    #readable: PushReadableStream<T>;
+    #readableController!: PushReadableStreamController<T>;
+    get readable() {
+        return this.#readable;
     }
 
-    private _activeCount = 0;
+    #activeCount = 0;
 
     constructor() {
-        this._readable = new PushReadableStream((controller) => {
-            this._readableController = controller;
+        this.#readable = new PushReadableStream((controller) => {
+            this.#readableController = controller;
         });
     }
 
-    public createWriteable() {
+    createWriteable() {
         return new WritableStream<T>({
             start: () => {
-                this._activeCount += 1;
+                this.#activeCount += 1;
             },
             write: async (chunk) => {
-                await this._readableController.enqueue(chunk);
+                await this.#readableController.enqueue(chunk);
             },
             abort: () => {
-                this._activeCount -= 1;
-                if (this._activeCount === 0) {
-                    this._readableController.close();
+                this.#activeCount -= 1;
+                if (this.#activeCount === 0) {
+                    this.#readableController.close();
                 }
             },
             close: () => {
-                this._activeCount -= 1;
-                if (this._activeCount === 0) {
-                    this._readableController.close();
+                this.#activeCount -= 1;
+                if (this.#activeCount === 0) {
+                    this.#readableController.close();
                 }
             },
         });
@@ -108,20 +108,20 @@ class MultiplexStream<T> {
  * * `resize`: Yes
  */
 export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
-    public static isSupported(adb: Adb) {
+    static isSupported(adb: Adb) {
         return adb.supportsFeature(AdbFeature.ShellV2);
     }
 
-    public static async pty(adb: Adb, command: string) {
+    static async pty(adb: Adb, command: string) {
         // TODO: AdbShellSubprocessProtocol: Support setting `XTERM` environment variable
         return new AdbSubprocessShellProtocol(
-            await adb.createSocket(`shell,v2,pty:${command}`)
+            await adb.createSocket(`shell,v2,pty:${command}`),
         );
     }
 
-    public static async raw(adb: Adb, command: string) {
+    static async raw(adb: Adb, command: string) {
         return new AdbSubprocessShellProtocol(
-            await adb.createSocket(`shell,v2,raw:${command}`)
+            await adb.createSocket(`shell,v2,raw:${command}`),
         );
     }
 
@@ -131,26 +131,26 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
     >;
 
     #stdin: WritableStream<Consumable<Uint8Array>>;
-    public get stdin() {
+    get stdin() {
         return this.#stdin;
     }
 
     #stdout: ReadableStream<Uint8Array>;
-    public get stdout() {
+    get stdout() {
         return this.#stdout;
     }
 
     #stderr: ReadableStream<Uint8Array>;
-    public get stderr() {
+    get stderr() {
         return this.#stderr;
     }
 
     readonly #exit = new PromiseResolver<number>();
-    public get exit() {
+    get exit() {
         return this.#exit.promise;
     }
 
-    public constructor(socket: AdbSocket) {
+    constructor(socket: AdbSocket) {
         this.#socket = socket;
 
         // Check this image to help you understand the stream graph
@@ -183,7 +183,7 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
                                 break;
                         }
                     },
-                })
+                }),
             )
             .then(
                 () => {
@@ -191,7 +191,7 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
                     stderrController.close();
                     // If `#exit` has already resolved, this will be a no-op
                     this.#exit.reject(
-                        new Error("Socket ended without exit message")
+                        new Error("Socket ended without exit message"),
                     );
                 },
                 (e) => {
@@ -199,7 +199,7 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
                     stderrController.error(e);
                     // If `#exit` has already resolved, this will be a no-op
                     this.#exit.reject(e);
-                }
+                },
             );
 
         const multiplexer = new MultiplexStream<
@@ -210,34 +210,34 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
                 new ConsumableTransformStream({
                     async transform(chunk, controller) {
                         await controller.enqueue(
-                            AdbShellProtocolPacket.serialize(chunk)
+                            AdbShellProtocolPacket.serialize(chunk),
                         );
                     },
-                })
+                }),
             )
             .pipeTo(socket.writable);
 
         this.#stdin = pipeFrom(
             multiplexer.createWriteable(),
-            new StdinSerializeStream()
+            new StdinSerializeStream(),
         );
 
         this.#socketWriter = multiplexer.createWriteable().getWriter();
     }
 
-    public async resize(rows: number, cols: number) {
+    async resize(rows: number, cols: number) {
         await ConsumableWritableStream.write(this.#socketWriter, {
             id: AdbShellProtocolId.WindowSizeChange,
             data: encodeUtf8(
                 // The "correct" format is `${rows}x${cols},${x_pixels}x${y_pixels}`
                 // However, according to https://linux.die.net/man/4/tty_ioctl
                 // `x_pixels` and `y_pixels` are unused, so always sending `0` should be fine.
-                `${rows}x${cols},0x0\0`
+                `${rows}x${cols},0x0\0`,
             ),
         });
     }
 
-    public kill() {
+    kill() {
         return this.#socket.close();
     }
 }

package/src/commands/sync/list.ts

@@ -30,7 +30,7 @@ export type AdbSyncEntry2Response =
 
 export async function* adbSyncOpenDirV2(
     socket: AdbSyncSocket,
-    path: string
+    path: string,
 ): AsyncGenerator<AdbSyncEntry2Response, void, void> {
     const locked = await socket.lock();
     try {
@@ -38,7 +38,7 @@ export async function* adbSyncOpenDirV2(
         for await (const item of adbSyncReadResponses(
             locked,
             AdbSyncResponseId.Entry2,
-            AdbSyncEntry2Response
+            AdbSyncEntry2Response,
         )) {
             // `LST2` can return error codes for failed `lstat` calls.
             // `LIST` just ignores them.
@@ -55,7 +55,7 @@ export async function* adbSyncOpenDirV2(
 
 export async function* adbSyncOpenDirV1(
     socket: AdbSyncSocket,
-    path: string
+    path: string,
 ): AsyncGenerator<AdbSyncEntryResponse, void, void> {
     const locked = await socket.lock();
     try {
@@ -63,7 +63,7 @@ export async function* adbSyncOpenDirV1(
         for await (const item of adbSyncReadResponses(
             locked,
             AdbSyncResponseId.Entry,
-            AdbSyncEntryResponse
+            AdbSyncEntryResponse,
         )) {
             yield item;
         }
@@ -75,7 +75,7 @@ export async function* adbSyncOpenDirV1(
 export async function* adbSyncOpenDir(
     socket: AdbSyncSocket,
     path: string,
-    v2: boolean
+    v2: boolean,
 ): AsyncGenerator<AdbSyncEntry, void, void> {
     if (v2) {
         yield* adbSyncOpenDirV2(socket, path);

package/src/commands/sync/pull.ts

@@ -16,7 +16,7 @@ export type AdbSyncDataResponse =
 
 export async function* adbSyncPullGenerator(
     socket: AdbSyncSocket,
-    path: string
+    path: string,
 ): AsyncGenerator<Uint8Array, void, void> {
     const locked = await socket.lock();
     let done = false;
@@ -25,7 +25,7 @@ export async function* adbSyncPullGenerator(
         for await (const packet of adbSyncReadResponses(
             locked,
             AdbSyncResponseId.Data,
-            AdbSyncDataResponse
+            AdbSyncDataResponse,
         )) {
             yield packet.data;
         }
@@ -36,7 +36,7 @@ export async function* adbSyncPullGenerator(
             for await (const packet of adbSyncReadResponses(
                 locked,
                 AdbSyncResponseId.Data,
-                AdbSyncDataResponse
+                AdbSyncDataResponse,
             )) {
                 void packet;
             }
@@ -47,7 +47,7 @@ export async function* adbSyncPullGenerator(
 
 export function adbSyncPull(
     socket: AdbSyncSocket,
-    path: string
+    path: string,
 ): ReadableStream<Uint8Array> {
     return new PushReadableStream(async (controller) => {
         for await (const data of adbSyncPullGenerator(socket, path)) {