@yume-chan/adb 0.0.23 → 0.0.24

package/src/server/client.ts

@@ -1,6 +1,7 @@
 // cspell:ignore tport
 
 import { PromiseResolver } from "@yume-chan/async";
+import { getUint64LittleEndian } from "@yume-chan/no-data-view";
 import type {
     AbortSignal,
     ReadableWritablePair,
@@ -8,16 +9,11 @@ import type {
 } from "@yume-chan/stream-extra";
 import {
     BufferedReadableStream,
-    UnwrapConsumableStream,
+    MaybeConsumable,
     WrapWritableStream,
 } from "@yume-chan/stream-extra";
-import type {
-    AsyncExactReadable,
-    ExactReadable,
-    ValueOrPromise,
-} from "@yume-chan/struct";
+import type { ValueOrPromise } from "@yume-chan/struct";
 import {
-    BigIntFieldType,
     EMPTY_UINT8_ARRAY,
     SyncPromise,
     decodeUtf8,
@@ -27,163 +23,164 @@ import {
 import type { AdbIncomingSocketHandler, AdbSocket, Closeable } from "../adb.js";
 import { AdbBanner } from "../banner.js";
 import type { AdbFeature } from "../features.js";
-import { NOOP, hexToNumber, numberToHex, unreachable } from "../utils/index.js";
+import {
+    NOOP,
+    hexToNumber,
+    sequenceEqual,
+    write4HexDigits,
+} from "../utils/index.js";
 
 import { AdbServerTransport } from "./transport.js";
 
-export interface AdbServerConnectionOptions {
-    unref?: boolean | undefined;
-    signal?: AbortSignal | undefined;
-}
-
-export interface AdbServerConnection
-    extends ReadableWritablePair<Uint8Array, Uint8Array>,
-        Closeable {
-    get closed(): Promise<void>;
-}
-
-export interface AdbServerConnector {
-    connect(
-        options?: AdbServerConnectionOptions,
-    ): ValueOrPromise<AdbServerConnection>;
-
-    addReverseTunnel(
-        handler: AdbIncomingSocketHandler,
-        address?: string,
-    ): ValueOrPromise<string>;
-
-    removeReverseTunnel(address: string): ValueOrPromise<void>;
+const OKAY = encodeUtf8("OKAY");
+const FAIL = encodeUtf8("FAIL");
 
-    clearReverseTunnels(): ValueOrPromise<void>;
-}
-
-export interface AdbServerSocket extends AdbSocket {
-    transportId: bigint;
-}
-
-export type AdbServerDeviceSelector =
-    | { transportId: bigint }
-    | { serial: string }
-    | { usb: true }
-    | { tcp: true }
-    | undefined;
-
-export interface AdbServerDevice {
-    serial: string;
-    product?: string | undefined;
-    model?: string | undefined;
-    device?: string | undefined;
-    transportId: bigint;
-}
-
-export class AdbServerClient {
-    static readonly VERSION = 41;
+class AdbServerStream {
+    #connection: AdbServerClient.ServerConnection;
+    #buffered: BufferedReadableStream;
+    #writer: WritableStreamDefaultWriter<Uint8Array>;
 
-    readonly connection: AdbServerConnector;
+    constructor(connection: AdbServerClient.ServerConnection) {
+        this.#connection = connection;
+        this.#buffered = new BufferedReadableStream(connection.readable);
+        this.#writer = connection.writable.getWriter();
+    }
 
-    constructor(connection: AdbServerConnector) {
-        this.connection = connection;
+    readExactly(length: number): ValueOrPromise<Uint8Array> {
+        return this.#buffered.readExactly(length);
     }
 
-    static readString(stream: ExactReadable): string;
-    static readString(stream: AsyncExactReadable): PromiseLike<string>;
-    static readString(
-        stream: ExactReadable | AsyncExactReadable,
-    ): string | PromiseLike<string> {
-        return SyncPromise.try(() => stream.readExactly(4))
+    readString() {
+        return SyncPromise.try(() => this.readExactly(4))
             .then((buffer) => {
                 const length = hexToNumber(buffer);
                 if (length === 0) {
                     return EMPTY_UINT8_ARRAY;
                 } else {
-                    return stream.readExactly(length);
+                    return this.readExactly(length);
                 }
             })
-            .then((valueBuffer) => {
-                return decodeUtf8(valueBuffer);
+            .then((buffer) => {
+                // TODO: Investigate using stream mode `TextDecoder` for long strings.
+                // Because concatenating strings uses rope data structure,
+                // which only points to the original strings and doesn't copy the data,
+                // it's more efficient than concatenating `Uint8Array`s.
+                //
+                // ```
+                // const decoder = new TextDecoder();
+                // let result = '';
+                // for await (const chunk of stream.iterateExactly(length)) {
+                //     result += decoder.decode(chunk, { stream: true });
+                // }
+                // result += decoder.decode();
+                // return result;
+                // ```
+                //
+                // Although, it will be super complex to use `SyncPromise` with async iterator,
+                // `stream.iterateExactly` need to return an
+                // `Iterator<Uint8Array | Promise<Uint8Array>>` instead of a true async iterator.
+                // Maybe `SyncPromise` should support async iterators directly.
+                return decodeUtf8(buffer);
             })
             .valueOrPromise();
     }
 
-    static async writeString(
-        writer: WritableStreamDefaultWriter<Uint8Array>,
-        value: string,
-    ): Promise<void> {
-        const valueBuffer = encodeUtf8(value);
-        const buffer = new Uint8Array(4 + valueBuffer.length);
-        buffer.set(numberToHex(valueBuffer.length));
-        buffer.set(valueBuffer, 4);
-        await writer.write(buffer);
+    async writeString(value: string): Promise<void> {
+        // TODO: investigate using `encodeUtf8("0000" + value)` then modifying the length
+        // That way allocates a new string (hopefully only a rope) instead of a new buffer
+        const encoded = encodeUtf8(value);
+        const buffer = new Uint8Array(4 + encoded.length);
+        write4HexDigits(buffer, 0, encoded.length);
+        buffer.set(encoded, 4);
+        await this.#writer.write(buffer);
     }
 
-    static async readOkay(
-        stream: ExactReadable | AsyncExactReadable,
-    ): Promise<void> {
-        const response = decodeUtf8(await stream.readExactly(4));
-        if (response === "OKAY") {
+    async readOkay(): Promise<void> {
+        const response = await this.readExactly(4);
+        if (sequenceEqual(response, OKAY)) {
+            // `OKAY` is followed by data length and data
+            // But different services want to parse the data differently
+            // So don't read the data here
             return;
         }
 
-        if (response === "FAIL") {
-            const reason = await AdbServerClient.readString(stream);
+        if (sequenceEqual(response, FAIL)) {
+            const reason = await this.readString();
             throw new Error(reason);
         }
 
-        throw new Error(`Unexpected response: ${response}`);
+        throw new Error(`Unexpected response: ${decodeUtf8(response)}`);
+    }
+
+    release() {
+        this.#writer.releaseLock();
+        return {
+            readable: this.#buffered.release(),
+            writable: this.#connection.writable,
+            closed: this.#connection.closed,
+            close: () => this.#connection.close(),
+        };
+    }
+
+    async dispose() {
+        await this.#buffered.cancel().catch(NOOP);
+        await this.#writer.close().catch(NOOP);
+        try {
+            await this.#connection.close();
+        } catch {
+            // ignore
+        }
+    }
+}
+
+export class AdbServerClient {
+    static readonly VERSION = 41;
+
+    readonly connector: AdbServerClient.ServerConnector;
+
+    readonly wireless = new AdbServerClient.WirelessCommands(this);
+    readonly mDns = new AdbServerClient.MDnsCommands(this);
+
+    constructor(connection: AdbServerClient.ServerConnector) {
+        this.connector = connection;
     }
 
-    async connect(
+    async createConnection(
         request: string,
-        options?: AdbServerConnectionOptions,
-    ): Promise<AdbServerConnection> {
-        const connection = await this.connection.connect(options);
+        options?: AdbServerClient.ServerConnectionOptions,
+    ): Promise<AdbServerStream> {
+        const connection = await this.connector.connect(options);
+        const stream = new AdbServerStream(connection);
 
         try {
-            const writer = connection.writable.getWriter();
-            await AdbServerClient.writeString(writer, request);
-            writer.releaseLock();
+            await stream.writeString(request);
         } catch (e) {
-            await connection.readable.cancel();
-            await connection.close();
+            await stream.dispose();
             throw e;
         }
 
-        const readable = new BufferedReadableStream(connection.readable);
         try {
             // `raceSignal` throws when the signal is aborted,
             // so the `catch` block can close the connection.
-            await raceSignal(
-                () => AdbServerClient.readOkay(readable),
-                options?.signal,
-            );
-
-            return {
-                readable: readable.release(),
-                writable: connection.writable,
-                get closed() {
-                    return connection.closed;
-                },
-                async close() {
-                    await connection.close();
-                },
-            };
+            await raceSignal(() => stream.readOkay(), options?.signal);
+            return stream;
         } catch (e) {
-            await readable.cancel().catch(NOOP);
-            await connection.close();
+            await stream.dispose();
             throw e;
         }
     }
 
+    /**
+     * `adb version`
+     */
     async getVersion(): Promise<number> {
-        const connection = await this.connect("host:version");
-        const readable = new BufferedReadableStream(connection.readable);
+        const connection = await this.createConnection("host:version");
         try {
-            const length = hexToNumber(await readable.readExactly(4));
-            const version = hexToNumber(await readable.readExactly(length));
+            const length = hexToNumber(await connection.readExactly(4));
+            const version = hexToNumber(await connection.readExactly(length));
             return version;
         } finally {
-            connection.writable.close().catch(NOOP);
-            readable.cancel().catch(NOOP);
+            await connection.dispose();
         }
     }
 
@@ -196,26 +193,29 @@ export class AdbServerClient {
         }
     }
 
+    /**
+     * `adb kill-server`
+     */
     async killServer(): Promise<void> {
-        const connection = await this.connect("host:kill");
-        connection.writable.close().catch(NOOP);
-        connection.readable.cancel().catch(NOOP);
+        const connection = await this.createConnection("host:kill");
+        await connection.dispose();
     }
 
+    /**
+     * `adb host-features`
+     */
     async getServerFeatures(): Promise<AdbFeature[]> {
-        const connection = await this.connect("host:host-features");
-        const readable = new BufferedReadableStream(connection.readable);
+        const connection = await this.createConnection("host:host-features");
         try {
-            const response = await AdbServerClient.readString(readable);
+            const response = await connection.readString();
             return response.split(",") as AdbFeature[];
         } finally {
-            connection.writable.close().catch(NOOP);
-            readable.cancel().catch(NOOP);
+            await connection.dispose();
         }
     }
 
-    parseDeviceList(value: string): AdbServerDevice[] {
-        const devices: AdbServerDevice[] = [];
+    parseDeviceList(value: string): AdbServerClient.Device[] {
+        const devices: AdbServerClient.Device[] = [];
         for (const line of value.split("\n")) {
             if (!line) {
                 continue;
@@ -224,7 +224,7 @@ export class AdbServerClient {
             const parts = line.split(" ").filter(Boolean);
             const serial = parts[0]!;
             const status = parts[1]!;
-            if (status !== "device") {
+            if (status !== "device" && status !== "unauthorized") {
                 continue;
             }
 
@@ -254,6 +254,7 @@ export class AdbServerClient {
             }
             devices.push({
                 serial,
+                authenticating: status === "unauthorized",
                 product,
                 model,
                 device,
@@ -263,43 +264,52 @@ export class AdbServerClient {
         return devices;
     }
 
-    async getDevices(): Promise<AdbServerDevice[]> {
-        const connection = await this.connect("host:devices-l");
-        const readable = new BufferedReadableStream(connection.readable);
+    /**
+     * `adb devices -l`
+     */
+    async getDevices(): Promise<AdbServerClient.Device[]> {
+        const connection = await this.createConnection("host:devices-l");
         try {
-            const response = await AdbServerClient.readString(readable);
+            const response = await connection.readString();
             return this.parseDeviceList(response);
         } finally {
-            connection.writable.close().catch(NOOP);
-            readable.cancel().catch(NOOP);
+            await connection.dispose();
         }
     }
 
-    async trackDevices(
-        callback: (devices: AdbServerDevice[]) => void,
-    ): Promise<() => void> {
-        const connection = await this.connect("host:track-devices-l");
-        const readable = new BufferedReadableStream(connection.readable);
-        let running = true;
-        (async () => {
-            try {
-                while (running) {
-                    const response = await AdbServerClient.readString(readable);
-                    const devices = this.parseDeviceList(response);
-                    callback(devices);
-                }
-            } catch {
-                // ignore
+    /**
+     * Track the device list.
+     *
+     * @param signal An optional `AbortSignal` to stop tracking
+     *
+     * When `signal` is aborted, `trackDevices` will return normally, instead of throwing `signal.reason`.
+     */
+    async *trackDevices(
+        signal?: AbortSignal,
+    ): AsyncGenerator<AdbServerClient.Device[], void, void> {
+        const connection = await this.createConnection("host:track-devices-l");
+        try {
+            while (true) {
+                const response = await raceSignal(
+                    async () => await connection.readString(),
+                    signal,
+                );
+                const devices = this.parseDeviceList(response);
+                yield devices;
             }
-        })().catch(unreachable);
-        return () => {
-            running = false;
-            readable.cancel().catch(NOOP);
-            Promise.resolve(connection.close()).catch(NOOP);
-        };
+        } catch (e) {
+            if (e === signal?.reason) {
+                return;
+            }
+        } finally {
+            await connection.dispose();
+        }
     }
 
-    formatDeviceService(device: AdbServerDeviceSelector, command: string) {
+    formatDeviceService(
+        device: AdbServerClient.DeviceSelector,
+        command: string,
+    ) {
         if (!device) {
             return `host:${command}`;
         }
@@ -315,7 +325,23 @@ export class AdbServerClient {
         if ("tcp" in device) {
             return `host-local:${command}`;
         }
-        throw new Error("Invalid device selector");
+        throw new TypeError("Invalid device selector");
+    }
+
+    /**
+     * `adb -s <device> reconnect` or `adb reconnect offline`
+     */
+    async reconnectDevice(device: AdbServerClient.DeviceSelector | "offline") {
+        const connection = await this.createConnection(
+            device === "offline"
+                ? "host:reconnect-offline"
+                : this.formatDeviceService(device, "reconnect"),
+        );
+        try {
+            await connection.readString();
+        } finally {
+            await connection.dispose();
+        }
     }
 
     /**
@@ -326,23 +352,36 @@ export class AdbServerClient {
      * @returns The transport ID of the selected device, and the features supported by the device.
      */
     async getDeviceFeatures(
-        device: AdbServerDeviceSelector,
+        device: AdbServerClient.DeviceSelector,
     ): Promise<{ transportId: bigint; features: AdbFeature[] }> {
-        // Usually the client sends a device command using `connectDevice`,
-        // so the command got forwarded and handled by ADB daemon.
-        // However, in fact, `connectDevice` only forwards unknown services to device,
-        // if the service is a host command, it will still be handled by ADB server.
-        // Also, if the command is about a device, but didn't specify a selector,
-        // it will be executed against the device selected previously by `connectDevice`.
-        // Using this method, we can get the transport ID and device features in one connection.
-        const socket = await this.connectDevice(device, "host:features");
+        // On paper, `host:features` is a host service (device features are cached in host),
+        // so it shouldn't use `createDeviceConnection`,
+        // which is used to forward the service to the device.
+        //
+        // However, `createDeviceConnection` is a two step process:
+        //
+        //    1. Send a switch device service to host, to switch the connection to the device.
+        //    2. Send the actual service to host, let it forward the service to the device.
+        //
+        // In step 2, the host only forward the service to device if the service is unknown to host.
+        // If the service is a host service, it's still handled by host.
+        //
+        // Even better, if the service needs a device selector, but the selector is not provided,
+        // the service will be executed against the device selected by the switch device service.
+        // So we can use all device selector formats for the host service,
+        // and get the transport ID in the same time.
+        const connection = await this.createDeviceConnection(
+            device,
+            "host:features",
+        );
+        // Luckily `AdbServerClient.Socket` is compatible with `AdbServerClient.ServerConnection`
+        const stream = new AdbServerStream(connection);
         try {
-            const readable = new BufferedReadableStream(socket.readable);
-            const featuresString = await AdbServerClient.readString(readable);
+            const featuresString = await stream.readString();
             const features = featuresString.split(",") as AdbFeature[];
-            return { transportId: socket.transportId, features };
+            return { transportId: connection.transportId, features };
         } finally {
-            await socket.close();
+            await stream.dispose();
         }
     }
 
@@ -350,12 +389,12 @@ export class AdbServerClient {
      * Creates a connection that will forward the service to device.
      * @param device The device selector
      * @param service The service to forward
-     * @returns An `AdbServerSocket` that can be used to communicate with the service
+     * @returns An `AdbServerClient.Socket` that can be used to communicate with the service
      */
-    async connectDevice(
-        device: AdbServerDeviceSelector,
+    async createDeviceConnection(
+        device: AdbServerClient.DeviceSelector,
         service: string,
-    ): Promise<AdbServerSocket> {
+    ): Promise<AdbServerClient.Socket> {
         await this.validateVersion();
 
         let switchService: string;
@@ -372,68 +411,62 @@ export class AdbServerClient {
         } else if ("tcp" in device) {
             switchService = `host:tport:local`;
         } else {
-            throw new Error("Invalid device selector");
+            throw new TypeError("Invalid device selector");
         }
 
-        const connection = await this.connect(switchService);
+        const connection = await this.createConnection(switchService);
 
         try {
-            const writer = connection.writable.getWriter();
-            await AdbServerClient.writeString(writer, service);
-            writer.releaseLock();
+            await connection.writeString(service);
         } catch (e) {
-            await connection.readable.cancel();
-            await connection.close();
+            await connection.dispose();
             throw e;
         }
 
-        const readable = new BufferedReadableStream(connection.readable);
         try {
             if (transportId === undefined) {
-                const array = await readable.readExactly(8);
-                // TODO: switch to a more performant algorithm.
-                const dataView = new DataView(
-                    array.buffer,
-                    array.byteOffset,
-                    array.byteLength,
-                );
-                transportId = BigIntFieldType.Uint64.getter(dataView, 0, true);
+                const array = await connection.readExactly(8);
+                transportId = getUint64LittleEndian(array, 0);
             }
 
-            await AdbServerClient.readOkay(readable);
+            await connection.readOkay();
+
+            const socket = connection.release();
 
             return {
                 transportId,
                 service,
-                readable: readable.release(),
+                readable: socket.readable,
                 writable: new WrapWritableStream(
-                    connection.writable,
-                ).bePipedThroughFrom(new UnwrapConsumableStream()),
+                    socket.writable,
+                ).bePipedThroughFrom(new MaybeConsumable.UnwrapStream()),
                 get closed() {
-                    return connection.closed;
+                    return socket.closed;
                 },
                 async close() {
-                    await connection.close();
+                    await socket.close();
                 },
             };
         } catch (e) {
-            await readable.cancel().catch(NOOP);
-            await connection.close();
+            await connection.dispose();
             throw e;
         }
     }
 
     /**
      * Wait for a device to be connected or disconnected.
+     *
+     * `adb wait-for-<state>`
+     *
      * @param device The device selector
      * @param state The state to wait for
      * @param options The options
      * @returns A promise that resolves when the condition is met.
      */
     async waitFor(
-        device: AdbServerDeviceSelector,
+        device: AdbServerClient.DeviceSelector,
         state: "device" | "disconnect",
-        options?: AdbServerConnectionOptions,
+        options?: AdbServerClient.ServerConnectionOptions,
     ): Promise<void> {
         let type: string;
         if (!device) {
@@ -447,7 +480,7 @@ export class AdbServerClient {
         } else if ("tcp" in device) {
             type = "local";
         } else {
-            throw new Error("Invalid device selector");
+            throw new TypeError("Invalid device selector");
         }
 
         // `waitFor` can't use `connectDevice`, because the device
@@ -457,16 +490,16 @@ export class AdbServerClient {
             `wait-for-${type}-${state}`,
         );
 
-        const socket = await this.connect(service, options);
-        const readable = new BufferedReadableStream(socket.readable);
-        await AdbServerClient.readOkay(readable);
-
-        await readable.cancel();
-        await socket.close();
+        const connection = await this.createConnection(service, options);
+        try {
+            await connection.readOkay();
+        } finally {
+            await connection.dispose();
+        }
     }
 
     async createTransport(
-        device: AdbServerDeviceSelector,
+        device: AdbServerClient.DeviceSelector,
     ): Promise<AdbServerTransport> {
         const { transportId, features } = await this.getDeviceFeatures(device);
 
@@ -492,7 +525,7 @@ export class AdbServerClient {
 }
 
 export async function raceSignal<T>(
-    callback: () => Promise<T>,
+    callback: () => PromiseLike<T>,
     ...signals: (AbortSignal | undefined)[]
 ): Promise<T> {
     const abortPromise = new PromiseResolver<never>();
@@ -521,3 +554,182 @@ export async function raceSignal<T>(
         }
     }
 }
+
+export namespace AdbServerClient {
+    export interface ServerConnectionOptions {
+        unref?: boolean | undefined;
+        signal?: AbortSignal | undefined;
+    }
+
+    export interface ServerConnection
+        extends ReadableWritablePair<Uint8Array, Uint8Array>,
+            Closeable {
+        get closed(): Promise<void>;
+    }
+
+    export interface ServerConnector {
+        connect(
+            options?: ServerConnectionOptions,
+        ): ValueOrPromise<ServerConnection>;
+
+        addReverseTunnel(
+            handler: AdbIncomingSocketHandler,
+            address?: string,
+        ): ValueOrPromise<string>;
+
+        removeReverseTunnel(address: string): ValueOrPromise<void>;
+
+        clearReverseTunnels(): ValueOrPromise<void>;
+    }
+
+    export interface Socket extends AdbSocket {
+        transportId: bigint;
+    }
+
+    export type DeviceSelector =
+        | { transportId: bigint }
+        | { serial: string }
+        | { usb: true }
+        | { tcp: true }
+        | undefined;
+
+    export interface Device {
+        serial: string;
+        authenticating: boolean;
+        product?: string | undefined;
+        model?: string | undefined;
+        device?: string | undefined;
+        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();
+            }
+        }
+    }
+}