@yume-chan/adb 0.0.19 → 0.0.21

package/src/commands/sync/socket.ts

@@ -7,91 +7,93 @@ import {
     BufferedReadableStream,
     ConsumableWritableStream,
 } from "@yume-chan/stream-extra";
-import type { StructAsyncDeserializeStream } from "@yume-chan/struct";
+import type { AsyncExactReadable } from "@yume-chan/struct";
 
-import type { AdbSocket } from "../../index.js";
-import { AutoResetEvent } from "../../index.js";
+import type { AdbSocket } from "../../adb.js";
+import { AutoResetEvent } from "../../utils/index.js";
 
-export class AdbSyncSocketLocked implements StructAsyncDeserializeStream {
-    private readonly _writer: WritableStreamDefaultWriter<
-        Consumable<Uint8Array>
-    >;
-    private readonly _readable: BufferedReadableStream;
-    private readonly _socketLock: AutoResetEvent;
-    private readonly _writeLock = new AutoResetEvent();
-    private readonly _combiner: BufferCombiner;
+export class AdbSyncSocketLocked implements AsyncExactReadable {
+    readonly #writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>;
+    readonly #readable: BufferedReadableStream;
+    readonly #socketLock: AutoResetEvent;
+    readonly #writeLock = new AutoResetEvent();
+    readonly #combiner: BufferCombiner;
 
-    public constructor(
+    get position() {
+        return this.#readable.position;
+    }
+
+    constructor(
         writer: WritableStreamDefaultWriter<Consumable<Uint8Array>>,
         readable: BufferedReadableStream,
         bufferSize: number,
-        lock: AutoResetEvent
+        lock: AutoResetEvent,
     ) {
-        this._writer = writer;
-        this._readable = readable;
-        this._socketLock = lock;
-        this._combiner = new BufferCombiner(bufferSize);
+        this.#writer = writer;
+        this.#readable = readable;
+        this.#socketLock = lock;
+        this.#combiner = new BufferCombiner(bufferSize);
     }
 
-    private async writeInnerStream(buffer: Uint8Array) {
-        await ConsumableWritableStream.write(this._writer, buffer);
+    async #writeInnerStream(buffer: Uint8Array) {
+        await ConsumableWritableStream.write(this.#writer, buffer);
     }
 
-    public async flush() {
+    async flush() {
         try {
-            await this._writeLock.wait();
-            const buffer = this._combiner.flush();
+            await this.#writeLock.wait();
+            const buffer = this.#combiner.flush();
             if (buffer) {
-                await this.writeInnerStream(buffer);
+                await this.#writeInnerStream(buffer);
             }
         } finally {
-            this._writeLock.notifyOne();
+            this.#writeLock.notifyOne();
         }
     }
 
-    public async write(data: Uint8Array) {
+    async write(data: Uint8Array) {
         try {
-            await this._writeLock.wait();
-            for (const buffer of this._combiner.push(data)) {
-                await this.writeInnerStream(buffer);
+            await this.#writeLock.wait();
+            for (const buffer of this.#combiner.push(data)) {
+                await this.#writeInnerStream(buffer);
             }
         } finally {
-            this._writeLock.notifyOne();
+            this.#writeLock.notifyOne();
         }
     }
 
-    public async read(length: number) {
+    async readExactly(length: number) {
         await this.flush();
-        return await this._readable.read(length);
+        return await this.#readable.readExactly(length);
     }
 
-    public release(): void {
-        this._combiner.flush();
-        this._socketLock.notifyOne();
+    release(): void {
+        this.#combiner.flush();
+        this.#socketLock.notifyOne();
     }
 }
 
 export class AdbSyncSocket {
-    private _lock = new AutoResetEvent();
-    private _socket: AdbSocket;
-    private _locked: AdbSyncSocketLocked;
+    readonly #lock = new AutoResetEvent();
+    readonly #socket: AdbSocket;
+    readonly #locked: AdbSyncSocketLocked;
 
-    public constructor(socket: AdbSocket, bufferSize: number) {
-        this._socket = socket;
-        this._locked = new AdbSyncSocketLocked(
+    constructor(socket: AdbSocket, bufferSize: number) {
+        this.#socket = socket;
+        this.#locked = new AdbSyncSocketLocked(
             socket.writable.getWriter(),
             new BufferedReadableStream(socket.readable),
             bufferSize,
-            this._lock
+            this.#lock,
         );
     }
 
-    public async lock() {
-        await this._lock.wait();
-        return this._locked;
+    async lock() {
+        await this.#lock.wait();
+        return this.#locked;
     }
 
-    public async close() {
-        await this._socket.close();
+    async close() {
+        await this.#socket.close();
     }
 }

package/src/commands/sync/stat.ts

@@ -103,7 +103,7 @@ export type AdbSyncStatResponse =
 export async function adbSyncLstat(
     socket: AdbSyncSocket,
     path: string,
-    v2: boolean
+    v2: boolean,
 ): Promise<AdbSyncStat> {
     const locked = await socket.lock();
     try {
@@ -112,14 +112,14 @@ export async function adbSyncLstat(
             return await adbSyncReadResponse(
                 locked,
                 AdbSyncResponseId.Lstat2,
-                AdbSyncStatResponse
+                AdbSyncStatResponse,
             );
         } else {
             await adbSyncWriteRequest(locked, AdbSyncRequestId.Lstat, path);
             const response = await adbSyncReadResponse(
                 locked,
                 AdbSyncResponseId.Lstat,
-                AdbSyncLstatResponse
+                AdbSyncLstatResponse,
             );
             return {
                 mode: response.mode,
@@ -141,7 +141,7 @@ export async function adbSyncLstat(
 
 export async function adbSyncStat(
     socket: AdbSyncSocket,
-    path: string
+    path: string,
 ): Promise<AdbSyncStatResponse> {
     const locked = await socket.lock();
     try {
@@ -149,7 +149,7 @@ export async function adbSyncStat(
         return await adbSyncReadResponse(
             locked,
             AdbSyncResponseId.Stat,
-            AdbSyncStatResponse
+            AdbSyncStatResponse,
         );
     } finally {
         locked.release();

package/src/commands/sync/sync.ts

@@ -1,9 +1,8 @@
 import { AutoDisposable } from "@yume-chan/event";
 import type { Consumable, ReadableStream } from "@yume-chan/stream-extra";
 
-import type { Adb } from "../../adb.js";
+import type { Adb, AdbSocket } from "../../adb.js";
 import { AdbFeature } from "../../features.js";
-import type { AdbSocket } from "../../socket/index.js";
 import { escapeArg } from "../subprocess/index.js";
 
 import type { AdbSyncEntry } from "./list.js";
@@ -11,6 +10,7 @@ import { adbSyncOpenDir } from "./list.js";
 import { adbSyncPull } from "./pull.js";
 import { adbSyncPush } from "./push.js";
 import { AdbSyncSocket } from "./socket.js";
+import type { AdbSyncStat, LinuxFileType } from "./stat.js";
 import { adbSyncLstat, adbSyncStat } from "./stat.js";
 
 /**
@@ -32,7 +32,8 @@ export function dirname(path: string): string {
 export interface AdbSyncWriteOptions {
     filename: string;
     file: ReadableStream<Consumable<Uint8Array>>;
-    mode?: number;
+    type?: LinuxFileType;
+    permission?: number;
     mtime?: number;
     dryRun?: boolean;
 }
@@ -41,63 +42,78 @@ export class AdbSync extends AutoDisposable {
     protected _adb: Adb;
     protected _socket: AdbSyncSocket;
 
-    private _supportsStat: boolean;
-    private _supportsListV2: boolean;
-    private _fixedPushMkdir: boolean;
-    private _supportsSendReceiveV2: boolean;
-    private _needPushMkdirWorkaround: boolean;
+    readonly #supportsStat: boolean;
+    readonly #supportsListV2: boolean;
+    readonly #fixedPushMkdir: boolean;
+    readonly #supportsSendReceiveV2: boolean;
+    readonly #needPushMkdirWorkaround: boolean;
 
-    public get supportsStat(): boolean {
-        return this._supportsStat;
+    get supportsStat(): boolean {
+        return this.#supportsStat;
     }
 
-    public get supportsListV2(): boolean {
-        return this._supportsListV2;
+    get supportsListV2(): boolean {
+        return this.#supportsListV2;
     }
 
-    public get fixedPushMkdir(): boolean {
-        return this._fixedPushMkdir;
+    get fixedPushMkdir(): boolean {
+        return this.#fixedPushMkdir;
     }
 
-    public get supportsSendReceiveV2(): boolean {
-        return this._supportsSendReceiveV2;
+    get supportsSendReceiveV2(): boolean {
+        return this.#supportsSendReceiveV2;
     }
 
-    public get needPushMkdirWorkaround(): boolean {
-        return this._needPushMkdirWorkaround;
+    get needPushMkdirWorkaround(): boolean {
+        return this.#needPushMkdirWorkaround;
     }
 
-    public constructor(adb: Adb, socket: AdbSocket) {
+    constructor(adb: Adb, socket: AdbSocket) {
         super();
 
         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(
-            AdbFeature.SendReceiveV2
+        this.#supportsStat = adb.supportsFeature(AdbFeature.StatV2);
+        this.#supportsListV2 = adb.supportsFeature(AdbFeature.ListV2);
+        this.#fixedPushMkdir = adb.supportsFeature(AdbFeature.FixedPushMkdir);
+        this.#supportsSendReceiveV2 = adb.supportsFeature(
+            AdbFeature.SendReceiveV2,
         );
         // https://android.googlesource.com/platform/packages/modules/adb/+/91768a57b7138166e0a3d11f79cd55909dda7014/client/file_sync_client.cpp#1361
-        this._needPushMkdirWorkaround =
+        this.#needPushMkdirWorkaround =
             this._adb.supportsFeature(AdbFeature.ShellV2) &&
             !this.fixedPushMkdir;
     }
 
-    public async lstat(path: string) {
-        return await adbSyncLstat(this._socket, path, this.supportsStat);
+    /**
+     * Gets information of a file or folder.
+     *
+     * If `path` points to a symbolic link, the returned information is about the link itself (with `type` being `LinuxFileType.Link`).
+     */
+    async lstat(path: string): Promise<AdbSyncStat> {
+        return await adbSyncLstat(this._socket, path, this.#supportsStat);
     }
 
-    public async stat(path: string) {
-        if (!this.supportsStat) {
+    /**
+     * Gets the information of a file or folder.
+     *
+     * If `path` points to a symbolic link, it will be resolved and the returned information is about the target (with `type` being `LinuxFileType.File` or `LinuxFileType.Directory`).
+     */
+    async stat(path: string) {
+        if (!this.#supportsStat) {
             throw new Error("Not supported");
         }
 
         return await adbSyncStat(this._socket, path);
     }
 
-    public async isDirectory(path: string): Promise<boolean> {
+    /**
+     * Checks if `path` is a directory, or a symbolic link to a directory.
+     *
+     * This uses `lstat` internally, thus works on all Android versions.
+     */
+    async isDirectory(path: string): Promise<boolean> {
         try {
             await this.lstat(path + "/");
             return true;
@@ -106,11 +122,11 @@ export class AdbSync extends AutoDisposable {
         }
     }
 
-    public opendir(path: string): AsyncGenerator<AdbSyncEntry, void, void> {
+    opendir(path: string): AsyncGenerator<AdbSyncEntry, void, void> {
         return adbSyncOpenDir(this._socket, path, this.supportsListV2);
     }
 
-    public async readdir(path: string) {
+    async readdir(path: string) {
         const results: AdbSyncEntry[] = [];
         for await (const entry of this.opendir(path)) {
             results.push(entry);
@@ -119,25 +135,21 @@ export class AdbSync extends AutoDisposable {
     }
 
     /**
-     * Read the content of a file on device.
+     * Reads the content of a file on device.
      *
      * @param filename The full path of the file on device to read.
-     * @returns A `ReadableStream` that reads from the file.
+     * @returns A `ReadableStream` that contains the file content.
      */
-    public read(filename: string): ReadableStream<Uint8Array> {
+    read(filename: string): ReadableStream<Uint8Array> {
         return adbSyncPull(this._socket, filename);
     }
 
     /**
-     * Write (or overwrite) a file on device.
+     * Writes a file on device. If the file name already exists, it will be overwritten.
      *
-     * @param filename The full path of the file on device to write.
-     * @param file The content to write.
-     * @param mode The unix permissions of the file.
-     * @param mtime The modified time of the file.
-     * @returns A `WritableStream` that writes to the file.
+     * @param options The content and options of the file to write.
      */
-    public async write(options: AdbSyncWriteOptions) {
+    async write(options: AdbSyncWriteOptions): Promise<void> {
         if (this.needPushMkdirWorkaround) {
             // It may fail if the path is already existed.
             // Ignore the result.
@@ -156,7 +168,7 @@ export class AdbSync extends AutoDisposable {
         });
     }
 
-    public override async dispose() {
+    override async dispose() {
         super.dispose();
         await this._socket.close();
     }

package/src/commands/tcpip.ts

@@ -1,21 +1,23 @@
 import { AdbCommandBase } from "./base.js";
 
 export class AdbTcpIpCommand extends AdbCommandBase {
-    public async setPort(port: number): Promise<void> {
+    async setPort(port: number): Promise<string> {
         if (port <= 0) {
             throw new Error(`Invalid port ${port}`);
         }
 
         const output = await this.adb.createSocketAndWait(`tcpip:${port}`);
         if (output !== `restarting in TCP mode port: ${port}\n`) {
-            throw new Error("Invalid response");
+            throw new Error(output);
         }
+        return output;
     }
 
-    public async disable(): Promise<void> {
+    async disable(): Promise<string> {
         const output = await this.adb.createSocketAndWait("usb:");
         if (output !== "restarting in USB mode\n") {
-            throw new Error("Invalid response");
+            throw new Error(output);
         }
+        return output;
     }
 }

package/src/{auth.ts → daemon/auth.ts}

@@ -1,28 +1,42 @@
 import { PromiseResolver } from "@yume-chan/async";
 import type { Disposable } from "@yume-chan/event";
 import type { ValueOrPromise } from "@yume-chan/struct";
+import { EMPTY_UINT8_ARRAY } from "@yume-chan/struct";
 
 import {
-    calculatePublicKey,
-    calculatePublicKeyLength,
-    sign,
+    calculateBase64EncodedLength,
+    encodeBase64,
+    encodeUtf8,
+} from "../utils/index.js";
+
+import {
+    adbGeneratePublicKey,
+    adbGetPublicKeySize,
+    rsaSign,
 } from "./crypto.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>;
+export interface AdbPrivateKey {
+    /**
+     * The private key in PKCS #8 format.
+     */
+    buffer: Uint8Array;
+    name?: string | undefined;
+}
+
+export type AdbKeyIterable =
+    | Iterable<AdbPrivateKey>
+    | AsyncIterable<AdbPrivateKey>;
 
 export interface AdbCredentialStore {
     /**
-     * Generate and store a RSA private key with modulus length `2048` and public exponent `65537`.
-     *
-     * The returned `Uint8Array` is the private key in PKCS #8 format.
+     * Generates and stores a RSA private key with modulus length `2048` and public exponent `65537`.
      */
-    generateKey(): ValueOrPromise<Uint8Array>;
+    generateKey(): ValueOrPromise<AdbPrivateKey>;
 
     /**
-     * Synchronously or asynchronously iterate through all stored RSA private keys.
+     * Synchronously or asynchronously iterates through all stored RSA private keys.
      *
      * Each call to `iterateKeys` must return a different iterator that iterate through all stored keys.
      */
@@ -49,13 +63,13 @@ export interface AdbAuthenticator {
      */
     (
         credentialStore: AdbCredentialStore,
-        getNextRequest: () => Promise<AdbPacketData>
+        getNextRequest: () => Promise<AdbPacketData>,
     ): AsyncIterable<AdbPacketData>;
 }
 
 export const AdbSignatureAuthenticator: AdbAuthenticator = async function* (
     credentialStore: AdbCredentialStore,
-    getNextRequest: () => Promise<AdbPacketData>
+    getNextRequest: () => Promise<AdbPacketData>,
 ): AsyncIterable<AdbPacketData> {
     for await (const key of credentialStore.iterateKeys()) {
         const packet = await getNextRequest();
@@ -64,7 +78,7 @@ export const AdbSignatureAuthenticator: AdbAuthenticator = async function* (
             return;
         }
 
-        const signature = sign(key, packet.payload);
+        const signature = rsaSign(key.buffer, packet.payload);
         yield {
             command: AdbCommand.Auth,
             arg0: AdbAuthType.Signature,
@@ -76,7 +90,7 @@ export const AdbSignatureAuthenticator: AdbAuthenticator = async function* (
 
 export const AdbPublicKeyAuthenticator: AdbAuthenticator = async function* (
     credentialStore: AdbCredentialStore,
-    getNextRequest: () => Promise<AdbPacketData>
+    getNextRequest: () => Promise<AdbPacketData>,
 ): AsyncIterable<AdbPacketData> {
     const packet = await getNextRequest();
 
@@ -84,7 +98,7 @@ export const AdbPublicKeyAuthenticator: AdbAuthenticator = async function* (
         return;
     }
 
-    let privateKey: Uint8Array | undefined;
+    let privateKey: AdbPrivateKey | undefined;
     for await (const key of credentialStore.iterateKeys()) {
         privateKey = key;
         break;
@@ -94,17 +108,27 @@ export const AdbPublicKeyAuthenticator: AdbAuthenticator = async function* (
         privateKey = await credentialStore.generateKey();
     }
 
-    const publicKeyLength = calculatePublicKeyLength();
+    const publicKeyLength = adbGetPublicKeySize();
     const [publicKeyBase64Length] =
         calculateBase64EncodedLength(publicKeyLength);
 
+    const nameBuffer = privateKey.name?.length
+        ? encodeUtf8(privateKey.name)
+        : EMPTY_UINT8_ARRAY;
     const publicKeyBuffer = new Uint8Array(
-        publicKeyBase64Length + 1 // Null character
+        publicKeyBase64Length +
+            (nameBuffer.length ? nameBuffer.length + 1 : 0) + // Space character + name
+            1, // Null character
     );
 
-    calculatePublicKey(privateKey, publicKeyBuffer);
+    adbGeneratePublicKey(privateKey.buffer, publicKeyBuffer);
     encodeBase64(publicKeyBuffer.subarray(0, publicKeyLength), publicKeyBuffer);
 
+    if (nameBuffer.length) {
+        publicKeyBuffer[publicKeyBase64Length] = 0x20;
+        publicKeyBuffer.set(nameBuffer, publicKeyBase64Length + 1);
+    }
+
     yield {
         command: AdbCommand.Auth,
         arg0: AdbAuthType.PublicKey,
@@ -119,39 +143,34 @@ export const ADB_DEFAULT_AUTHENTICATORS: AdbAuthenticator[] = [
 ];
 
 export class AdbAuthenticationProcessor implements Disposable {
-    public readonly authenticators: readonly AdbAuthenticator[];
+    readonly authenticators: readonly AdbAuthenticator[];
 
-    private readonly credentialStore: AdbCredentialStore;
+    readonly #credentialStore: AdbCredentialStore;
 
-    private pendingRequest = new PromiseResolver<AdbPacketData>();
+    #pendingRequest = new PromiseResolver<AdbPacketData>();
+    #iterator: AsyncIterator<AdbPacketData, void, void> | undefined;
 
-    private iterator: AsyncIterator<AdbPacketData, void, void> | undefined;
-
-    public constructor(
+    constructor(
         authenticators: readonly AdbAuthenticator[],
-        credentialStore: AdbCredentialStore
+        credentialStore: AdbCredentialStore,
     ) {
         this.authenticators = authenticators;
-        this.credentialStore = credentialStore;
+        this.#credentialStore = credentialStore;
     }
 
-    private getNextRequest = (): Promise<AdbPacketData> => {
-        return this.pendingRequest.promise;
+    #getNextRequest = (): Promise<AdbPacketData> => {
+        return this.#pendingRequest.promise;
     };
 
-    private async *invokeAuthenticator(): AsyncGenerator<
-        AdbPacketData,
-        void,
-        void
-    > {
+    async *#invokeAuthenticator(): AsyncGenerator<AdbPacketData, void, void> {
         for (const authenticator of this.authenticators) {
             for await (const packet of authenticator(
-                this.credentialStore,
-                this.getNextRequest
+                this.#credentialStore,
+                this.#getNextRequest,
             )) {
                 // If the authenticator yielded a response
                 // Prepare `nextRequest` for next authentication request
-                this.pendingRequest = new PromiseResolver();
+                this.#pendingRequest = new PromiseResolver();
 
                 // Yield the response to outer layer
                 yield packet;
@@ -162,14 +181,14 @@ export class AdbAuthenticationProcessor implements Disposable {
         }
     }
 
-    public async process(packet: AdbPacketData): Promise<AdbPacketData> {
-        if (!this.iterator) {
-            this.iterator = this.invokeAuthenticator();
+    async process(packet: AdbPacketData): Promise<AdbPacketData> {
+        if (!this.#iterator) {
+            this.#iterator = this.#invokeAuthenticator();
         }
 
-        this.pendingRequest.resolve(packet);
+        this.#pendingRequest.resolve(packet);
 
-        const result = await this.iterator.next();
+        const result = await this.#iterator.next();
         if (result.done) {
             throw new Error("No authenticator can handle the request");
         }
@@ -177,7 +196,7 @@ export class AdbAuthenticationProcessor implements Disposable {
         return result.value;
     }
 
-    public dispose() {
-        void this.iterator?.return?.();
+    dispose() {
+        void this.#iterator?.return?.();
     }
 }