@yume-chan/adb 0.0.18 → 0.0.19

package/src/adb.ts

@@ -1,19 +1,19 @@
-// cspell: ignore libusb
-
 import { PromiseResolver } from "@yume-chan/async";
+import type { Consumable, ReadableWritablePair } from "@yume-chan/stream-extra";
 import {
     AbortController,
+    ConsumableWritableStream,
     DecodeUtf8Stream,
     GatherStringStream,
     WritableStream,
-    type ReadableWritablePair,
 } from "@yume-chan/stream-extra";
 
+import type { AdbCredentialStore } from "./auth.js";
 import {
     ADB_DEFAULT_AUTHENTICATORS,
     AdbAuthenticationProcessor,
-    type AdbCredentialStore,
 } from "./auth.js";
+import type { AdbFrameBuffer } from "./commands/index.js";
 import {
     AdbPower,
     AdbReverseCommand,
@@ -22,22 +22,16 @@ import {
     AdbTcpIpCommand,
     escapeArg,
     framebuffer,
-    install,
-    type AdbFrameBuffer,
 } from "./commands/index.js";
-import { AdbFeatures } from "./features.js";
-import {
-    AdbCommand,
-    calculateChecksum,
-    type AdbPacketData,
-    type AdbPacketInit,
-} from "./packet.js";
-import {
-    AdbPacketDispatcher,
-    type AdbIncomingSocketHandler,
-    type AdbSocket,
-    type Closeable,
+import { AdbFeature } from "./features.js";
+import type { AdbPacketData, AdbPacketInit } from "./packet.js";
+import { AdbCommand, calculateChecksum } from "./packet.js";
+import type {
+    AdbIncomingSocketHandler,
+    AdbSocket,
+    Closeable,
 } from "./socket/index.js";
+import { AdbPacketDispatcher } from "./socket/index.js";
 import { decodeUtf8, encodeUtf8 } from "./utils/index.js";
 
 export enum AdbPropKey {
@@ -56,13 +50,17 @@ export class Adb implements Closeable {
      * and starts a new authentication process.
      */
     public static async authenticate(
-        connection: ReadableWritablePair<AdbPacketData, AdbPacketInit>,
+        connection: ReadableWritablePair<
+            AdbPacketData,
+            Consumable<AdbPacketInit>
+        >,
         credentialStore: AdbCredentialStore,
         authenticators = ADB_DEFAULT_AUTHENTICATORS
     ): Promise<Adb> {
         // Initially, set to highest-supported version and payload size.
         let version = 0x01000001;
-        let maxPayloadSize = 0x100000;
+        // Android 4: 4K, Android 7: 256K, Android 9: 1M
+        let maxPayloadSize = 1024 * 1024;
 
         const resolver = new PromiseResolver<string>();
         const authProcessor = new AdbAuthenticationProcessor(
@@ -117,7 +115,9 @@ export class Adb implements Closeable {
         async function sendPacket(init: AdbPacketData) {
             // Always send checksum in auth steps
             // Because we don't know if the device needs it or not.
-            await writer.write(calculateChecksum(init));
+            (init as AdbPacketInit).checksum = calculateChecksum(init.payload);
+            (init as AdbPacketInit).magic = init.command ^ 0xffffffff;
+            await ConsumableWritableStream.write(writer, init as AdbPacketInit);
         }
 
         let banner: string;
@@ -125,17 +125,17 @@ export class Adb implements Closeable {
             // https://android.googlesource.com/platform/packages/modules/adb/+/79010dc6d5ca7490c493df800d4421730f5466ca/transport.cpp#1252
             // There are some other feature constants, but some of them are only used by ADB server, not devices (daemons).
             const features = [
-                AdbFeatures.ShellV2,
-                AdbFeatures.Cmd,
-                AdbFeatures.StatV2,
-                AdbFeatures.ListV2,
-                AdbFeatures.FixedPushMkdir,
+                AdbFeature.ShellV2,
+                AdbFeature.Cmd,
+                AdbFeature.StatV2,
+                AdbFeature.ListV2,
+                AdbFeature.FixedPushMkdir,
                 "apex",
-                "abb",
+                AdbFeature.Abb,
                 // only tells the client the symlink timestamp issue in `adb push --sync` has been fixed.
                 // No special handling required.
                 "fixed_push_symlink_timestamp",
-                "abb_exec",
+                AdbFeature.AbbExec,
                 "remount_shell",
                 "track_app",
                 "sendrecv_v2",
@@ -174,11 +174,16 @@ export class Adb implements Closeable {
         return this.dispatcher.disconnected;
     }
 
-    private _protocolVersion: number | undefined;
+    private _protocolVersion: number;
     public get protocolVersion() {
         return this._protocolVersion;
     }
 
+    private _maxPayloadSize: number;
+    public get maxPayloadSize() {
+        return this._maxPayloadSize;
+    }
+
     private _product: string | undefined;
     public get product() {
         return this._product;
@@ -194,7 +199,7 @@ export class Adb implements Closeable {
         return this._device;
     }
 
-    private _features: AdbFeatures[] = [];
+    private _features: AdbFeature[] = [];
     public get features() {
         return this._features;
     }
@@ -205,7 +210,10 @@ export class Adb implements Closeable {
     public readonly tcpip: AdbTcpIpCommand;
 
     public constructor(
-        connection: ReadableWritablePair<AdbPacketData, AdbPacketInit>,
+        connection: ReadableWritablePair<
+            AdbPacketData,
+            Consumable<AdbPacketInit>
+        >,
         version: number,
         maxPayloadSize: number,
         banner: string
@@ -229,6 +237,7 @@ export class Adb implements Closeable {
         });
 
         this._protocolVersion = version;
+        this._maxPayloadSize = maxPayloadSize;
 
         this.subprocess = new AdbSubprocess(this);
         this.power = new AdbPower(this);
@@ -262,13 +271,17 @@ export class Adb implements Closeable {
                         this._device = value;
                         break;
                     case AdbPropKey.Features:
-                        this._features = value!.split(",") as AdbFeatures[];
+                        this._features = value!.split(",") as AdbFeature[];
                         break;
                 }
             }
         }
     }
 
+    public supportsFeature(feature: AdbFeature): boolean {
+        return this._features.includes(feature);
+    }
+
     /**
      * Add a handler for incoming socket.
      * @param handler A function to call with new incoming sockets. It must return `true` if it accepts the socket.
@@ -300,18 +313,15 @@ export class Adb implements Closeable {
     }
 
     public async rm(...filenames: string[]): Promise<string> {
+        // https://android.googlesource.com/platform/packages/modules/adb/+/1a0fb8846d4e6b671c8aa7f137a8c21d7b248716/client/adb_install.cpp#984
         const stdout = await this.subprocess.spawnAndWaitLegacy([
             "rm",
-            "-rf",
             ...filenames.map((arg) => escapeArg(arg)),
+            "</dev/null",
         ]);
         return stdout;
     }
 
-    public install() {
-        return install(this);
-    }
-
     public async sync(): Promise<AdbSync> {
         const socket = await this.createSocket("sync:");
         return new AdbSync(this, socket);

package/src/auth.ts

@@ -1,13 +1,14 @@
 import { PromiseResolver } from "@yume-chan/async";
-import { type Disposable } from "@yume-chan/event";
-import { type ValueOrPromise } from "@yume-chan/struct";
+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 type { AdbPacketData } from "./packet.js";
+import { AdbCommand } from "./packet.js";
 import { calculateBase64EncodedLength, encodeBase64 } from "./utils/index.js";
 
 export type AdbKeyIterable = Iterable<Uint8Array> | AsyncIterable<Uint8Array>;
@@ -97,9 +98,9 @@ export const AdbPublicKeyAuthenticator: AdbAuthenticator = async function* (
     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);
+    const publicKeyBuffer = new Uint8Array(
+        publicKeyBase64Length + 1 // Null character
+    );
 
     calculatePublicKey(privateKey, publicKeyBuffer);
     encodeBase64(publicKeyBuffer.subarray(0, publicKeyLength), publicKeyBuffer);

package/src/backend.ts

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

package/src/commands/base.ts

@@ -1,6 +1,6 @@
 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,7 +1,7 @@
 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");
 
@@ -20,7 +20,7 @@ export const AdbFrameBufferV1 = new Struct({ littleEndian: true })
     .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")
@@ -38,7 +38,7 @@ export const AdbFrameBufferV2 = new Struct({ littleEndian: true })
     .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
@@ -69,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("Unsupported FrameBuffer version");
     }
 }

package/src/commands/index.ts

@@ -1,8 +1,7 @@
-export * from './base.js';
-export * from './framebuffer.js';
-export * from './install.js';
-export * from './power.js';
-export * from './reverse.js';
-export * from './subprocess/index.js';
-export * from './sync/index.js';
-export * from './tcpip.js';
+export * from "./base.js";
+export * from "./framebuffer.js";
+export * from "./power.js";
+export * from "./reverse.js";
+export * from "./subprocess/index.js";
+export * from "./sync/index.js";
+export * from "./tcpip.js";

package/src/commands/reverse.ts

@@ -7,11 +7,8 @@ import {
 } 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 type { Adb } from "../adb.js";
+import type { AdbIncomingSocketHandler, AdbSocket } from "../socket/index.js";
 import { decodeUtf8 } from "../utils/index.js";
 
 export interface AdbForwardListener {
@@ -26,10 +23,33 @@ const AdbReverseStringResponse = new Struct()
     .string("length", { length: 4 })
     .string("content", { lengthField: "length", lengthFieldRadix: 16 });
 
+export class AdbReverseError extends Error {
+    public constructor(message: string) {
+        super(message);
+        Object.setPrototypeOf(this, AdbReverseError.prototype);
+    }
+}
+
+export class AdbReverseNotSupportedError extends Error {
+    public constructor() {
+        super(
+            "ADB reverse tunnel is not supported on this device when connected wirelessly."
+        );
+        Object.setPrototypeOf(this, AdbReverseNotSupportedError.prototype);
+    }
+}
+
 const AdbReverseErrorResponse = new Struct()
     .fields(AdbReverseStringResponse)
     .postDeserialize((value) => {
-        throw new Error(value.content);
+        // https://issuetracker.google.com/issues/37066218
+        // ADB on Android <9 can't create reverse tunnels when connected wirelessly (ADB over WiFi),
+        // and returns this confusing "more than one device/emulator" error.
+        if (value.content === "more than one device/emulator") {
+            throw new AdbReverseNotSupportedError();
+        } else {
+            throw new AdbReverseError(value.content);
+        }
     });
 
 export class AdbReverseCommand extends AutoDisposable {
@@ -91,18 +111,23 @@ export class AdbReverseCommand extends AutoDisposable {
     }
 
     /**
-     * @param deviceAddress The address adbd on device is listening on. Can be `tcp:0` to let adbd choose an available TCP port by itself.
-     * @param localAddress Native ADB client will open a connection to this address when reverse connection received. In WebADB, it's only used to uniquely identify a reverse tunnel registry, `handler` will be called to handle the connection.
+     * @param deviceAddress
+     * The address to be listened on device by ADB daemon. Or `tcp:0` to choose an available TCP port.
+     * @param localAddress
+     * An identifier for the reverse tunnel.
+     *
+     * When a socket wants to connect to {@link deviceAddress}, native ADB client will forward that connection to {@link localAddress}.
+     * However in this library, the {@link handler} is invoked instead. So this parameter is only used to identify the reverse tunnel.
      * @param handler A callback to handle incoming connections. It must return `true` if it accepts the connection.
      * @returns `tcp:{ACTUAL_LISTENING_PORT}`, If `deviceAddress` is `tcp:0`; otherwise, `deviceAddress`.
+     * @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(
         deviceAddress: string,
         localAddress: string,
         handler: AdbIncomingSocketHandler
     ): Promise<string> {
-        // TODO(reverse): handle ADB bug
-        // https://issuetracker.google.com/issues/37066218
         const stream = await this.sendRequest(
             `reverse:forward:${deviceAddress};${localAddress}`
         );

package/src/commands/subprocess/command.ts

@@ -2,11 +2,13 @@ import { DecodeUtf8Stream, GatherStringStream } from "@yume-chan/stream-extra";
 
 import { AdbCommandBase } from "../base.js";
 
+import type {
+    AdbSubprocessProtocol,
+    AdbSubprocessProtocolConstructor,
+} from "./protocols/index.js";
 import {
     AdbSubprocessNoneProtocol,
     AdbSubprocessShellProtocol,
-    type AdbSubprocessProtocol,
-    type AdbSubprocessProtocolConstructor,
 } from "./protocols/index.js";
 
 export interface AdbSubprocessOptions {
@@ -65,7 +67,10 @@ export class AdbSubprocess extends AdbCommandBase {
     }
 
     /**
-     * Spawns an executable in PTY (interactive) mode.
+     * Spawns an executable in PTY mode.
+     *
+     * Redirection mode is enough for most simple commands, but PTY mode is required for
+     * commands that manipulate the terminal, such as `vi` and `less`.
      * @param command The command to run. If omitted, the default shell will be spawned.
      * @param options The options for creating the `AdbSubprocessProtocol`
      * @returns A new `AdbSubprocessProtocol` instance connecting to the spawned process.
@@ -78,7 +83,10 @@ export class AdbSubprocess extends AdbCommandBase {
     }
 
     /**
-     * Spawns an executable and pipe the output.
+     * Spawns an executable and redirect the standard input/output stream.
+     *
+     * Redirection mode is enough for most simple commands, but PTY mode is required for
+     * commands that manipulate the terminal, such as `vi` and `less`.
      * @param command The command to run, or an array of strings containing both command and args.
      * @param options The options for creating the `AdbSubprocessProtocol`
      * @returns A new `AdbSubprocessProtocol` instance connecting to the spawned process.

package/src/commands/subprocess/index.ts

@@ -1,3 +1,3 @@
-export * from './command.js';
-export * from './protocols/index.js';
-export * from './utils.js';
+export * from "./command.js";
+export * from "./protocols/index.js";
+export * from "./utils.js";

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

@@ -1,3 +1,3 @@
-export * from './none.js';
-export * from './shell.js';
-export * from './types.js';
+export * from "./none.js";
+export * from "./shell.js";
+export * from "./types.js";

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

@@ -1,9 +1,9 @@
-import { DuplexStreamFactory, ReadableStream } from '@yume-chan/stream-extra';
+import { DuplexStreamFactory, ReadableStream } from "@yume-chan/stream-extra";
 
-import { type Adb } from "../../../adb.js";
-import { type AdbSocket } from "../../../socket/index.js";
+import type { Adb } from "../../../adb.js";
+import type { AdbSocket } from "../../../socket/index.js";
 
-import { type AdbSubprocessProtocol } from "./types.js";
+import type { AdbSubprocessProtocol } from "./types.js";
 
 /**
  * The legacy shell
@@ -14,16 +14,22 @@ import { type AdbSubprocessProtocol } from "./types.js";
  * * `resize`: No
  */
 export class AdbSubprocessNoneProtocol implements AdbSubprocessProtocol {
-    public static isSupported() { return true; }
+    public static isSupported() {
+        return true;
+    }
 
     public static async pty(adb: Adb, command: string) {
-        return new AdbSubprocessNoneProtocol(await adb.createSocket(`shell:${command}`));
+        return new AdbSubprocessNoneProtocol(
+            await adb.createSocket(`shell:${command}`)
+        );
     }
 
     public 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}`));
+        return new AdbSubprocessNoneProtocol(
+            await adb.createSocket(`exec:${command}`)
+        );
     }
 
     private readonly socket: AdbSocket;
@@ -31,22 +37,30 @@ export class AdbSubprocessNoneProtocol implements AdbSubprocessProtocol {
     private readonly duplex: DuplexStreamFactory<Uint8Array, Uint8Array>;
 
     // Legacy shell forwards all data to stdin.
-    public get stdin() { return this.socket.writable; }
+    public get stdin() {
+        return this.socket.writable;
+    }
 
     private _stdout: ReadableStream<Uint8Array>;
     /**
      * Legacy shell mixes stdout and stderr.
      */
-    public get stdout() { return this._stdout; }
+    public get stdout() {
+        return this._stdout;
+    }
 
     private _stderr: ReadableStream<Uint8Array>;
     /**
      * `stderr` will always be empty.
      */
-    public get stderr() { return this._stderr; }
+    public get stderr() {
+        return this._stderr;
+    }
 
     private _exit: Promise<number>;
-    public get exit() { return this._exit; }
+    public get exit() {
+        return this._exit;
+    }
 
     public constructor(socket: AdbSocket) {
         this.socket = socket;

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

@@ -1,23 +1,28 @@
-import { PromiseResolver } from '@yume-chan/async';
+import { PromiseResolver } from "@yume-chan/async";
+import type {
+    Consumable,
+    PushReadableStreamController,
+    ReadableStream,
+    WritableStreamDefaultWriter,
+} from "@yume-chan/stream-extra";
 import {
+    ConsumableTransformStream,
+    ConsumableWritableStream,
     PushReadableStream,
     StructDeserializeStream,
-    StructSerializeStream,
     TransformStream,
     WritableStream,
     pipeFrom,
-    type PushReadableStreamController,
-    type ReadableStream,
-    type WritableStreamDefaultWriter,
 } from "@yume-chan/stream-extra";
-import Struct, { placeholder, type StructValueType } from '@yume-chan/struct';
+import type { StructValueType } from "@yume-chan/struct";
+import Struct, { placeholder } from "@yume-chan/struct";
 
-import { type Adb } from "../../../adb.js";
-import { AdbFeatures } from '../../../features.js';
-import { type AdbSocket } from "../../../socket/index.js";
-import { encodeUtf8 } from '../../../utils/index.js';
+import type { Adb } from "../../../adb.js";
+import { AdbFeature } from "../../../features.js";
+import type { AdbSocket } from "../../../socket/index.js";
+import { encodeUtf8 } from "../../../utils/index.js";
 
-import { type AdbSubprocessProtocol } from "./types.js";
+import type { AdbSubprocessProtocol } from "./types.js";
 
 export enum AdbShellProtocolId {
     Stdin,
@@ -29,33 +34,38 @@ export enum AdbShellProtocolId {
 }
 
 // This packet format is used in both direction.
-const AdbShellProtocolPacket =
-    new Struct({ littleEndian: true })
-        .uint8('id', placeholder<AdbShellProtocolId>())
-        .uint32('length')
-        .uint8Array('data', { lengthField: 'length' });
+const AdbShellProtocolPacket = new Struct({ littleEndian: true })
+    .uint8("id", placeholder<AdbShellProtocolId>())
+    .uint32("length")
+    .uint8Array("data", { lengthField: "length" });
 
-type AdbShellProtocolPacketInit = typeof AdbShellProtocolPacket['TInit'];
+type AdbShellProtocolPacketInit = (typeof AdbShellProtocolPacket)["TInit"];
 
 type AdbShellProtocolPacket = StructValueType<typeof AdbShellProtocolPacket>;
 
-class StdinSerializeStream extends TransformStream<Uint8Array, AdbShellProtocolPacketInit>{
+class StdinSerializeStream extends ConsumableTransformStream<
+    Uint8Array,
+    AdbShellProtocolPacketInit
+> {
     constructor() {
         super({
-            transform(chunk, controller) {
-                controller.enqueue({
+            async transform(chunk, controller) {
+                await controller.enqueue({
                     id: AdbShellProtocolId.Stdin,
                     data: chunk,
                 });
             },
             flush() {
                 // TODO: AdbShellSubprocessProtocol: support closing stdin
-            }
+            },
         });
     }
 }
 
-class StdoutDeserializeStream extends TransformStream<AdbShellProtocolPacket, Uint8Array>{
+class StdoutDeserializeStream extends TransformStream<
+    AdbShellProtocolPacket,
+    Uint8Array
+> {
     constructor(type: AdbShellProtocolId.Stdout | AdbShellProtocolId.Stderr) {
         super({
             transform(chunk, controller) {
@@ -116,7 +126,7 @@ class MultiplexStream<T> {
  */
 export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
     public static isSupported(adb: Adb) {
-        return adb.features.includes(AdbFeatures.ShellV2);
+        return adb.supportsFeature(AdbFeature.ShellV2);
     }
 
     public static async pty(adb: Adb, command: string) {
@@ -133,9 +143,11 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
     }
 
     private readonly _socket: AdbSocket;
-    private _socketWriter: WritableStreamDefaultWriter<AdbShellProtocolPacketInit>;
+    private _socketWriter: WritableStreamDefaultWriter<
+        Consumable<AdbShellProtocolPacketInit>
+    >;
 
-    private _stdin: WritableStream<Uint8Array>;
+    private _stdin: WritableStream<Consumable<Uint8Array>>;
     public get stdin() {
         return this._stdin;
     }
@@ -192,9 +204,19 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
             new StdoutDeserializeStream(AdbShellProtocolId.Stderr)
         );
 
-        const multiplexer = new MultiplexStream<AdbShellProtocolPacketInit>();
+        const multiplexer = new MultiplexStream<
+            Consumable<AdbShellProtocolPacketInit>
+        >();
         void multiplexer.readable
-            .pipeThrough(new StructSerializeStream(AdbShellProtocolPacket))
+            .pipeThrough(
+                new ConsumableTransformStream({
+                    async transform(chunk, controller) {
+                        await controller.enqueue(
+                            AdbShellProtocolPacket.serialize(chunk)
+                        );
+                    },
+                })
+            )
             .pipeTo(socket.writable);
 
         this._stdin = pipeFrom(
@@ -206,7 +228,7 @@ export class AdbSubprocessShellProtocol implements AdbSubprocessProtocol {
     }
 
     public async resize(rows: number, cols: number) {
-        await this._socketWriter.write({
+        await ConsumableWritableStream.write(this._socketWriter, {
             id: AdbShellProtocolId.WindowSizeChange,
             data: encodeUtf8(
                 // The "correct" format is `${rows}x${cols},${x_pixels}x${y_pixels}`