@yume-chan/adb 0.0.18 → 0.0.20

package/esm/{packet.js → daemon/packet.js}

@@ -1,49 +1,44 @@
-import { TransformStream } from "@yume-chan/stream-extra";
-import Struct from "@yume-chan/struct";
-export var AdbCommand;
-(function (AdbCommand) {
-    AdbCommand[AdbCommand["Auth"] = 1213486401] = "Auth";
-    AdbCommand[AdbCommand["Close"] = 1163086915] = "Close";
-    AdbCommand[AdbCommand["Connect"] = 1314410051] = "Connect";
-    AdbCommand[AdbCommand["OK"] = 1497451343] = "OK";
-    AdbCommand[AdbCommand["Open"] = 1313165391] = "Open";
-    AdbCommand[AdbCommand["Write"] = 1163154007] = "Write";
-})(AdbCommand = AdbCommand || (AdbCommand = {}));
-export const AdbPacketHeader = new Struct({ littleEndian: true })
-    .uint32("command")
-    .uint32("arg0")
-    .uint32("arg1")
-    .uint32("payloadLength")
-    .uint32("checksum")
-    .int32("magic");
-export const AdbPacket = new Struct({ littleEndian: true })
-    .fields(AdbPacketHeader)
-    .uint8Array("payload", { lengthField: "payloadLength" });
-export function calculateChecksum(payload) {
-    if (payload instanceof Uint8Array) {
-        return payload.reduce((result, item) => result + item, 0);
-    }
-    else {
-        payload.checksum = calculateChecksum(payload.payload);
-        return payload;
-    }
-}
-export class AdbPacketSerializeStream extends TransformStream {
-    constructor() {
-        super({
-            transform: (init, controller) => {
-                // This syntax is ugly, but I don't want to create a new object.
-                init.magic =
-                    init.command ^ 0xffffffff;
-                init.payloadLength =
-                    init.payload.byteLength;
-                controller.enqueue(AdbPacketHeader.serialize(init));
-                if (init.payload.byteLength) {
-                    // Enqueue payload separately to avoid copying
-                    controller.enqueue(init.payload);
-                }
-            },
-        });
-    }
-}
+import { ConsumableTransformStream } from "@yume-chan/stream-extra";
+import Struct from "@yume-chan/struct";
+export var AdbCommand;
+(function (AdbCommand) {
+    AdbCommand[AdbCommand["Auth"] = 1213486401] = "Auth";
+    AdbCommand[AdbCommand["Close"] = 1163086915] = "Close";
+    AdbCommand[AdbCommand["Connect"] = 1314410051] = "Connect";
+    AdbCommand[AdbCommand["OK"] = 1497451343] = "OK";
+    AdbCommand[AdbCommand["Open"] = 1313165391] = "Open";
+    AdbCommand[AdbCommand["Write"] = 1163154007] = "Write";
+})(AdbCommand = AdbCommand || (AdbCommand = {}));
+export const AdbPacketHeader = new Struct({ littleEndian: true })
+    .uint32("command")
+    .uint32("arg0")
+    .uint32("arg1")
+    .uint32("payloadLength")
+    .uint32("checksum")
+    .int32("magic");
+export const AdbPacket = new Struct({ littleEndian: true })
+    .concat(AdbPacketHeader)
+    .uint8Array("payload", { lengthField: "payloadLength" });
+export function calculateChecksum(payload) {
+    return payload.reduce((result, item) => result + item, 0);
+}
+export class AdbPacketSerializeStream extends ConsumableTransformStream {
+    constructor() {
+        const headerBuffer = new Uint8Array(AdbPacketHeader.size);
+        super({
+            transform: async (chunk, controller) => {
+                const init = chunk;
+                init.payloadLength = init.payload.byteLength;
+                AdbPacketHeader.serialize(init, headerBuffer);
+                await controller.enqueue(headerBuffer);
+                if (init.payload.byteLength) {
+                    // USB protocol preserves packet boundaries,
+                    // so we must write payload separately as native ADB does,
+                    // otherwise the read operation on device will fail.
+                    await controller.enqueue(init.payload);
+                }
+            },
+        });
+    }
+}
 //# sourceMappingURL=packet.js.map

package/esm/daemon/packet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"packet.js","sourceRoot":"","sources":["../../src/daemon/packet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,MAAM,MAAM,mBAAmB,CAAC;AAEvC,MAAM,CAAN,IAAY,UAOX;AAPD,WAAY,UAAU;IAClB,oDAAiB,CAAA;IACjB,sDAAkB,CAAA;IAClB,0DAAoB,CAAA;IACpB,gDAAe,CAAA;IACf,oDAAiB,CAAA;IACjB,sDAAkB,CAAA;AACtB,CAAC,EAPW,UAAU,GAAV,UAAU,KAAV,UAAU,QAOrB;AAED,MAAM,CAAC,MAAM,eAAe,GAAG,IAAI,MAAM,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;KAC5D,MAAM,CAAC,SAAS,CAAC;KACjB,MAAM,CAAC,MAAM,CAAC;KACd,MAAM,CAAC,MAAM,CAAC;KACd,MAAM,CAAC,eAAe,CAAC;KACvB,MAAM,CAAC,UAAU,CAAC;KAClB,KAAK,CAAC,OAAO,CAAC,CAAC;AAMpB,MAAM,CAAC,MAAM,SAAS,GAAG,IAAI,MAAM,CAAC,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;KACtD,MAAM,CAAC,eAAe,CAAC;KACvB,UAAU,CAAC,SAAS,EAAE,EAAE,WAAW,EAAE,eAAe,EAAE,CAAC,CAAC;AAqB7D,MAAM,UAAU,iBAAiB,CAAC,OAAmB;IACjD,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,MAAM,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC;AAC9D,CAAC;AAED,MAAM,OAAO,wBAAyB,SAAQ,yBAG7C;IACG;QACI,MAAM,YAAY,GAAG,IAAI,UAAU,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAC1D,KAAK,CAAC;YACF,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,EAAE;gBACnC,MAAM,IAAI,GAAG,KAA4C,CAAC;gBAC1D,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;gBAE7C,eAAe,CAAC,SAAS,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;gBAC9C,MAAM,UAAU,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;gBAEvC,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE;oBACzB,4CAA4C;oBAC5C,0DAA0D;oBAC1D,oDAAoD;oBACpD,MAAM,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;iBAC1C;YACL,CAAC;SACJ,CAAC,CAAC;IACP,CAAC;CACJ"}

package/esm/daemon/socket.d.ts

@@ -0,0 +1,58 @@
+import type { Disposable } from "@yume-chan/event";
+import type { Consumable, ReadableStream, ReadableWritablePair, WritableStream } from "@yume-chan/stream-extra";
+import type { Closeable } from "../adb.js";
+import type { AdbPacketDispatcher } from "./dispatcher.js";
+export interface AdbDaemonSocketInfo {
+    localId: number;
+    remoteId: number;
+    localCreated: boolean;
+    service: string;
+}
+export interface AdbDaemonSocketConstructionOptions extends AdbDaemonSocketInfo {
+    dispatcher: AdbPacketDispatcher;
+    highWaterMark?: number | undefined;
+}
+export declare class AdbDaemonSocketController implements AdbDaemonSocketInfo, ReadableWritablePair<Uint8Array, Consumable<Uint8Array>>, Closeable, Disposable {
+    #private;
+    private readonly dispatcher;
+    readonly localId: number;
+    readonly remoteId: number;
+    readonly localCreated: boolean;
+    readonly service: string;
+    get readable(): ReadableStream<Uint8Array>;
+    readonly writable: WritableStream<Consumable<Uint8Array>>;
+    /**
+     * Whether the socket is half-closed (i.e. the local side initiated the close).
+     *
+     * It's only used by dispatcher to avoid sending another `CLSE` packet to remote.
+     */
+    get closed(): boolean;
+    private _socket;
+    get socket(): AdbDaemonSocket;
+    constructor(options: AdbDaemonSocketConstructionOptions);
+    enqueue(data: Uint8Array): Promise<void>;
+    ack(): void;
+    close(): Promise<void>;
+    dispose(): Promise<void>;
+}
+/**
+ * A duplex stream representing a socket to ADB daemon.
+ *
+ * To close it, call either `socket.close()`,
+ * `socket.readable.cancel()`, `socket.readable.getReader().cancel()`,
+ * `socket.writable.abort()`, `socket.writable.getWriter().abort()`,
+ * `socket.writable.close()` or `socket.writable.getWriter().close()`.
+ */
+export declare class AdbDaemonSocket implements AdbDaemonSocketInfo, ReadableWritablePair<Uint8Array, Consumable<Uint8Array>> {
+    #private;
+    get localId(): number;
+    get remoteId(): number;
+    get localCreated(): boolean;
+    get service(): string;
+    get readable(): ReadableStream<Uint8Array>;
+    get writable(): WritableStream<Consumable<Uint8Array>>;
+    get closed(): boolean;
+    constructor(controller: AdbDaemonSocketController);
+    close(): Promise<void>;
+}
+//# sourceMappingURL=socket.d.ts.map

package/esm/daemon/socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket.d.ts","sourceRoot":"","sources":["../../src/daemon/socket.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EACR,UAAU,EAEV,cAAc,EACd,oBAAoB,EACpB,cAAc,EACjB,MAAM,yBAAyB,CAAC;AASjC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAG3D,MAAM,WAAW,mBAAmB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IAEjB,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,kCACb,SAAQ,mBAAmB;IAC3B,UAAU,EAAE,mBAAmB,CAAC;IAEhC,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAED,qBAAa,yBACT,YACI,mBAAmB,EACnB,oBAAoB,CAAC,UAAU,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC,EACxD,SAAS,EACT,UAAU;;IAEd,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAuB;IAElD,SAAgB,OAAO,EAAG,MAAM,CAAC;IACjC,SAAgB,QAAQ,EAAG,MAAM,CAAC;IAClC,SAAgB,YAAY,EAAG,OAAO,CAAC;IACvC,SAAgB,OAAO,EAAG,MAAM,CAAC;IAMjC,IAAW,QAAQ,+BAElB;IAGD,SAAgB,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC;IAGjE;;;;OAIG;IACH,IAAW,MAAM,YAEhB;IAED,OAAO,CAAC,OAAO,CAAkB;IACjC,IAAW,MAAM,oBAEhB;gBAEkB,OAAO,EAAE,kCAAkC;IAiEjD,OAAO,CAAC,IAAI,EAAE,UAAU;IAU9B,GAAG;IAIG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,OAAO;CAGjB;AAED;;;;;;;GAOG;AACH,qBAAa,eACT,YACI,mBAAmB,EACnB,oBAAoB,CAAC,UAAU,EAAE,UAAU,CAAC,UAAU,CAAC,CAAC;;IAI5D,IAAW,OAAO,IAAI,MAAM,CAE3B;IACD,IAAW,QAAQ,IAAI,MAAM,CAE5B;IACD,IAAW,YAAY,IAAI,OAAO,CAEjC;IACD,IAAW,OAAO,IAAI,MAAM,CAE3B;IAED,IAAW,QAAQ,IAAI,cAAc,CAAC,UAAU,CAAC,CAEhD;IACD,IAAW,QAAQ,IAAI,cAAc,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAE5D;IAED,IAAW,MAAM,IAAI,OAAO,CAE3B;gBAEkB,UAAU,EAAE,yBAAyB;IAIjD,KAAK;CAGf"}

package/esm/{socket → daemon}/socket.js

@@ -1,119 +1,122 @@
-import { PromiseResolver } from "@yume-chan/async";
-import { ChunkStream, DuplexStreamFactory, PushReadableStream, WritableStream, pipeFrom, } from "@yume-chan/stream-extra";
-import { AdbCommand } from "../packet.js";
-export class AdbSocketController {
-    dispatcher;
-    localId;
-    remoteId;
-    localCreated;
-    serviceString;
-    _duplex;
-    _readable;
-    _readableController;
-    get readable() {
-        return this._readable;
-    }
-    _writePromise;
-    writable;
-    _closed = false;
-    /**
-     * Whether the socket is half-closed (i.e. the local side initiated the close).
-     *
-     * It's only used by dispatcher to avoid sending another `CLSE` packet to remote.
-     */
-    get closed() {
-        return this._closed;
-    }
-    _socket;
-    get socket() {
-        return this._socket;
-    }
-    constructor(options) {
-        Object.assign(this, options);
-        // Check this image to help you understand the stream graph
-        // cspell: disable-next-line
-        // https://www.plantuml.com/plantuml/png/TL0zoeGm4ErpYc3l5JxyS0yWM6mX5j4C6p4cxcJ25ejttuGX88ZftizxUKmJI275pGhXl0PP_UkfK_CAz5Z2hcWsW9Ny2fdU4C1f5aSchFVxA8vJjlTPRhqZzDQMRB7AklwJ0xXtX0ZSKH1h24ghoKAdGY23FhxC4nS2pDvxzIvxb-8THU0XlEQJ-ZB7SnXTAvc_LhOckhMdLBnbtndpb-SB7a8q2SRD_W00
-        this._duplex = new DuplexStreamFactory({
-            close: async () => {
-                this._closed = true;
-                await this.dispatcher.sendPacket(AdbCommand.Close, this.localId, this.remoteId);
-                // Don't `dispose` here, we need to wait for `CLSE` response packet.
-                return false;
-            },
-            dispose: () => {
-                // Error out the pending writes
-                this._writePromise?.reject(new Error("Socket closed"));
-            },
-        });
-        this._readable = this._duplex.wrapReadable(new PushReadableStream((controller) => {
-            this._readableController = controller;
-        }, {
-            highWaterMark: options.highWaterMark ?? 16 * 1024,
-            size(chunk) {
-                return chunk.byteLength;
-            },
-        }));
-        this.writable = pipeFrom(this._duplex.createWritable(new WritableStream({
-            write: async (chunk) => {
-                // Wait for an ack packet
-                this._writePromise = new PromiseResolver();
-                await this.dispatcher.sendPacket(AdbCommand.Write, this.localId, this.remoteId, chunk);
-                await this._writePromise.promise;
-            },
-        })), new ChunkStream(this.dispatcher.options.maxPayloadSize));
-        this._socket = new AdbSocket(this);
-    }
-    async enqueue(packet) {
-        // Consumer may abort the `ReadableStream` to close the socket,
-        // it's OK to throw away further packets in this case.
-        if (this._readableController.abortSignal.aborted) {
-            return;
-        }
-        await this._readableController.enqueue(packet);
-    }
-    ack() {
-        this._writePromise?.resolve();
-    }
-    async close() {
-        await this._duplex.close();
-    }
-    dispose() {
-        return this._duplex.dispose();
-    }
-}
-/**
- * A duplex stream representing a socket to ADB daemon.
- *
- * To close it, call either `socket.close()`,
- * `socket.readable.cancel()`, `socket.readable.getReader().cancel()`,
- * `socket.writable.abort()`, `socket.writable.getWriter().abort()`,
- * `socket.writable.close()` or `socket.writable.getWriter().close()`.
- */
-export class AdbSocket {
-    _controller;
-    get localId() {
-        return this._controller.localId;
-    }
-    get remoteId() {
-        return this._controller.remoteId;
-    }
-    get localCreated() {
-        return this._controller.localCreated;
-    }
-    get serviceString() {
-        return this._controller.serviceString;
-    }
-    get readable() {
-        return this._controller.readable;
-    }
-    get writable() {
-        return this._controller.writable;
-    }
-    constructor(controller) {
-        this._controller = controller;
-    }
-    close() {
-        return this._controller.close();
-    }
-}
+import { PromiseResolver } from "@yume-chan/async";
+import { ConsumableWritableStream, DistributionStream, DuplexStreamFactory, PushReadableStream, pipeFrom, } from "@yume-chan/stream-extra";
+import { AdbCommand } from "./packet.js";
+export class AdbDaemonSocketController {
+    dispatcher;
+    localId;
+    remoteId;
+    localCreated;
+    service;
+    #duplex;
+    #readable;
+    #readableController;
+    get readable() {
+        return this.#readable;
+    }
+    #writePromise;
+    writable;
+    #closed = false;
+    /**
+     * Whether the socket is half-closed (i.e. the local side initiated the close).
+     *
+     * It's only used by dispatcher to avoid sending another `CLSE` packet to remote.
+     */
+    get closed() {
+        return this.#closed;
+    }
+    _socket;
+    get socket() {
+        return this._socket;
+    }
+    constructor(options) {
+        Object.assign(this, options);
+        // Check this image to help you understand the stream graph
+        // cspell: disable-next-line
+        // https://www.plantuml.com/plantuml/png/TL0zoeGm4ErpYc3l5JxyS0yWM6mX5j4C6p4cxcJ25ejttuGX88ZftizxUKmJI275pGhXl0PP_UkfK_CAz5Z2hcWsW9Ny2fdU4C1f5aSchFVxA8vJjlTPRhqZzDQMRB7AklwJ0xXtX0ZSKH1h24ghoKAdGY23FhxC4nS2pDvxzIvxb-8THU0XlEQJ-ZB7SnXTAvc_LhOckhMdLBnbtndpb-SB7a8q2SRD_W00
+        this.#duplex = new DuplexStreamFactory({
+            close: async () => {
+                this.#closed = true;
+                await this.dispatcher.sendPacket(AdbCommand.Close, this.localId, this.remoteId);
+                // Don't `dispose` here, we need to wait for `CLSE` response packet.
+                return false;
+            },
+            dispose: () => {
+                // Error out the pending writes
+                this.#writePromise?.reject(new Error("Socket closed"));
+            },
+        });
+        this.#readable = this.#duplex.wrapReadable(new PushReadableStream((controller) => {
+            this.#readableController = controller;
+        }, {
+            highWaterMark: options.highWaterMark ?? 16 * 1024,
+            size(chunk) {
+                return chunk.byteLength;
+            },
+        }));
+        this.writable = pipeFrom(this.#duplex.createWritable(new ConsumableWritableStream({
+            write: async (chunk) => {
+                // Wait for an ack packet
+                this.#writePromise = new PromiseResolver();
+                await this.dispatcher.sendPacket(AdbCommand.Write, this.localId, this.remoteId, chunk);
+                await this.#writePromise.promise;
+            },
+        })), new DistributionStream(this.dispatcher.options.maxPayloadSize));
+        this._socket = new AdbDaemonSocket(this);
+    }
+    async enqueue(data) {
+        // Consumer may abort the `ReadableStream` to close the socket,
+        // it's OK to throw away further packets in this case.
+        if (this.#readableController.abortSignal.aborted) {
+            return;
+        }
+        await this.#readableController.enqueue(data);
+    }
+    ack() {
+        this.#writePromise?.resolve();
+    }
+    async close() {
+        await this.#duplex.close();
+    }
+    dispose() {
+        return this.#duplex.dispose();
+    }
+}
+/**
+ * A duplex stream representing a socket to ADB daemon.
+ *
+ * To close it, call either `socket.close()`,
+ * `socket.readable.cancel()`, `socket.readable.getReader().cancel()`,
+ * `socket.writable.abort()`, `socket.writable.getWriter().abort()`,
+ * `socket.writable.close()` or `socket.writable.getWriter().close()`.
+ */
+export class AdbDaemonSocket {
+    #controller;
+    get localId() {
+        return this.#controller.localId;
+    }
+    get remoteId() {
+        return this.#controller.remoteId;
+    }
+    get localCreated() {
+        return this.#controller.localCreated;
+    }
+    get service() {
+        return this.#controller.service;
+    }
+    get readable() {
+        return this.#controller.readable;
+    }
+    get writable() {
+        return this.#controller.writable;
+    }
+    get closed() {
+        return this.#controller.closed;
+    }
+    constructor(controller) {
+        this.#controller = controller;
+    }
+    close() {
+        return this.#controller.close();
+    }
+}
 //# sourceMappingURL=socket.js.map

package/esm/daemon/socket.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket.js","sourceRoot":"","sources":["../../src/daemon/socket.ts"],"names":[],"mappings":"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"}

package/esm/daemon/transport.d.ts

@@ -0,0 +1,45 @@
+import type { Consumable, ReadableWritablePair } from "@yume-chan/stream-extra";
+import type { ValueOrPromise } from "@yume-chan/struct";
+import type { AdbIncomingSocketHandler, AdbSocket, AdbTransport } from "../adb.js";
+import { AdbBanner } from "../banner.js";
+import type { AdbAuthenticator, AdbCredentialStore } from "./auth.js";
+import type { AdbPacketData, AdbPacketInit } from "./packet.js";
+export declare const ADB_DAEMON_VERSION_OMIT_CHECKSUM = 16777217;
+interface AdbDaemonAuthenticationOptions {
+    serial: string;
+    connection: ReadableWritablePair<AdbPacketData, Consumable<AdbPacketInit>>;
+    credentialStore: AdbCredentialStore;
+    authenticators?: AdbAuthenticator[];
+}
+interface AdbDaemonSocketConnectorConstructionOptions {
+    serial: string;
+    connection: ReadableWritablePair<AdbPacketData, Consumable<AdbPacketInit>>;
+    version: number;
+    maxPayloadSize: number;
+    banner: string;
+}
+export declare class AdbDaemonTransport implements AdbTransport {
+    #private;
+    /**
+     * Authenticates the connection and creates an `AdbDaemonTransport` instance
+     * that can be used by `Adb` class.
+     *
+     * If an authentication process failed, it's possible to call `authenticate` again
+     * on the same connection. Because every time the device receives a `CNXN` packet,
+     * it resets all internal state, and starts a new authentication process.
+     */
+    static authenticate({ serial, connection, credentialStore, authenticators, }: AdbDaemonAuthenticationOptions): Promise<AdbDaemonTransport>;
+    get serial(): string;
+    get protocolVersion(): number;
+    get maxPayloadSize(): number;
+    get banner(): AdbBanner;
+    get disconnected(): Promise<void>;
+    constructor({ serial, connection, version, maxPayloadSize, banner, }: AdbDaemonSocketConnectorConstructionOptions);
+    connect(service: string): ValueOrPromise<AdbSocket>;
+    addReverseTunnel(handler: AdbIncomingSocketHandler, address?: string): string;
+    removeReverseTunnel(address: string): void;
+    clearReverseTunnels(): void;
+    close(): ValueOrPromise<void>;
+}
+export {};
+//# sourceMappingURL=transport.d.ts.map

package/esm/daemon/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../src/daemon/transport.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAMhF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxD,OAAO,KAAK,EACR,wBAAwB,EACxB,SAAS,EACT,YAAY,EACf,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAGzC,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAMtE,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGhE,eAAO,MAAM,gCAAgC,WAAa,CAAC;AAE3D,UAAU,8BAA8B;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,oBAAoB,CAAC,aAAa,EAAE,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC;IAC3E,eAAe,EAAE,kBAAkB,CAAC;IACpC,cAAc,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACvC;AAED,UAAU,2CAA2C;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,oBAAoB,CAAC,aAAa,EAAE,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC;IAC3E,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,kBAAmB,YAAW,YAAY;;IACnD;;;;;;;OAOG;WACiB,YAAY,CAAC,EAC7B,MAAM,EACN,UAAU,EACV,eAAe,EACf,cAA2C,GAC9C,EAAE,8BAA8B,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAkI/D,IAAW,MAAM,WAEhB;IAGD,IAAW,eAAe,WAEzB;IAGD,IAAW,cAAc,WAExB;IAGD,IAAW,MAAM,cAEhB;IAED,IAAW,YAAY,kBAEtB;gBAEkB,EACf,MAAM,EACN,UAAU,EACV,OAAO,EACP,cAAc,EACd,MAAM,GACT,EAAE,2CAA2C;IAwBvC,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,CAAC,SAAS,CAAC;IAInD,gBAAgB,CACnB,OAAO,EAAE,wBAAwB,EACjC,OAAO,CAAC,EAAE,MAAM,GACjB,MAAM;IASF,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAI1C,mBAAmB,IAAI,IAAI;IAI3B,KAAK,IAAI,cAAc,CAAC,IAAI,CAAC;CAGvC"}

package/esm/daemon/transport.js

@@ -0,0 +1,184 @@
+import { PromiseResolver } from "@yume-chan/async";
+import { AbortController, ConsumableWritableStream, WritableStream, } from "@yume-chan/stream-extra";
+import { decodeUtf8, encodeUtf8 } from "@yume-chan/struct";
+import { AdbBanner } from "../banner.js";
+import { AdbFeature } from "../features.js";
+import { ADB_DEFAULT_AUTHENTICATORS, AdbAuthenticationProcessor, } from "./auth.js";
+import { AdbPacketDispatcher } from "./dispatcher.js";
+import { AdbCommand, calculateChecksum } from "./packet.js";
+export const ADB_DAEMON_VERSION_OMIT_CHECKSUM = 0x01000001;
+export class AdbDaemonTransport {
+    /**
+     * Authenticates the connection and creates an `AdbDaemonTransport` instance
+     * that can be used by `Adb` class.
+     *
+     * If an authentication process failed, it's possible to call `authenticate` again
+     * on the same connection. Because every time the device receives a `CNXN` packet,
+     * it resets all internal state, and starts a new authentication process.
+     */
+    static async authenticate({ serial, connection, credentialStore, authenticators = ADB_DEFAULT_AUTHENTICATORS, }) {
+        // Initially, set to highest-supported version and payload size.
+        let version = 0x01000001;
+        // Android 4: 4K, Android 7: 256K, Android 9: 1M
+        let maxPayloadSize = 1024 * 1024;
+        const resolver = new PromiseResolver();
+        const authProcessor = new AdbAuthenticationProcessor(authenticators, credentialStore);
+        // Here is similar to `AdbPacketDispatcher`,
+        // But the received packet types and send packet processing are different.
+        const abortController = new AbortController();
+        const pipe = connection.readable
+            .pipeTo(new WritableStream({
+            async write(packet) {
+                switch (packet.command) {
+                    case AdbCommand.Connect:
+                        version = Math.min(version, packet.arg0);
+                        maxPayloadSize = Math.min(maxPayloadSize, packet.arg1);
+                        resolver.resolve(decodeUtf8(packet.payload));
+                        break;
+                    case AdbCommand.Auth: {
+                        const response = await authProcessor.process(packet);
+                        await sendPacket(response);
+                        break;
+                    }
+                    default:
+                        // Maybe the previous ADB client exited without reading all packets,
+                        // so they are still waiting in OS internal buffer.
+                        // Just ignore them.
+                        // Because a `Connect` packet will reset the device,
+                        // Eventually there will be `Connect` and `Auth` response packets.
+                        break;
+                }
+            },
+        }), {
+            // Don't cancel the source ReadableStream on AbortSignal abort.
+            preventCancel: true,
+            signal: abortController.signal,
+        })
+            .then(() => {
+            if (resolver.state === "running") {
+                resolver.reject(new Error("Connection closed unexpectedly"));
+            }
+        }, (e) => {
+            resolver.reject(e);
+        });
+        const writer = connection.writable.getWriter();
+        async function sendPacket(init) {
+            // Always send checksum in auth steps
+            // Because we don't know if the device needs it or not.
+            init.checksum = calculateChecksum(init.payload);
+            init.magic = init.command ^ 0xffffffff;
+            await ConsumableWritableStream.write(writer, init);
+        }
+        let banner;
+        try {
+            // 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 = [
+                AdbFeature.ShellV2,
+                AdbFeature.Cmd,
+                AdbFeature.StatV2,
+                AdbFeature.ListV2,
+                AdbFeature.FixedPushMkdir,
+                "apex",
+                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",
+                AdbFeature.AbbExec,
+                "remount_shell",
+                "track_app",
+                "sendrecv_v2",
+                "sendrecv_v2_brotli",
+                "sendrecv_v2_lz4",
+                "sendrecv_v2_zstd",
+                "sendrecv_v2_dry_run_send",
+            ].join(",");
+            await sendPacket({
+                command: AdbCommand.Connect,
+                arg0: version,
+                arg1: maxPayloadSize,
+                // The terminating `;` is required in formal definition
+                // But ADB daemon (all versions) can still work without it
+                payload: encodeUtf8(`host::features=${features}`),
+            });
+            banner = await resolver.promise;
+        }
+        finally {
+            // When failed, release locks on `connection` so the caller can try again.
+            // When success, also release locks so `AdbPacketDispatcher` can use them.
+            abortController.abort();
+            writer.releaseLock();
+            // Wait until pipe stops (`ReadableStream` lock released)
+            await pipe;
+        }
+        return new AdbDaemonTransport({
+            serial,
+            connection,
+            version,
+            maxPayloadSize,
+            banner,
+        });
+    }
+    #dispatcher;
+    #serial;
+    get serial() {
+        return this.#serial;
+    }
+    #protocolVersion;
+    get protocolVersion() {
+        return this.#protocolVersion;
+    }
+    #maxPayloadSize;
+    get maxPayloadSize() {
+        return this.#maxPayloadSize;
+    }
+    #banner;
+    get banner() {
+        return this.#banner;
+    }
+    get disconnected() {
+        return this.#dispatcher.disconnected;
+    }
+    constructor({ serial, connection, version, maxPayloadSize, banner, }) {
+        this.#serial = serial;
+        this.#banner = AdbBanner.parse(banner);
+        let calculateChecksum;
+        let appendNullToServiceString;
+        if (version >= ADB_DAEMON_VERSION_OMIT_CHECKSUM) {
+            calculateChecksum = false;
+            appendNullToServiceString = false;
+        }
+        else {
+            calculateChecksum = true;
+            appendNullToServiceString = true;
+        }
+        this.#dispatcher = new AdbPacketDispatcher(connection, {
+            calculateChecksum,
+            appendNullToServiceString,
+            maxPayloadSize,
+        });
+        this.#protocolVersion = version;
+        this.#maxPayloadSize = maxPayloadSize;
+    }
+    connect(service) {
+        return this.#dispatcher.createSocket(service);
+    }
+    addReverseTunnel(handler, address) {
+        if (!address) {
+            const id = Math.random().toString().substring(2);
+            address = `localabstract:reverse_${id}`;
+        }
+        this.#dispatcher.addReverseTunnel(address, handler);
+        return address;
+    }
+    removeReverseTunnel(address) {
+        this.#dispatcher.removeReverseTunnel(address);
+    }
+    clearReverseTunnels() {
+        this.#dispatcher.clearReverseTunnels();
+    }
+    close() {
+        return this.#dispatcher.close();
+    }
+}
+//# sourceMappingURL=transport.js.map