@yume-chan/adb 0.0.17 → 0.0.18

package/src/auth.ts

@@ -1,10 +1,14 @@
-import { PromiseResolver } from '@yume-chan/async';
-import type { Disposable } from '@yume-chan/event';
-import type { ValueOrPromise } from '@yume-chan/struct';
-
-import { calculatePublicKey, calculatePublicKeyLength, sign } from './crypto.js';
-import { AdbCommand, type AdbPacketData } from './packet.js';
-import { calculateBase64EncodedLength, encodeBase64 } from './utils/index.js';
+import { PromiseResolver } from "@yume-chan/async";
+import { type Disposable } from "@yume-chan/event";
+import { type ValueOrPromise } from "@yume-chan/struct";
+
+import {
+    calculatePublicKey,
+    calculatePublicKeyLength,
+    sign,
+} from "./crypto.js";
+import { AdbCommand, type AdbPacketData } from "./packet.js";
+import { calculateBase64EncodedLength, encodeBase64 } from "./utils/index.js";
 
 export type AdbKeyIterable = Iterable<Uint8Array> | AsyncIterable<Uint8Array>;
 
@@ -50,7 +54,7 @@ export interface AdbAuthenticator {
 
 export const AdbSignatureAuthenticator: AdbAuthenticator = async function* (
     credentialStore: AdbCredentialStore,
-    getNextRequest: () => Promise<AdbPacketData>,
+    getNextRequest: () => Promise<AdbPacketData>
 ): AsyncIterable<AdbPacketData> {
     for await (const key of credentialStore.iterateKeys()) {
         const packet = await getNextRequest();
@@ -71,7 +75,7 @@ export const AdbSignatureAuthenticator: AdbAuthenticator = async function* (
 
 export const AdbPublicKeyAuthenticator: AdbAuthenticator = async function* (
     credentialStore: AdbCredentialStore,
-    getNextRequest: () => Promise<AdbPacketData>,
+    getNextRequest: () => Promise<AdbPacketData>
 ): AsyncIterable<AdbPacketData> {
     const packet = await getNextRequest();
 
@@ -85,23 +89,20 @@ export const AdbPublicKeyAuthenticator: AdbAuthenticator = async function* (
         break;
     }
 
-
     if (!privateKey) {
         privateKey = await credentialStore.generateKey();
     }
 
     const publicKeyLength = calculatePublicKeyLength();
-    const [publicKeyBase64Length] = calculateBase64EncodedLength(publicKeyLength);
+    const [publicKeyBase64Length] =
+        calculateBase64EncodedLength(publicKeyLength);
 
     // The public key is null terminated,
     // So we allocate the buffer with one extra byte.
     const publicKeyBuffer = new Uint8Array(publicKeyBase64Length + 1);
 
     calculatePublicKey(privateKey, publicKeyBuffer);
-    encodeBase64(
-        publicKeyBuffer.subarray(0, publicKeyLength),
-        publicKeyBuffer
-    );
+    encodeBase64(publicKeyBuffer.subarray(0, publicKeyLength), publicKeyBuffer);
 
     yield {
         command: AdbCommand.Auth,
@@ -137,9 +138,16 @@ export class AdbAuthenticationProcessor implements Disposable {
         return this.pendingRequest.promise;
     };
 
-    private async* invokeAuthenticator(): AsyncGenerator<AdbPacketData, void, void> {
+    private async *invokeAuthenticator(): AsyncGenerator<
+        AdbPacketData,
+        void,
+        void
+    > {
         for (const authenticator of this.authenticators) {
-            for await (const packet of authenticator(this.credentialStore, this.getNextRequest)) {
+            for await (const packet of authenticator(
+                this.credentialStore,
+                this.getNextRequest
+            )) {
                 // If the authenticator yielded a response
                 // Prepare `nextRequest` for next authentication request
                 this.pendingRequest = new PromiseResolver();
@@ -162,13 +170,13 @@ export class AdbAuthenticationProcessor implements Disposable {
 
         const result = await this.iterator.next();
         if (result.done) {
-            throw new Error('No authenticator can handle the request');
+            throw new Error("No authenticator can handle the request");
         }
 
         return result.value;
     }
 
     public dispose() {
-        this.iterator?.return?.();
+        void this.iterator?.return?.();
     }
 }

package/src/backend.ts

@@ -1,12 +1,14 @@
-import type { ReadableWritablePair } from '@yume-chan/stream-extra';
-import type { ValueOrPromise } from '@yume-chan/struct';
+import { type ReadableWritablePair } from "@yume-chan/stream-extra";
+import { type ValueOrPromise } from "@yume-chan/struct";
 
-import type { AdbPacketData, AdbPacketInit } from './packet.js';
+import { type AdbPacketData, type AdbPacketInit } from "./packet.js";
 
 export interface AdbBackend {
     readonly serial: string;
 
     readonly name: string | undefined;
 
-    connect(): ValueOrPromise<ReadableWritablePair<AdbPacketData, AdbPacketInit>>;
+    connect(): ValueOrPromise<
+        ReadableWritablePair<AdbPacketData, AdbPacketInit>
+    >;
 }

package/src/commands/base.ts

@@ -1,6 +1,6 @@
-import { AutoDisposable } from '@yume-chan/event';
+import { AutoDisposable } from "@yume-chan/event";
 
-import type { Adb } from '../adb.js';
+import { type Adb } from "../adb.js";
 
 export class AdbCommandBase extends AutoDisposable {
     protected adb: Adb;

package/src/commands/framebuffer.ts

@@ -1,48 +1,44 @@
-import { BufferedReadableStream } from '@yume-chan/stream-extra';
-import Struct from '@yume-chan/struct';
+import { BufferedReadableStream } from "@yume-chan/stream-extra";
+import Struct from "@yume-chan/struct";
 
-import type { Adb } from '../adb.js';
+import { type Adb } from "../adb.js";
 
-const Version =
-    new Struct({ littleEndian: true })
-        .uint32('version');
+const Version = new Struct({ littleEndian: true }).uint32("version");
 
-export const AdbFrameBufferV1 =
-    new Struct({ littleEndian: true })
-        .uint32('bpp')
-        .uint32('size')
-        .uint32('width')
-        .uint32('height')
-        .uint32('red_offset')
-        .uint32('red_length')
-        .uint32('blue_offset')
-        .uint32('blue_length')
-        .uint32('green_offset')
-        .uint32('green_length')
-        .uint32('alpha_offset')
-        .uint32('alpha_length')
-        .uint8Array('data', { lengthField: 'size' });
+export const AdbFrameBufferV1 = new Struct({ littleEndian: true })
+    .uint32("bpp")
+    .uint32("size")
+    .uint32("width")
+    .uint32("height")
+    .uint32("red_offset")
+    .uint32("red_length")
+    .uint32("blue_offset")
+    .uint32("blue_length")
+    .uint32("green_offset")
+    .uint32("green_length")
+    .uint32("alpha_offset")
+    .uint32("alpha_length")
+    .uint8Array("data", { lengthField: "size" });
 
-export type AdbFrameBufferV1 = typeof AdbFrameBufferV1['TDeserializeResult'];
+export type AdbFrameBufferV1 = typeof AdbFrameBufferV1["TDeserializeResult"];
 
-export const AdbFrameBufferV2 =
-    new Struct({ littleEndian: true })
-        .uint32('bpp')
-        .uint32('colorSpace')
-        .uint32('size')
-        .uint32('width')
-        .uint32('height')
-        .uint32('red_offset')
-        .uint32('red_length')
-        .uint32('blue_offset')
-        .uint32('blue_length')
-        .uint32('green_offset')
-        .uint32('green_length')
-        .uint32('alpha_offset')
-        .uint32('alpha_length')
-        .uint8Array('data', { lengthField: 'size' });
+export const AdbFrameBufferV2 = new Struct({ littleEndian: true })
+    .uint32("bpp")
+    .uint32("colorSpace")
+    .uint32("size")
+    .uint32("width")
+    .uint32("height")
+    .uint32("red_offset")
+    .uint32("red_length")
+    .uint32("blue_offset")
+    .uint32("blue_length")
+    .uint32("green_offset")
+    .uint32("green_length")
+    .uint32("alpha_offset")
+    .uint32("alpha_length")
+    .uint8Array("data", { lengthField: "size" });
 
-export type AdbFrameBufferV2 = typeof AdbFrameBufferV2['TDeserializeResult'];
+export type AdbFrameBufferV2 = typeof AdbFrameBufferV2["TDeserializeResult"];
 
 /**
  * ADB uses 8 int32 fields to describe bit depths
@@ -63,7 +59,7 @@ export type AdbFrameBufferV2 = typeof AdbFrameBufferV2['TDeserializeResult'];
 export type AdbFrameBuffer = AdbFrameBufferV1 | AdbFrameBufferV2;
 
 export async function framebuffer(adb: Adb): Promise<AdbFrameBuffer> {
-    const socket = await adb.createSocket('framebuffer:');
+    const socket = await adb.createSocket("framebuffer:");
     const stream = new BufferedReadableStream(socket.readable);
     const { version } = await Version.deserialize(stream);
     switch (version) {
@@ -73,6 +69,6 @@ export async function framebuffer(adb: Adb): Promise<AdbFrameBuffer> {
         case 2:
             return AdbFrameBufferV2.deserialize(stream);
         default:
-            throw new Error('Unknown FrameBuffer version');
+            throw new Error("Unknown FrameBuffer version");
     }
 }

package/src/commands/install.ts

@@ -1,13 +1,17 @@
-import { WrapWritableStream, WritableStream } from '@yume-chan/stream-extra';
+import {
+    WrapWritableStream,
+    type WritableStream,
+} from "@yume-chan/stream-extra";
 
-import type { Adb } from '../adb.js';
-import { escapeArg } from './subprocess/index.js';
-import type { AdbSync } from './sync/index.js';
+import { type Adb } from "../adb.js";
 
-export function install(
-    adb: Adb,
-): WritableStream<Uint8Array> {
-    const filename = `/data/local/tmp/${Math.random().toString().substring(2)}.apk`;
+import { escapeArg } from "./subprocess/index.js";
+import { type AdbSync } from "./sync/index.js";
+
+export function install(adb: Adb): WritableStream<Uint8Array> {
+    const filename = `/data/local/tmp/${Math.random()
+        .toString()
+        .substring(2)}.apk`;
 
     let sync!: AdbSync;
     return new WrapWritableStream<Uint8Array>({
@@ -20,13 +24,17 @@ export function install(
             return sync.write(filename, undefined, undefined);
         },
         async close() {
-            sync.dispose();
+            await sync.dispose();
 
             // Invoke `pm install` to install it
-            await adb.subprocess.spawnAndWaitLegacy(['pm', 'install', escapeArg(filename)]);
+            await adb.subprocess.spawnAndWaitLegacy([
+                "pm",
+                "install",
+                escapeArg(filename),
+            ]);
 
             // Remove the temp file
             await adb.rm(filename);
-        }
+        },
     });
 }

package/src/commands/power.ts

@@ -3,27 +3,27 @@
 // cspell: ignore keyevent
 // cspell: ignore longpress
 
-import { AdbCommandBase } from './base.js';
+import { AdbCommandBase } from "./base.js";
 
 export class AdbPower extends AdbCommandBase {
-    public reboot(name: string = '') {
+    public reboot(name = "") {
         return this.adb.createSocketAndWait(`reboot:${name}`);
     }
 
     public bootloader() {
-        return this.reboot('bootloader');
+        return this.reboot("bootloader");
     }
 
     public fastboot() {
-        return this.reboot('fastboot');
+        return this.reboot("fastboot");
     }
 
     public recovery() {
-        return this.reboot('recovery');
+        return this.reboot("recovery");
     }
 
     public sideload() {
-        return this.reboot('sideload');
+        return this.reboot("sideload");
     }
 
     /**
@@ -32,15 +32,19 @@ export class AdbPower extends AdbCommandBase {
      * Only works on some Qualcomm devices.
      */
     public qualcommEdlMode() {
-        return this.reboot('edl');
+        return this.reboot("edl");
     }
 
     public powerOff() {
-        return this.adb.subprocess.spawnAndWaitLegacy(['reboot', '-p']);
+        return this.adb.subprocess.spawnAndWaitLegacy(["reboot", "-p"]);
     }
 
-    public powerButton(longPress: boolean = false) {
-        return this.adb.subprocess.spawnAndWaitLegacy(['input', 'keyevent', longPress ? '--longpress POWER' : 'POWER']);
+    public powerButton(longPress = false) {
+        return this.adb.subprocess.spawnAndWaitLegacy([
+            "input",
+            "keyevent",
+            longPress ? "--longpress POWER" : "POWER",
+        ]);
     }
 
     /**
@@ -49,6 +53,6 @@ export class AdbPower extends AdbCommandBase {
      * Only works on Samsung devices.
      */
     public samsungOdin() {
-        return this.reboot('download');
+        return this.reboot("download");
     }
 }

package/src/commands/reverse.ts

@@ -1,12 +1,18 @@
 // cspell: ignore killforward
 
-import { AutoDisposable } from '@yume-chan/event';
-import { BufferedReadableStream, BufferedReadableStreamEndedError } from '@yume-chan/stream-extra';
-import Struct from '@yume-chan/struct';
-
-import type { Adb } from '../adb.js';
-import type { AdbIncomingSocketHandler, AdbSocket } from '../socket/index.js';
-import { decodeUtf8 } from '../utils/index.js';
+import { AutoDisposable } from "@yume-chan/event";
+import {
+    BufferedReadableStream,
+    BufferedReadableStreamEndedError,
+} from "@yume-chan/stream-extra";
+import Struct from "@yume-chan/struct";
+
+import { type Adb } from "../adb.js";
+import {
+    type AdbIncomingSocketHandler,
+    type AdbSocket,
+} from "../socket/index.js";
+import { decodeUtf8 } from "../utils/index.js";
 
 export interface AdbForwardListener {
     deviceSerial: string;
@@ -16,20 +22,21 @@ export interface AdbForwardListener {
     remoteName: string;
 }
 
-const AdbReverseStringResponse =
-    new Struct()
-        .string('length', { length: 4 })
-        .string('content', { lengthField: 'length', lengthFieldRadix: 16 });
+const AdbReverseStringResponse = new Struct()
+    .string("length", { length: 4 })
+    .string("content", { lengthField: "length", lengthFieldRadix: 16 });
 
-const AdbReverseErrorResponse =
-    new Struct()
-        .fields(AdbReverseStringResponse)
-        .postDeserialize((value) => {
-            throw new Error(value.content);
-        });
+const AdbReverseErrorResponse = new Struct()
+    .fields(AdbReverseStringResponse)
+    .postDeserialize((value) => {
+        throw new Error(value.content);
+    });
 
 export class AdbReverseCommand extends AutoDisposable {
-    protected localAddressToHandler = new Map<string, AdbIncomingSocketHandler>();
+    protected localAddressToHandler = new Map<
+        string,
+        AdbIncomingSocketHandler
+    >();
 
     protected deviceAddressToLocalAddress = new Map<string, string>();
 
@@ -41,13 +48,15 @@ export class AdbReverseCommand extends AutoDisposable {
         super();
 
         this.adb = adb;
-        this.addDisposable(this.adb.onIncomingSocket(this.handleIncomingSocket));
+        this.addDisposable(
+            this.adb.onIncomingSocket(this.handleIncomingSocket)
+        );
     }
 
     protected handleIncomingSocket = async (socket: AdbSocket) => {
         let address = socket.serviceString;
         // ADB daemon appends `\0` to the service string
-        address = address.replace(/\0/g, '');
+        address = address.replace(/\0/g, "");
         return !!(await this.localAddressToHandler.get(address)?.(socket));
     };
 
@@ -58,7 +67,7 @@ export class AdbReverseCommand extends AutoDisposable {
 
     private async sendRequest(service: string) {
         const stream = await this.createBufferedStream(service);
-        const success = decodeUtf8(await stream.read(4)) === 'OKAY';
+        const success = decodeUtf8(await stream.read(4)) === "OKAY";
         if (!success) {
             await AdbReverseErrorResponse.deserialize(stream);
         }
@@ -66,11 +75,15 @@ export class AdbReverseCommand extends AutoDisposable {
     }
 
     public async list(): Promise<AdbForwardListener[]> {
-        const stream = await this.createBufferedStream('reverse:list-forward');
+        const stream = await this.createBufferedStream("reverse:list-forward");
 
         const response = await AdbReverseStringResponse.deserialize(stream);
-        return response.content!.split('\n').map(line => {
-            const [deviceSerial, localName, remoteName] = line.split(' ') as [string, string, string];
+        return response.content!.split("\n").map((line) => {
+            const [deviceSerial, localName, remoteName] = line.split(" ") as [
+                string,
+                string,
+                string
+            ];
             return { deviceSerial, localName, remoteName };
         });
 
@@ -86,13 +99,17 @@ export class AdbReverseCommand extends AutoDisposable {
     public async add(
         deviceAddress: string,
         localAddress: string,
-        handler: AdbIncomingSocketHandler,
+        handler: AdbIncomingSocketHandler
     ): Promise<string> {
-        const stream = await this.sendRequest(`reverse:forward:${deviceAddress};${localAddress}`);
+        // TODO(reverse): handle ADB bug
+        // https://issuetracker.google.com/issues/37066218
+        const stream = await this.sendRequest(
+            `reverse:forward:${deviceAddress};${localAddress}`
+        );
 
         // `tcp:0` tells the device to pick an available port.
         // On Android >=8, device will respond with the selected port for all `tcp:` requests.
-        if (deviceAddress.startsWith('tcp:')) {
+        if (deviceAddress.startsWith("tcp:")) {
             let length: number | undefined;
             try {
                 length = Number.parseInt(decodeUtf8(await stream.read(4)), 16);
@@ -107,7 +124,7 @@ export class AdbReverseCommand extends AutoDisposable {
             }
 
             if (length !== undefined) {
-                const port = decodeUtf8(await stream.read(length!));
+                const port = decodeUtf8(await stream.read(length));
                 deviceAddress = `tcp:${Number.parseInt(port, 10)}`;
             }
         }
@@ -123,7 +140,9 @@ export class AdbReverseCommand extends AutoDisposable {
         await this.sendRequest(`reverse:killforward:${deviceAddress}`);
 
         if (this.deviceAddressToLocalAddress.has(deviceAddress)) {
-            this.localAddressToHandler.delete(this.deviceAddressToLocalAddress.get(deviceAddress)!);
+            this.localAddressToHandler.delete(
+                this.deviceAddressToLocalAddress.get(deviceAddress)!
+            );
             this.deviceAddressToLocalAddress.delete(deviceAddress);
         }
 

package/src/commands/subprocess/command.ts

@@ -1,7 +1,13 @@
-import { GatherStringStream, DecodeUtf8Stream } from '@yume-chan/stream-extra';
+import { DecodeUtf8Stream, GatherStringStream } from "@yume-chan/stream-extra";
 
-import { AdbCommandBase } from '../base.js';
-import { AdbSubprocessNoneProtocol, AdbSubprocessProtocol, AdbSubprocessProtocolConstructor, AdbSubprocessShellProtocol } from './protocols/index.js';
+import { AdbCommandBase } from "../base.js";
+
+import {
+    AdbSubprocessNoneProtocol,
+    AdbSubprocessShellProtocol,
+    type AdbSubprocessProtocol,
+    type AdbSubprocessProtocolConstructor,
+} from "./protocols/index.js";
 
 export interface AdbSubprocessOptions {
     /**
@@ -30,7 +36,7 @@ export interface AdbSubprocessWaitResult {
 
 export class AdbSubprocess extends AdbCommandBase {
     private async createProtocol(
-        mode: 'pty' | 'raw',
+        mode: "pty" | "raw",
         command?: string | string[],
         options?: Partial<AdbSubprocessOptions>
     ): Promise<AdbSubprocessProtocol> {
@@ -46,14 +52,14 @@ export class AdbSubprocess extends AdbCommandBase {
         }
 
         if (!Constructor) {
-            throw new Error('No specified protocol is supported by the device');
+            throw new Error("No specified protocol is supported by the device");
         }
 
         if (Array.isArray(command)) {
-            command = command.join(' ');
+            command = command.join(" ");
         } else if (command === undefined) {
             // spawn the default shell
-            command = '';
+            command = "";
         }
         return await Constructor[mode](this.adb, command);
     }
@@ -68,7 +74,7 @@ export class AdbSubprocess extends AdbCommandBase {
         command?: string | string[],
         options?: Partial<AdbSubprocessOptions>
     ): Promise<AdbSubprocessProtocol> {
-        return this.createProtocol('pty', command, options);
+        return this.createProtocol("pty", command, options);
     }
 
     /**
@@ -81,7 +87,7 @@ export class AdbSubprocess extends AdbCommandBase {
         command: string | string[],
         options?: Partial<AdbSubprocessOptions>
     ): Promise<AdbSubprocessProtocol> {
-        return this.createProtocol('raw', command, options);
+        return this.createProtocol("raw", command, options);
     }
 
     /**
@@ -100,13 +106,9 @@ export class AdbSubprocess extends AdbCommandBase {
         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
+            shell.stdout.pipeThrough(new DecodeUtf8Stream()).pipeTo(stdout),
+            shell.stderr.pipeThrough(new DecodeUtf8Stream()).pipeTo(stderr),
+            shell.exit,
         ]);
 
         return {
@@ -121,11 +123,12 @@ 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> {
-        const { stdout } = await this.spawnAndWait(
-            command,
-            { protocols: [AdbSubprocessNoneProtocol] }
-        );
+    public async spawnAndWaitLegacy(
+        command: string | string[]
+    ): Promise<string> {
+        const { stdout } = await this.spawnAndWait(command, {
+            protocols: [AdbSubprocessNoneProtocol],
+        });
         return stdout;
     }
 }

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

@@ -1,8 +1,9 @@
 import { DuplexStreamFactory, ReadableStream } from '@yume-chan/stream-extra';
 
-import type { Adb } from '../../../adb.js';
-import type { AdbSocket } from '../../../socket/index.js';
-import type { AdbSubprocessProtocol } from './types.js';
+import { type Adb } from "../../../adb.js";
+import { type AdbSocket } from "../../../socket/index.js";
+
+import { type AdbSubprocessProtocol } from "./types.js";
 
 /**
  * The legacy shell