@yume-chan/adb 1.1.0 → 2.0.0

package/src/commands/sync/response.ts

@@ -1,7 +1,9 @@
 import { getUint32LittleEndian } from "@yume-chan/no-data-view";
-import type { AsyncExactReadable, StructLike } from "@yume-chan/struct";
+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 {
     const result = new Uint8Array(value.length);
     for (let i = 0; i < value.length; i += 1) {
@@ -49,7 +51,7 @@ export const AdbSyncFailResponse = struct(
 export async function adbSyncReadResponse<T>(
     stream: AsyncExactReadable,
     id: number | string,
-    type: StructLike<T>,
+    type: StructDeserializer<T>,
 ): Promise<T> {
     if (typeof id === "string") {
         id = adbSyncEncodeId(id);
@@ -72,7 +74,7 @@ export async function adbSyncReadResponse<T>(
 export async function* adbSyncReadResponses<T>(
     stream: AsyncExactReadable,
     id: number | string,
-    type: StructLike<T>,
+    type: StructDeserializer<T>,
 ): AsyncGenerator<T, void, void> {
     if (typeof id === "string") {
         id = adbSyncEncodeId(id);
@@ -83,7 +85,7 @@ export async function* adbSyncReadResponses<T>(
         switch (getUint32LittleEndian(buffer, 0)) {
             case AdbSyncResponseId.Fail:
                 await AdbSyncFailResponse.deserialize(stream);
-                throw new Error("Unreachable");
+                unreachable();
             case AdbSyncResponseId.Done:
                 // `DONE` responses' size are always same as the request's normal response.
                 //

package/src/commands/sync/sync.ts

@@ -151,7 +151,7 @@ export class AdbSync {
             // It may fail if `filename` already exists.
             // Ignore the result.
             // TODO: sync: test push mkdir workaround (need an Android 8 device)
-            await this._adb.subprocess.spawnAndWait([
+            await this._adb.subprocess.noneProtocol.spawnWait([
                 "mkdir",
                 "-p",
                 escapeArg(dirname(options.filename)),

package/src/commands/tcpip.ts

@@ -1,4 +1,4 @@
-import { AdbCommandBase } from "./base.js";
+import { AdbServiceBase } from "./base.js";
 
 /**
  * ADB daemon checks for the following properties in the order of
@@ -27,7 +27,7 @@ function parsePort(value: string): number | undefined {
     return Number.parseInt(value, 10);
 }
 
-export class AdbTcpIpCommand extends AdbCommandBase {
+export class AdbTcpIpService extends AdbServiceBase {
     async getListenAddresses(): Promise<AdbTcpIpListenAddresses> {
         const serviceListenAddresses = await this.adb.getProp(
             "service.adb.listen_addrs",

package/src/daemon/dispatcher.ts

@@ -101,18 +101,21 @@ export class AdbPacketDispatcher implements Closeable {
      */
     readonly #sockets = new Map<number, AdbDaemonSocketController>();
 
-    #writer: WritableStreamDefaultWriter<Consumable<AdbPacketInit>>;
+    readonly #writer: WritableStreamDefaultWriter<Consumable<AdbPacketInit>>;
 
     readonly options: AdbPacketDispatcherOptions;
 
     #closed = false;
-    #disconnected = new PromiseResolver<void>();
+    readonly #disconnected = new PromiseResolver<void>();
     get disconnected() {
         return this.#disconnected.promise;
     }
 
-    #incomingSocketHandlers = new Map<string, AdbIncomingSocketHandler>();
-    #readAbortController = new AbortController();
+    readonly #incomingSocketHandlers = new Map<
+        string,
+        AdbIncomingSocketHandler
+    >();
+    readonly #readAbortController = new AbortController();
 
     constructor(
         connection: ReadableWritablePair<

package/src/daemon/packet.ts

@@ -1,6 +1,6 @@
 import { Consumable, TransformStream } from "@yume-chan/stream-extra";
 import type { StructInit, StructValue } from "@yume-chan/struct";
-import { buffer, s32, struct, u32 } from "@yume-chan/struct";
+import { buffer, extend, s32, struct, u32 } from "@yume-chan/struct";
 
 export const AdbCommand = {
     Auth: 0x48545541, // 'AUTH'
@@ -29,13 +29,9 @@ export type AdbPacketHeader = StructValue<typeof AdbPacketHeader>;
 
 type AdbPacketHeaderInit = StructInit<typeof AdbPacketHeader>;
 
-export const AdbPacket = struct(
-    /* #__PURE__ */ (() => ({
-        ...AdbPacketHeader.fields,
-        payload: buffer("payloadLength"),
-    }))(),
-    { littleEndian: true },
-);
+export const AdbPacket = extend(AdbPacketHeader, {
+    payload: buffer("payloadLength"),
+});
 
 export type AdbPacket = StructValue<typeof AdbPacket>;
 

package/src/daemon/socket.ts

@@ -43,7 +43,7 @@ export class AdbDaemonSocketController
     readonly localCreated!: boolean;
     readonly service!: string;
 
-    #readable: ReadableStream<Uint8Array>;
+    readonly #readable: ReadableStream<Uint8Array>;
     #readableController!: PushReadableStreamController<Uint8Array>;
     get readable() {
         return this.#readable;
@@ -54,12 +54,12 @@ export class AdbDaemonSocketController
 
     #closed = false;
 
-    #closedPromise = new PromiseResolver<void>();
+    readonly #closedPromise = new PromiseResolver<undefined>();
     get closed() {
         return this.#closedPromise.promise;
     }
 
-    #socket: AdbDaemonSocket;
+    readonly #socket: AdbDaemonSocket;
     get socket() {
         return this.#socket;
     }
@@ -170,7 +170,7 @@ export class AdbDaemonSocketController
 
     dispose() {
         this.#readableController.close();
-        this.#closedPromise.resolve();
+        this.#closedPromise.resolve(undefined);
     }
 }
 
@@ -178,7 +178,7 @@ export class AdbDaemonSocketController
  * A duplex stream representing a socket to ADB daemon.
  */
 export class AdbDaemonSocket implements AdbDaemonSocketInfo, AdbSocket {
-    #controller: AdbDaemonSocketController;
+    readonly #controller: AdbDaemonSocketController;
 
     get localId(): number {
         return this.#controller.localId;
@@ -200,7 +200,7 @@ export class AdbDaemonSocket implements AdbDaemonSocketInfo, AdbSocket {
         return this.#controller.writable;
     }
 
-    get closed(): Promise<void> {
+    get closed(): Promise<undefined> {
         return this.#controller.closed;
     }
 

package/src/device-observer.ts

@@ -2,9 +2,9 @@ import type { MaybePromiseLike } from "@yume-chan/async";
 import type { Event } from "@yume-chan/event";
 
 export interface DeviceObserver<T> {
-    onDeviceAdd: Event<T[]>;
-    onDeviceRemove: Event<T[]>;
-    onListChange: Event<T[]>;
-    current: T[];
+    readonly onDeviceAdd: Event<readonly T[]>;
+    readonly onDeviceRemove: Event<readonly T[]>;
+    readonly onListChange: Event<readonly T[]>;
+    readonly current: readonly T[];
     stop(): MaybePromiseLike<void>;
 }

package/src/server/client.ts

@@ -15,16 +15,27 @@ import type { AdbIncomingSocketHandler, AdbSocket, Closeable } from "../adb.js";
 import { AdbBanner } from "../banner.js";
 import type { DeviceObserver as DeviceObserverBase } from "../device-observer.js";
 import type { AdbFeature } from "../features.js";
-import { hexToNumber, sequenceEqual } from "../utils/index.js";
-
+import { hexToNumber } from "../utils/index.js";
+
+import {
+    MDnsCommands,
+    WirelessCommands,
+    AlreadyConnectedError as _AlreadyConnectedError,
+    NetworkError as _NetworkError,
+    UnauthorizedError as _UnauthorizedError,
+} from "./commands/index.js";
 import { AdbServerDeviceObserverOwner } from "./observer.js";
-import { AdbServerStream, FAIL } from "./stream.js";
+import { AdbServerStream } from "./stream.js";
 import { AdbServerTransport } from "./transport.js";
 
 /**
  * Client for the ADB Server.
  */
 export class AdbServerClient {
+    static NetworkError = _NetworkError;
+    static UnauthorizedError = _UnauthorizedError;
+    static AlreadyConnectedError = _AlreadyConnectedError;
+
     static parseDeviceList(value: string): AdbServerClient.Device[] {
         const devices: AdbServerClient.Device[] = [];
         for (const line of value.split("\n")) {
@@ -99,9 +110,9 @@ export class AdbServerClient {
 
     readonly connector: AdbServerClient.ServerConnector;
 
-    readonly wireless = new AdbServerClient.WirelessCommands(this);
-    readonly mDns = new AdbServerClient.MDnsCommands(this);
-    #observerOwner = new AdbServerDeviceObserverOwner(this);
+    readonly wireless = new WirelessCommands(this);
+    readonly mDns = new MDnsCommands(this);
+    readonly #observerOwner = new AdbServerDeviceObserverOwner(this);
 
     constructor(connector: AdbServerClient.ServerConnector) {
         this.connector = connector;
@@ -447,10 +458,7 @@ export class AdbServerClient {
             disconnected,
         );
 
-        transport.disconnected.then(
-            () => waitAbortController.abort(),
-            () => waitAbortController.abort(),
-        );
+        void transport.disconnected.finally(() => waitAbortController.abort());
 
         return transport;
     }
@@ -496,7 +504,7 @@ export namespace AdbServerClient {
     export interface ServerConnection
         extends ReadableWritablePair<Uint8Array, MaybeConsumable<Uint8Array>>,
             Closeable {
-        get closed(): Promise<void>;
+        get closed(): Promise<undefined>;
     }
 
     export interface ServerConnector {
@@ -537,138 +545,11 @@ export namespace AdbServerClient {
         transportId: bigint;
     }
 
-    export class NetworkError extends Error {
-        constructor(message: string) {
-            super(message);
-            this.name = "NetworkError";
-        }
-    }
-
-    export class UnauthorizedError extends Error {
-        constructor(message: string) {
-            super(message);
-            this.name = "UnauthorizedError";
-        }
-    }
-
-    export class AlreadyConnectedError extends Error {
-        constructor(message: string) {
-            super(message);
-            this.name = "AlreadyConnectedError";
-        }
-    }
-
-    export class WirelessCommands {
-        #client: AdbServerClient;
-
-        constructor(client: AdbServerClient) {
-            this.#client = client;
-        }
-
-        /**
-         * `adb pair <password> <address>`
-         */
-        async pair(address: string, password: string): Promise<void> {
-            const connection = await this.#client.createConnection(
-                `host:pair:${password}:${address}`,
-            );
-            try {
-                const response = await connection.readExactly(4);
-                // `response` is either `FAIL`, or 4 hex digits for length of the string
-                if (sequenceEqual(response, FAIL)) {
-                    throw new Error(await connection.readString());
-                }
-                const length = hexToNumber(response);
-                // Ignore the string as it's always `Successful ...`
-                await connection.readExactly(length);
-            } finally {
-                await connection.dispose();
-            }
-        }
-
-        /**
-         * `adb connect <address>`
-         */
-        async connect(address: string): Promise<void> {
-            const connection = await this.#client.createConnection(
-                `host:connect:${address}`,
-            );
-            try {
-                const response = await connection.readString();
-                switch (response) {
-                    case `already connected to ${address}`:
-                        throw new AdbServerClient.AlreadyConnectedError(
-                            response,
-                        );
-                    case `failed to connect to ${address}`: // `adb pair` mode not authorized
-                    case `failed to authenticate to ${address}`: // `adb tcpip` mode not authorized
-                        throw new AdbServerClient.UnauthorizedError(response);
-                    case `connected to ${address}`:
-                        return;
-                    default:
-                        throw new AdbServerClient.NetworkError(response);
-                }
-            } finally {
-                await connection.dispose();
-            }
-        }
-
-        /**
-         * `adb disconnect <address>`
-         */
-        async disconnect(address: string): Promise<void> {
-            const connection = await this.#client.createConnection(
-                `host:disconnect:${address}`,
-            );
-            try {
-                await connection.readString();
-            } finally {
-                await connection.dispose();
-            }
-        }
-    }
-
-    export class MDnsCommands {
-        #client: AdbServerClient;
-
-        constructor(client: AdbServerClient) {
-            this.#client = client;
-        }
-
-        async check() {
-            const connection =
-                await this.#client.createConnection("host:mdns:check");
-            try {
-                const response = await connection.readString();
-                return !response.startsWith("ERROR:");
-            } finally {
-                await connection.dispose();
-            }
-        }
-
-        async getServices() {
-            const connection =
-                await this.#client.createConnection("host:mdns:services");
-            try {
-                const response = await connection.readString();
-                return response
-                    .split("\n")
-                    .filter(Boolean)
-                    .map((line) => {
-                        const parts = line.split("\t");
-                        return {
-                            name: parts[0]!,
-                            service: parts[1]!,
-                            address: parts[2]!,
-                        };
-                    });
-            } finally {
-                await connection.dispose();
-            }
-        }
-    }
-
     export interface DeviceObserver extends DeviceObserverBase<Device> {
         onError: Event<Error>;
     }
+
+    export type NetworkError = _NetworkError;
+    export type UnauthorizedError = _UnauthorizedError;
+    export type AlreadyConnectedError = _AlreadyConnectedError;
 }

package/src/server/commands/index.ts

@@ -0,0 +1,2 @@
+export * from "./m-dns.js";
+export * from "./wireless.js";

package/src/server/commands/m-dns.ts

@@ -0,0 +1,43 @@
+// cspell:ignore mdns
+
+import type { AdbServerClient } from "../client.js";
+
+export class MDnsCommands {
+    readonly #client: AdbServerClient;
+
+    constructor(client: AdbServerClient) {
+        this.#client = client;
+    }
+
+    async check() {
+        const connection =
+            await this.#client.createConnection("host:mdns:check");
+        try {
+            const response = await connection.readString();
+            return !response.startsWith("ERROR:");
+        } finally {
+            await connection.dispose();
+        }
+    }
+
+    async getServices() {
+        const connection =
+            await this.#client.createConnection("host:mdns:services");
+        try {
+            const response = await connection.readString();
+            return response
+                .split("\n")
+                .filter(Boolean)
+                .map((line) => {
+                    const parts = line.split("\t");
+                    return {
+                        name: parts[0]!,
+                        service: parts[1]!,
+                        address: parts[2]!,
+                    };
+                });
+        } finally {
+            await connection.dispose();
+        }
+    }
+}

package/src/server/commands/wireless.ts

@@ -0,0 +1,94 @@
+// cspell:ignore tport
+
+import { hexToNumber, sequenceEqual } from "../../utils/index.js";
+import type { AdbServerClient } from "../client.js";
+import { FAIL } from "../stream.js";
+
+export class NetworkError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = "NetworkError";
+    }
+}
+
+export class UnauthorizedError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = "UnauthorizedError";
+    }
+}
+
+export class AlreadyConnectedError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = "AlreadyConnectedError";
+    }
+}
+
+export class WirelessCommands {
+    readonly #client: AdbServerClient;
+
+    constructor(client: AdbServerClient) {
+        this.#client = client;
+    }
+
+    /**
+     * `adb pair <password> <address>`
+     */
+    async pair(address: string, password: string): Promise<void> {
+        const connection = await this.#client.createConnection(
+            `host:pair:${password}:${address}`,
+        );
+        try {
+            const response = await connection.readExactly(4);
+            // `response` is either `FAIL`, or 4 hex digits for length of the string
+            if (sequenceEqual(response, FAIL)) {
+                throw new Error(await connection.readString());
+            }
+            const length = hexToNumber(response);
+            // Ignore the string as it's always `Successful ...`
+            await connection.readExactly(length);
+        } finally {
+            await connection.dispose();
+        }
+    }
+
+    /**
+     * `adb connect <address>`
+     */
+    async connect(address: string): Promise<void> {
+        const connection = await this.#client.createConnection(
+            `host:connect:${address}`,
+        );
+        try {
+            const response = await connection.readString();
+            switch (response) {
+                case `already connected to ${address}`:
+                    throw new AlreadyConnectedError(response);
+                case `failed to connect to ${address}`: // `adb pair` mode not authorized
+                case `failed to authenticate to ${address}`: // `adb tcpip` mode not authorized
+                    throw new UnauthorizedError(response);
+                case `connected to ${address}`:
+                    return;
+                default:
+                    throw new NetworkError(response);
+            }
+        } finally {
+            await connection.dispose();
+        }
+    }
+
+    /**
+     * `adb disconnect <address>`
+     */
+    async disconnect(address: string): Promise<void> {
+        const connection = await this.#client.createConnection(
+            `host:disconnect:${address}`,
+        );
+        try {
+            await connection.readString();
+        } finally {
+            await connection.dispose();
+        }
+    }
+}