@yume-chan/adb 0.0.21 → 0.0.23

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

@@ -1,6 +1,8 @@
-import { DuplexStreamFactory, ReadableStream } from "@yume-chan/stream-extra";
+import type { Consumable, WritableStream } from "@yume-chan/stream-extra";
+import { ReadableStream } from "@yume-chan/stream-extra";
 
 import type { Adb, AdbSocket } from "../../../adb.js";
+import { unreachable } from "../../../utils/index.js";
 
 import type { AdbSubprocessProtocol } from "./types.js";
 
@@ -33,26 +35,23 @@ export class AdbSubprocessNoneProtocol implements AdbSubprocessProtocol {
 
     readonly #socket: AdbSocket;
 
-    readonly #duplex: DuplexStreamFactory<Uint8Array, Uint8Array>;
-
     // Legacy shell forwards all data to stdin.
-    get stdin() {
+    get stdin(): WritableStream<Consumable<Uint8Array>> {
         return this.#socket.writable;
     }
 
-    #stdout: ReadableStream<Uint8Array>;
     /**
      * Legacy shell mixes stdout and stderr.
      */
-    get stdout() {
-        return this.#stdout;
+    get stdout(): ReadableStream<Uint8Array> {
+        return this.#socket.readable;
     }
 
     #stderr: ReadableStream<Uint8Array>;
     /**
      * `stderr` will always be empty.
      */
-    get stderr() {
+    get stderr(): ReadableStream<Uint8Array> {
         return this.#stderr;
     }
 
@@ -64,24 +63,21 @@ export class AdbSubprocessNoneProtocol implements AdbSubprocessProtocol {
     constructor(socket: AdbSocket) {
         this.#socket = socket;
 
-        // Link `stdout`, `stderr` and `stdin` together,
-        // so closing any of them will close the others.
-        this.#duplex = new DuplexStreamFactory<Uint8Array, Uint8Array>({
-            close: async () => {
-                await this.#socket.close();
+        this.#stderr = new ReadableStream({
+            start: (controller) => {
+                this.#socket.closed
+                    .then(() => controller.close())
+                    .catch(unreachable);
             },
         });
-
-        this.#stdout = this.#duplex.wrapReadable(this.#socket.readable);
-        this.#stderr = this.#duplex.wrapReadable(new ReadableStream());
-        this.#exit = this.#duplex.closed.then(() => 0);
+        this.#exit = socket.closed.then(() => 0);
     }
 
     resize() {
         // Not supported, but don't throw.
     }
 
-    kill() {
-        return this.#duplex.close();
+    async kill() {
+        await this.#socket.close();
     }
 }

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

@@ -6,12 +6,10 @@ import type {
     WritableStreamDefaultWriter,
 } from "@yume-chan/stream-extra";
 import {
-    ConsumableTransformStream,
     ConsumableWritableStream,
     PushReadableStream,
     StructDeserializeStream,
     WritableStream,
-    pipeFrom,
 } from "@yume-chan/stream-extra";
 import type { StructValueType } from "@yume-chan/struct";
 import Struct, { placeholder } from "@yume-chan/struct";
@@ -37,68 +35,8 @@ const AdbShellProtocolPacket = new Struct({ littleEndian: true })
     .uint32("length")
     .uint8Array("data", { lengthField: "length" });
 
-type AdbShellProtocolPacketInit = (typeof AdbShellProtocolPacket)["TInit"];
-
 type AdbShellProtocolPacket = StructValueType<typeof AdbShellProtocolPacket>;
 
-class StdinSerializeStream extends ConsumableTransformStream<
-    Uint8Array,
-    AdbShellProtocolPacketInit
-> {
-    constructor() {
-        super({
-            async transform(chunk, controller) {
-                await controller.enqueue({
-                    id: AdbShellProtocolId.Stdin,
-                    data: chunk,
-                });
-            },
-            flush() {
-                // TODO: AdbShellSubprocessProtocol: support closing stdin
-            },
-        });
-    }
-}
-
-class MultiplexStream<T> {
-    #readable: PushReadableStream<T>;
-    #readableController!: PushReadableStreamController<T>;
-    get readable() {
-        return this.#readable;
-    }
-
-    #activeCount = 0;
-
-    constructor() {
-        this.#readable = new PushReadableStream((controller) => {
-            this.#readableController = controller;
-        });
-    }
-
-    createWriteable() {
-        return new WritableStream<T>({
-            start: () => {
-                this.#activeCount += 1;
-            },
-            write: async (chunk) => {
-                await this.#readableController.enqueue(chunk);
-            },
-            abort: () => {
-                this.#activeCount -= 1;
-                if (this.#activeCount === 0) {
-                    this.#readableController.close();
-                }
-            },
-            close: () => {
-                this.#activeCount -= 1;
-                if (this.#activeCount === 0) {
-                    this.#readableController.close();
-                }
-            },
-        });
-    }
-}
-
 /**
  * Shell v2 a.k.a Shell Protocol
  *
@@ -109,7 +47,7 @@ class MultiplexStream<T> {
  */
 export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
     static isSupported(adb: Adb) {
-        return adb.supportsFeature(AdbFeature.ShellV2);
+        return adb.canUseFeature(AdbFeature.ShellV2);
     }
 
     static async pty(adb: Adb, command: string) {
@@ -126,9 +64,7 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
     }
 
     readonly #socket: AdbSocket;
-    #socketWriter: WritableStreamDefaultWriter<
-        Consumable<AdbShellProtocolPacketInit>
-    >;
+    #writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>;
 
     #stdin: WritableStream<Consumable<Uint8Array>>;
     get stdin() {
@@ -153,10 +89,6 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
     constructor(socket: AdbSocket) {
         this.#socket = socket;
 
-        // Check this image to help you understand the stream graph
-        // cspell: disable-next-line
-        // https://www.plantuml.com/plantuml/png/bL91QiCm4Bpx5SAdv90lb1JISmiw5XzaQKf5PIkiLZIqzEyLSg8ks13gYtOykpFhiOw93N6UGjVDqK7rZsxKqNw0U_NTgVAy4empOy2mm4_olC0VEVEE47GUpnGjKdgXoD76q4GIEpyFhOwP_m28hW0NNzxNUig1_JdW0bA7muFIJDco1daJ_1SAX9bgvoPJPyIkSekhNYctvIGXrCH6tIsPL5fs-s6J5yc9BpWXhKtNdF2LgVYPGM_6GlMwfhWUsIt4lbScANrwlgVVUifPSVi__t44qStnwPvZwobdSmHHlL57p2vFuHS0
-
         let stdoutController!: PushReadableStreamController<Uint8Array>;
         let stderrController!: PushReadableStreamController<Uint8Array>;
         this.#stdout = new PushReadableStream<Uint8Array>((controller) => {
@@ -176,10 +108,14 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
                                 this.#exit.resolve(chunk.data[0]!);
                                 break;
                             case AdbShellProtocolId.Stdout:
-                                await stdoutController.enqueue(chunk.data);
+                                if (!stdoutController.abortSignal.aborted) {
+                                    await stdoutController.enqueue(chunk.data);
+                                }
                                 break;
                             case AdbShellProtocolId.Stderr:
-                                await stderrController.enqueue(chunk.data);
+                                if (!stderrController.abortSignal.aborted) {
+                                    await stderrController.enqueue(chunk.data);
+                                }
                                 break;
                         }
                     },
@@ -202,39 +138,33 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
                 },
             );
 
-        const multiplexer = new MultiplexStream<
-            Consumable<AdbShellProtocolPacketInit>
-        >();
-        void multiplexer.readable
-            .pipeThrough(
-                new ConsumableTransformStream({
-                    async transform(chunk, controller) {
-                        await controller.enqueue(
-                            AdbShellProtocolPacket.serialize(chunk),
-                        );
-                    },
-                }),
-            )
-            .pipeTo(socket.writable);
-
-        this.#stdin = pipeFrom(
-            multiplexer.createWriteable(),
-            new StdinSerializeStream(),
-        );
+        this.#writer = this.#socket.writable.getWriter();
 
-        this.#socketWriter = multiplexer.createWriteable().getWriter();
+        this.#stdin = new WritableStream<Consumable<Uint8Array>>({
+            write: async (chunk) => {
+                await ConsumableWritableStream.write(
+                    this.#writer,
+                    AdbShellProtocolPacket.serialize({
+                        id: AdbShellProtocolId.Stdin,
+                        data: chunk.value,
+                    }),
+                );
+                chunk.consume();
+            },
+        });
     }
 
     async resize(rows: number, cols: number) {
-        await ConsumableWritableStream.write(this.#socketWriter, {
-            id: AdbShellProtocolId.WindowSizeChange,
-            data: encodeUtf8(
+        await ConsumableWritableStream.write(
+            this.#writer,
+            AdbShellProtocolPacket.serialize({
+                id: AdbShellProtocolId.WindowSizeChange,
                 // 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`,
-            ),
-        });
+                data: encodeUtf8(`${rows}x${cols},0x0\0`),
+            }),
+        );
     }
 
     kill() {

package/src/commands/subprocess/utils.ts

@@ -10,7 +10,7 @@ export function escapeArg(s: string) {
             break;
         }
         result += s.substring(base, found);
-        // a'b becomes a'\'b
+        // a'b becomes a'\'b (the backslash is not a escape character)
         result += String.raw`'\''`;
         base = found + 1;
     }

package/src/commands/sync/list.ts

@@ -4,7 +4,11 @@ import { AdbSyncRequestId, adbSyncWriteRequest } from "./request.js";
 import { AdbSyncResponseId, adbSyncReadResponses } from "./response.js";
 import type { AdbSyncSocket } from "./socket.js";
 import type { AdbSyncStat } from "./stat.js";
-import { AdbSyncLstatResponse, AdbSyncStatResponse } from "./stat.js";
+import {
+    AdbSyncLstatResponse,
+    AdbSyncStatErrorCode,
+    AdbSyncStatResponse,
+} from "./stat.js";
 
 export interface AdbSyncEntry extends AdbSyncStat {
     name: string;
@@ -43,7 +47,7 @@ export async function* adbSyncOpenDirV2(
             // `LST2` can return error codes for failed `lstat` calls.
             // `LIST` just ignores them.
             // But they only contain `name` so still pretty useless.
-            if (item.error !== 0) {
+            if (item.error !== AdbSyncStatErrorCode.SUCCESS) {
                 continue;
             }
             yield item;

package/src/commands/sync/pull.ts

@@ -30,6 +30,9 @@ export async function* adbSyncPullGenerator(
             yield packet.data;
         }
         done = true;
+    } catch (e) {
+        done = true;
+        throw e;
     } finally {
         if (!done) {
             // sync pull can't be cancelled, so we have to read all data

package/src/commands/sync/response.ts

@@ -46,7 +46,7 @@ export async function adbSyncReadResponse<T>(
 }
 
 export async function* adbSyncReadResponses<
-    T extends Struct<object, PropertyKey, object, any>,
+    T extends Struct<object, PropertyKey, object, unknown>,
 >(
     stream: AsyncExactReadable,
     id: AdbSyncResponseId,
@@ -66,7 +66,7 @@ export async function* adbSyncReadResponses<
                 await stream.readExactly(type.size);
                 return;
             case id:
-                yield await type.deserialize(stream);
+                yield (await type.deserialize(stream)) as StructValueType<T>;
                 break;
             default:
                 throw new Error(

package/src/commands/sync/socket.ts

@@ -71,6 +71,10 @@ export class AdbSyncSocketLocked implements AsyncExactReadable {
         this.#combiner.flush();
         this.#socketLock.notifyOne();
     }
+
+    async close() {
+        await this.#readable.cancel();
+    }
 }
 
 export class AdbSyncSocket {
@@ -94,6 +98,7 @@ export class AdbSyncSocket {
     }
 
     async close() {
+        await this.#locked.close();
         await this.#socket.close();
     }
 }

package/src/commands/sync/sync.ts

@@ -74,16 +74,15 @@ export class AdbSync extends AutoDisposable {
         this._adb = adb;
         this._socket = new AdbSyncSocket(socket, adb.maxPayloadSize);
 
-        this.#supportsStat = adb.supportsFeature(AdbFeature.StatV2);
-        this.#supportsListV2 = adb.supportsFeature(AdbFeature.ListV2);
-        this.#fixedPushMkdir = adb.supportsFeature(AdbFeature.FixedPushMkdir);
-        this.#supportsSendReceiveV2 = adb.supportsFeature(
+        this.#supportsStat = adb.canUseFeature(AdbFeature.StatV2);
+        this.#supportsListV2 = adb.canUseFeature(AdbFeature.ListV2);
+        this.#fixedPushMkdir = adb.canUseFeature(AdbFeature.FixedPushMkdir);
+        this.#supportsSendReceiveV2 = adb.canUseFeature(
             AdbFeature.SendReceiveV2,
         );
         // https://android.googlesource.com/platform/packages/modules/adb/+/91768a57b7138166e0a3d11f79cd55909dda7014/client/file_sync_client.cpp#1361
         this.#needPushMkdirWorkaround =
-            this._adb.supportsFeature(AdbFeature.ShellV2) &&
-            !this.fixedPushMkdir;
+            this._adb.canUseFeature(AdbFeature.ShellV2) && !this.fixedPushMkdir;
     }
 
     /**

package/src/commands/tcpip.ts

@@ -1,6 +1,50 @@
 import { AdbCommandBase } from "./base.js";
 
+/**
+ * ADB daemon checks for the following properties in the order of
+ *
+ * * `serviceListenAddresses` (`service.adb.listen_addrs`)
+ * * `servicePort` (`service.adb.tcp.port`)
+ * * `persistPort` (`persist.adb.tcp.port`)
+ *
+ * Once it finds a non-empty value, it will use it and ignore the rest.
+ *
+ * `serviceListenAddresses` and `persistPort` are fixed at build time,
+ * only `servicePort` can be changed using `setPort` and `disable`.
+ * This means if either `serviceListenAddresses` or `persistPort` is non-empty,
+ * ADB over WiFi is always enabled.
+ */
+export interface AdbTcpIpListenAddresses {
+    serviceListenAddresses: string[];
+    servicePort: number | undefined;
+    persistPort: number | undefined;
+}
+
 export class AdbTcpIpCommand extends AdbCommandBase {
+    #parsePort(value: string): number | undefined {
+        if (!value || value === "0") {
+            return undefined;
+        }
+        return Number.parseInt(value, 10);
+    }
+
+    async getListenAddresses(): Promise<AdbTcpIpListenAddresses> {
+        const serviceListenAddresses = await this.adb.getProp(
+            "service.adb.listen_addrs",
+        );
+        const servicePort = await this.adb.getProp("service.adb.tcp.port");
+        const persistPort = await this.adb.getProp("persist.adb.tcp.port");
+
+        return {
+            serviceListenAddresses:
+                serviceListenAddresses != ""
+                    ? serviceListenAddresses.split(",")
+                    : [],
+            servicePort: this.#parsePort(servicePort),
+            persistPort: this.#parsePort(persistPort),
+        };
+    }
+
     async setPort(port: number): Promise<string> {
         if (port <= 0) {
             throw new Error(`Invalid port ${port}`);