appium-ios-remotexpc 0.8.0 → 0.10.0

package/build/src/services/ios/afc/enums.js

@@ -0,0 +1,70 @@
+/**
+ * Enums for AFC protocol as defined by Apple's AFC service
+ */
+export var AfcOpcode;
+(function (AfcOpcode) {
+    AfcOpcode[AfcOpcode["STATUS"] = 1] = "STATUS";
+    AfcOpcode[AfcOpcode["DATA"] = 2] = "DATA";
+    AfcOpcode[AfcOpcode["READ_DIR"] = 3] = "READ_DIR";
+    AfcOpcode[AfcOpcode["REMOVE_PATH"] = 8] = "REMOVE_PATH";
+    AfcOpcode[AfcOpcode["MAKE_DIR"] = 9] = "MAKE_DIR";
+    AfcOpcode[AfcOpcode["GET_FILE_INFO"] = 10] = "GET_FILE_INFO";
+    AfcOpcode[AfcOpcode["GET_DEVINFO"] = 11] = "GET_DEVINFO";
+    AfcOpcode[AfcOpcode["FILE_OPEN"] = 13] = "FILE_OPEN";
+    AfcOpcode[AfcOpcode["READ"] = 15] = "READ";
+    AfcOpcode[AfcOpcode["WRITE"] = 16] = "WRITE";
+    AfcOpcode[AfcOpcode["FILE_CLOSE"] = 20] = "FILE_CLOSE";
+    AfcOpcode[AfcOpcode["RENAME_PATH"] = 24] = "RENAME_PATH";
+    AfcOpcode[AfcOpcode["MAKE_LINK"] = 28] = "MAKE_LINK";
+})(AfcOpcode || (AfcOpcode = {}));
+export var AfcError;
+(function (AfcError) {
+    AfcError[AfcError["SUCCESS"] = 0] = "SUCCESS";
+    AfcError[AfcError["UNKNOWN_ERROR"] = 1] = "UNKNOWN_ERROR";
+    AfcError[AfcError["OP_HEADER_INVALID"] = 2] = "OP_HEADER_INVALID";
+    AfcError[AfcError["NO_RESOURCES"] = 3] = "NO_RESOURCES";
+    AfcError[AfcError["READ_ERROR"] = 4] = "READ_ERROR";
+    AfcError[AfcError["WRITE_ERROR"] = 5] = "WRITE_ERROR";
+    AfcError[AfcError["UNKNOWN_PACKET_TYPE"] = 6] = "UNKNOWN_PACKET_TYPE";
+    AfcError[AfcError["INVALID_ARG"] = 7] = "INVALID_ARG";
+    AfcError[AfcError["OBJECT_NOT_FOUND"] = 8] = "OBJECT_NOT_FOUND";
+    AfcError[AfcError["OBJECT_IS_DIR"] = 9] = "OBJECT_IS_DIR";
+    AfcError[AfcError["PERM_DENIED"] = 10] = "PERM_DENIED";
+    AfcError[AfcError["SERVICE_NOT_CONNECTED"] = 11] = "SERVICE_NOT_CONNECTED";
+    AfcError[AfcError["OP_TIMEOUT"] = 12] = "OP_TIMEOUT";
+    AfcError[AfcError["TOO_MUCH_DATA"] = 13] = "TOO_MUCH_DATA";
+    AfcError[AfcError["END_OF_DATA"] = 14] = "END_OF_DATA";
+    AfcError[AfcError["OP_NOT_SUPPORTED"] = 15] = "OP_NOT_SUPPORTED";
+    AfcError[AfcError["OBJECT_EXISTS"] = 16] = "OBJECT_EXISTS";
+    AfcError[AfcError["OBJECT_BUSY"] = 17] = "OBJECT_BUSY";
+    AfcError[AfcError["NO_SPACE_LEFT"] = 18] = "NO_SPACE_LEFT";
+    AfcError[AfcError["OP_WOULD_BLOCK"] = 19] = "OP_WOULD_BLOCK";
+    AfcError[AfcError["IO_ERROR"] = 20] = "IO_ERROR";
+    AfcError[AfcError["OP_INTERRUPTED"] = 21] = "OP_INTERRUPTED";
+    AfcError[AfcError["OP_IN_PROGRESS"] = 22] = "OP_IN_PROGRESS";
+    AfcError[AfcError["INTERNAL_ERROR"] = 23] = "INTERNAL_ERROR";
+    AfcError[AfcError["MUX_ERROR"] = 30] = "MUX_ERROR";
+    AfcError[AfcError["NO_MEM"] = 31] = "NO_MEM";
+    AfcError[AfcError["NOT_ENOUGH_DATA"] = 32] = "NOT_ENOUGH_DATA";
+    AfcError[AfcError["DIR_NOT_EMPTY"] = 33] = "DIR_NOT_EMPTY";
+})(AfcError || (AfcError = {}));
+export var AfcLinkType;
+(function (AfcLinkType) {
+    AfcLinkType[AfcLinkType["HARDLINK"] = 1] = "HARDLINK";
+    AfcLinkType[AfcLinkType["SYMLINK"] = 2] = "SYMLINK";
+})(AfcLinkType || (AfcLinkType = {}));
+export var AfcFopenMode;
+(function (AfcFopenMode) {
+    AfcFopenMode[AfcFopenMode["RDONLY"] = 1] = "RDONLY";
+    AfcFopenMode[AfcFopenMode["RW"] = 2] = "RW";
+    AfcFopenMode[AfcFopenMode["WRONLY"] = 3] = "WRONLY";
+    AfcFopenMode[AfcFopenMode["WR"] = 4] = "WR";
+    AfcFopenMode[AfcFopenMode["APPEND"] = 5] = "APPEND";
+    AfcFopenMode[AfcFopenMode["RDAPPEND"] = 6] = "RDAPPEND";
+})(AfcFopenMode || (AfcFopenMode = {}));
+export var AfcFileMode;
+(function (AfcFileMode) {
+    AfcFileMode["S_IFDIR"] = "S_IFDIR";
+    AfcFileMode["S_IFREG"] = "S_IFREG";
+    AfcFileMode["S_IFLNK"] = "S_IFLNK";
+})(AfcFileMode || (AfcFileMode = {}));

package/build/src/services/ios/afc/index.d.ts

@@ -0,0 +1,72 @@
+import { Readable, Writable } from 'node:stream';
+import { AFC_FOPEN_TEXTUAL_MODES } from './constants.js';
+import { AfcFileMode } from './enums.js';
+export interface StatInfo {
+    st_ifmt: AfcFileMode;
+    st_size: bigint;
+    st_blocks: number;
+    st_mtime: Date;
+    st_birthtime: Date;
+    st_nlink: number;
+    LinkTarget?: string;
+    [k: string]: any;
+}
+/**
+ * AFC client over RSD (Remote XPC shim).
+ * After RSDCheckin, speaks raw AFC protocol on the same socket.
+ */
+export declare class AfcService {
+    private readonly address;
+    static readonly RSD_SERVICE_NAME = "com.apple.afc.shim.remote";
+    private socket;
+    private packetNum;
+    private silent;
+    constructor(address: [string, number], silent?: boolean);
+    /**
+     * List directory entries. Returned entries do not include '.' and '..'
+     */
+    listdir(dirPath: string): Promise<string[]>;
+    stat(filePath: string): Promise<StatInfo>;
+    isdir(filePath: string): Promise<boolean>;
+    exists(filePath: string): Promise<boolean>;
+    fopen(filePath: string, mode?: keyof typeof AFC_FOPEN_TEXTUAL_MODES): Promise<bigint>;
+    fclose(handle: bigint): Promise<void>;
+    createReadStream(handle: bigint, size: bigint): Readable;
+    createWriteStream(handle: bigint, chunkSize?: number): Writable;
+    fread(handle: bigint, size: bigint): Promise<Buffer>;
+    fwrite(handle: bigint, data: Buffer, chunkSize?: number): Promise<void>;
+    getFileContents(filePath: string): Promise<Buffer>;
+    setFileContents(filePath: string, data: Buffer): Promise<void>;
+    readToStream(filePath: string): Promise<Readable>;
+    writeFromStream(filePath: string, stream: Readable): Promise<void>;
+    pull(remoteSrc: string, localDst: string): Promise<void>;
+    rmSingle(filePath: string, force?: boolean): Promise<boolean>;
+    rm(filePath: string, force?: boolean): Promise<string[]>;
+    rename(src: string, dst: string): Promise<void>;
+    push(localSrc: string, remoteDst: string): Promise<void>;
+    walk(root: string): Promise<Array<{
+        dir: string;
+        dirs: string[];
+        files: string[];
+    }>>;
+    /**
+     * Close the underlying socket
+     */
+    close(): void;
+    /**
+     * Connect to RSD port and perform RSDCheckin.
+     * Keeps the underlying socket for raw AFC I/O.
+     */
+    private _connect;
+    private _resolvePath;
+    private _dispatch;
+    private _receive;
+    /**
+     * Send a single-operation request and parse result.
+     * Throws if status != SUCCESS.
+     * Returns response DATA buffer when applicable.
+     */
+    private _doOperation;
+}
+export default AfcService;
+//# sourceMappingURL=index.d.ts.map

package/build/src/services/ios/afc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/ios/afc/index.ts"],"names":[],"mappings":"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"}

package/build/src/services/ios/afc/index.js

@@ -0,0 +1,385 @@
+import { logger } from '@appium/support';
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import { Readable, Writable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { buildClosePayload, buildFopenPayload, buildReadPayload, buildRemovePayload, buildRenamePayload, buildStatPayload, nanosecondsToMilliseconds, nextReadChunkSize, parseCStringArray, parseKeyValueNullList, readAfcResponse, rsdHandshakeForRawService, sendAfcPacket, writeUInt64LE, } from './codec.js';
+import { AFC_FOPEN_TEXTUAL_MODES, AFC_WRITE_THIS_LENGTH } from './constants.js';
+import { AfcError, AfcFileMode, AfcOpcode } from './enums.js';
+import { createAfcReadStream, createAfcWriteStream } from './stream-utils.js';
+const log = logger.getLogger('AfcService');
+const NON_LISTABLE_ENTRIES = ['', '.', '..'];
+/**
+ * AFC client over RSD (Remote XPC shim).
+ * After RSDCheckin, speaks raw AFC protocol on the same socket.
+ */
+export class AfcService {
+    address;
+    static RSD_SERVICE_NAME = 'com.apple.afc.shim.remote';
+    socket = null;
+    packetNum = 0n;
+    silent = false;
+    constructor(address, silent) {
+        this.address = address;
+        this.silent = silent ?? process.env.NODE_ENV !== 'test';
+    }
+    /**
+     * List directory entries. Returned entries do not include '.' and '..'
+     */
+    async listdir(dirPath) {
+        const data = await this._doOperation(AfcOpcode.READ_DIR, buildStatPayload(dirPath));
+        const entries = parseCStringArray(data);
+        return entries.filter((x) => !NON_LISTABLE_ENTRIES.includes(x));
+    }
+    async stat(filePath) {
+        log.debug(`Getting file info for: ${filePath}`);
+        try {
+            const data = await this._doOperation(AfcOpcode.GET_FILE_INFO, buildStatPayload(filePath));
+            const kv = parseKeyValueNullList(data);
+            const out = {
+                st_size: BigInt(kv.st_size),
+                st_blocks: Number.parseInt(kv.st_blocks, 10),
+                st_mtime: new Date(nanosecondsToMilliseconds(kv.st_mtime)),
+                st_birthtime: new Date(nanosecondsToMilliseconds(kv.st_birthtime)),
+                st_nlink: Number.parseInt(kv.st_nlink, 10),
+            };
+            for (const [k, v] of Object.entries(kv)) {
+                if (!(k in out)) {
+                    out[k] = v;
+                }
+            }
+            return out;
+        }
+        catch (error) {
+            if (!this.silent) {
+                log.error(`Failed to stat file '${filePath}':`, error);
+            }
+            throw error;
+        }
+    }
+    async isdir(filePath) {
+        const st = await this.stat(filePath);
+        return st.st_ifmt === AfcFileMode.S_IFDIR;
+    }
+    async exists(filePath) {
+        try {
+            await this.stat(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async fopen(filePath, mode = 'r') {
+        const afcMode = AFC_FOPEN_TEXTUAL_MODES[mode];
+        if (!afcMode) {
+            const allowedModes = Object.keys(AFC_FOPEN_TEXTUAL_MODES).join(', ');
+            if (!this.silent) {
+                log.error(`Invalid fopen mode '${mode}'. Allowed modes: ${allowedModes}`);
+            }
+            throw new Error(`Invalid fopen mode '${mode}'. Allowed: ${allowedModes}`);
+        }
+        log.debug(`Opening file '${filePath}' with mode '${mode}'`);
+        try {
+            const data = await this._doOperation(AfcOpcode.FILE_OPEN, buildFopenPayload(afcMode, filePath));
+            // Response data contains UInt64LE 'handle'
+            const handle = data.readBigUInt64LE(0);
+            log.debug(`File opened successfully, handle: ${handle}`);
+            return handle;
+        }
+        catch (error) {
+            if (!this.silent) {
+                log.error(`Failed to open file '${filePath}' with mode '${mode}':`, error);
+            }
+            throw error;
+        }
+    }
+    async fclose(handle) {
+        await this._doOperation(AfcOpcode.FILE_CLOSE, buildClosePayload(handle));
+    }
+    createReadStream(handle, size) {
+        return createAfcReadStream(handle, size, this._dispatch.bind(this), this._receive.bind(this));
+    }
+    createWriteStream(handle, chunkSize) {
+        return createAfcWriteStream(handle, this._dispatch.bind(this), this._receive.bind(this), chunkSize);
+    }
+    async fread(handle, size) {
+        log.debug(`Reading ${size} bytes from handle ${handle}`);
+        const stream = this.createReadStream(handle, size);
+        const chunks = [];
+        for await (const chunk of stream) {
+            chunks.push(chunk);
+        }
+        const buffer = Buffer.concat(chunks);
+        log.debug(`Successfully read ${buffer.length} bytes`);
+        return buffer;
+    }
+    async fwrite(handle, data, chunkSize = data.length) {
+        log.debug(`Writing ${data.length} bytes to handle ${handle}`);
+        const effectiveChunkSize = chunkSize;
+        let offset = 0;
+        let chunkCount = 0;
+        while (offset < data.length) {
+            const end = Math.min(offset + effectiveChunkSize, data.length);
+            const chunk = data.subarray(offset, end);
+            chunkCount++;
+            await this._dispatch(AfcOpcode.WRITE, Buffer.concat([writeUInt64LE(handle), chunk]), AFC_WRITE_THIS_LENGTH);
+            const { status } = await this._receive();
+            if (status !== AfcError.SUCCESS) {
+                const errorName = AfcError[status] || 'UNKNOWN';
+                if (!this.silent) {
+                    log.error(`Write operation failed at offset ${offset} with status ${errorName} (${status})`);
+                }
+                throw new Error(`fwrite chunk failed with ${errorName} (${status}) at offset ${offset}`);
+            }
+            offset = end;
+        }
+        log.debug(`Successfully wrote ${data.length} bytes in ${chunkCount} chunks`);
+    }
+    async getFileContents(filePath) {
+        log.debug(`Reading file contents: ${filePath}`);
+        const resolved = await this._resolvePath(filePath);
+        const st = await this.stat(resolved);
+        if (st.st_ifmt !== AfcFileMode.S_IFREG) {
+            if (!this.silent) {
+                log.error(`Path '${resolved}' is not a regular file (type: ${st.st_ifmt})`);
+            }
+            throw new Error(`'${resolved}' isn't a regular file`);
+        }
+        const h = await this.fopen(resolved, 'r');
+        try {
+            const buf = await this.fread(h, st.st_size);
+            log.debug(`Successfully read ${buf.length} bytes from ${filePath}`);
+            return buf;
+        }
+        finally {
+            await this.fclose(h);
+        }
+    }
+    async setFileContents(filePath, data) {
+        log.debug(`Writing ${data.length} bytes to file: ${filePath}`);
+        const h = await this.fopen(filePath, 'w');
+        try {
+            await this.fwrite(h, data);
+            log.debug(`Successfully wrote file: ${filePath}`);
+        }
+        catch (error) {
+            await this.rmSingle(filePath, true);
+            throw error;
+        }
+        finally {
+            await this.fclose(h);
+        }
+    }
+    async readToStream(filePath) {
+        log.debug(`Creating read stream for: ${filePath}`);
+        const resolved = await this._resolvePath(filePath);
+        const st = await this.stat(resolved);
+        if (st.st_ifmt !== AfcFileMode.S_IFREG) {
+            throw new Error(`'${resolved}' isn't a regular file`);
+        }
+        const handle = await this.fopen(resolved, 'r');
+        const stream = this.createReadStream(handle, st.st_size);
+        stream.once('close', () => this.fclose(handle).catch(() => { }));
+        return stream;
+    }
+    async writeFromStream(filePath, stream) {
+        log.debug(`Writing stream to file: ${filePath}`);
+        const handle = await this.fopen(filePath, 'w');
+        const writeStream = this.createWriteStream(handle);
+        try {
+            await pipeline(stream, writeStream);
+            log.debug(`Successfully wrote file: ${filePath}`);
+        }
+        catch (error) {
+            await this.rmSingle(filePath, true);
+            throw error;
+        }
+        finally {
+            await this.fclose(handle);
+        }
+    }
+    async pull(remoteSrc, localDst) {
+        log.debug(`Pulling file from '${remoteSrc}' to '${localDst}'`);
+        const stream = await this.readToStream(remoteSrc);
+        const writeStream = fs.createWriteStream(localDst);
+        await pipeline(stream, writeStream);
+        log.debug(`Successfully pulled file to '${localDst}'`);
+    }
+    async rmSingle(filePath, force = false) {
+        log.debug(`Removing single path: ${filePath} (force: ${force})`);
+        try {
+            await this._doOperation(AfcOpcode.REMOVE_PATH, buildRemovePayload(filePath));
+            log.debug(`Successfully removed: ${filePath}`);
+            return true;
+        }
+        catch (error) {
+            if (force) {
+                log.debug(`Failed to remove '${filePath}' (ignored due to force=true):`, error);
+                return false;
+            }
+            if (!this.silent) {
+                log.error(`Failed to remove '${filePath}':`, error);
+            }
+            throw error;
+        }
+    }
+    async rm(filePath, force = false) {
+        if (!(await this.exists(filePath))) {
+            return force ? [] : [filePath];
+        }
+        if (!(await this.isdir(filePath))) {
+            if (await this.rmSingle(filePath, force)) {
+                return [];
+            }
+            return [filePath];
+        }
+        const failedPaths = [];
+        for (const entry of await this.listdir(filePath)) {
+            const cur = path.posix.join(filePath, entry);
+            if (await this.isdir(cur)) {
+                const sub = await this.rm(cur, true);
+                failedPaths.push(...sub);
+            }
+            else {
+                if (!(await this.rmSingle(cur, true))) {
+                    failedPaths.push(cur);
+                }
+            }
+        }
+        try {
+            if (!(await this.rmSingle(filePath, force))) {
+                failedPaths.push(filePath);
+            }
+        }
+        catch (err) {
+            if (failedPaths.length) {
+                failedPaths.push(filePath);
+            }
+            else {
+                throw err;
+            }
+        }
+        return failedPaths;
+    }
+    async rename(src, dst) {
+        log.debug(`Renaming '${src}' to '${dst}'`);
+        try {
+            await this._doOperation(AfcOpcode.RENAME_PATH, buildRenamePayload(src, dst));
+            log.debug(`Successfully renamed '${src}' to '${dst}'`);
+        }
+        catch (error) {
+            if (!this.silent) {
+                log.error(`Failed to rename '${src}' to '${dst}':`, error);
+            }
+            throw error;
+        }
+    }
+    async push(localSrc, remoteDst) {
+        log.debug(`Pushing file from '${localSrc}' to '${remoteDst}'`);
+        const readStream = fs.createReadStream(localSrc);
+        await this.writeFromStream(remoteDst, readStream);
+        log.debug(`Successfully pushed file to '${remoteDst}'`);
+    }
+    async walk(root) {
+        const out = [];
+        const entries = await this.listdir(root);
+        const dirs = [];
+        const files = [];
+        for (const e of entries) {
+            const p = path.posix.join(root, e);
+            if (await this.isdir(p)) {
+                dirs.push(e);
+            }
+            else {
+                files.push(e);
+            }
+        }
+        out.push({ dir: root, dirs, files });
+        for (const d of dirs) {
+            out.push(...(await this.walk(path.posix.join(root, d))));
+        }
+        return out;
+    }
+    /**
+     * Close the underlying socket
+     */
+    close() {
+        log.debug('Closing AFC service connection');
+        try {
+            this.socket?.end();
+        }
+        catch (error) {
+            log.debug('Error while closing socket (ignored):', error);
+        }
+        this.socket = null;
+    }
+    /**
+     * Connect to RSD port and perform RSDCheckin.
+     * Keeps the underlying socket for raw AFC I/O.
+     */
+    async _connect() {
+        if (this.socket && !this.socket.destroyed) {
+            return this.socket;
+        }
+        const [host, rsdPort] = this.address;
+        this.socket = await new Promise((resolve, reject) => {
+            const s = net.createConnection({ host, port: rsdPort }, () => {
+                s.setTimeout(0);
+                s.setKeepAlive(true);
+                resolve(s);
+            });
+            s.once('error', reject);
+            s.setTimeout(30000, () => {
+                s.destroy();
+                reject(new Error('AFC connect timed out'));
+            });
+        });
+        await rsdHandshakeForRawService(this.socket);
+        log.debug('RSD handshake complete; switching to raw AFC');
+        return this.socket;
+    }
+    async _resolvePath(filePath) {
+        const info = await this.stat(filePath);
+        if (info.st_ifmt === AfcFileMode.S_IFLNK && info.LinkTarget) {
+            const target = info.LinkTarget;
+            if (target.startsWith('/')) {
+                return target;
+            }
+            return path.posix.join(path.posix.dirname(filePath), target);
+        }
+        return filePath;
+    }
+    async _dispatch(op, payload = Buffer.alloc(0), thisLenOverride) {
+        const sock = await this._connect();
+        await sendAfcPacket(sock, op, this.packetNum++, payload, thisLenOverride);
+    }
+    async _receive() {
+        const sock = await this._connect();
+        const res = await readAfcResponse(sock);
+        return { status: res.status, data: res.data };
+    }
+    /**
+     * Send a single-operation request and parse result.
+     * Throws if status != SUCCESS.
+     * Returns response DATA buffer when applicable.
+     */
+    async _doOperation(op, payload = Buffer.alloc(0), thisLenOverride) {
+        await this._dispatch(op, payload, thisLenOverride);
+        const { status, data } = await this._receive();
+        if (status !== AfcError.SUCCESS) {
+            const errorName = AfcError[status] || 'UNKNOWN';
+            const opName = AfcOpcode[op] || op.toString();
+            if (status === AfcError.OBJECT_NOT_FOUND) {
+                throw new Error(`AFC error: OBJECT_NOT_FOUND for operation ${opName}`);
+            }
+            if (!this.silent) {
+                log.error(`AFC operation ${opName} failed with status ${errorName} (${status})`);
+            }
+            throw new Error(`AFC operation ${opName} failed with ${errorName} (${status})`);
+        }
+        return data;
+    }
+}
+export default AfcService;

package/build/src/services/ios/afc/stream-utils.d.ts

@@ -0,0 +1,14 @@
+import { Readable, Writable } from 'node:stream';
+import { AfcError, AfcOpcode } from './enums.js';
+type AfcDispatcher = (op: AfcOpcode, payload: Buffer) => Promise<void>;
+type AfcWriteDispatcher = (op: AfcOpcode, payload: Buffer, thisLenOverride?: number) => Promise<void>;
+export declare function createAfcReadStream(handle: bigint, size: bigint, dispatch: AfcDispatcher, receive: () => Promise<{
+    status: AfcError;
+    data: Buffer;
+}>): Readable;
+export declare function createAfcWriteStream(handle: bigint, dispatch: AfcWriteDispatcher, receive: () => Promise<{
+    status: AfcError;
+    data: Buffer;
+}>, chunkSize?: number): Writable;
+export {};
+//# sourceMappingURL=stream-utils.d.ts.map

package/build/src/services/ios/afc/stream-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-utils.d.ts","sourceRoot":"","sources":["../../../../../src/services/ios/afc/stream-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAIjD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEjD,KAAK,aAAa,GAAG,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAEvE,KAAK,kBAAkB,GAAG,CACxB,EAAE,EAAE,SAAS,EACb,OAAO,EAAE,MAAM,EACf,eAAe,CAAC,EAAE,MAAM,KACrB,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnB,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,aAAa,EACvB,OAAO,EAAE,MAAM,OAAO,CAAC;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GACzD,QAAQ,CAmCV;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,EAAE,MAAM,OAAO,CAAC;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EAC1D,SAAS,CAAC,EAAE,MAAM,GACjB,QAAQ,CAwCV"}

package/build/src/services/ios/afc/stream-utils.js

@@ -0,0 +1,60 @@
+import { Readable, Writable } from 'node:stream';
+import { buildReadPayload, nextReadChunkSize, writeUInt64LE } from './codec.js';
+import { AFC_WRITE_THIS_LENGTH } from './constants.js';
+import { AfcError, AfcOpcode } from './enums.js';
+export function createAfcReadStream(handle, size, dispatch, receive) {
+    let left = size;
+    let totalRead = 0n;
+    return new Readable({
+        async read() {
+            try {
+                if (left <= 0n) {
+                    this.push(null);
+                    return;
+                }
+                const toRead = nextReadChunkSize(left);
+                await dispatch(AfcOpcode.READ, buildReadPayload(handle, toRead));
+                const { status, data } = await receive();
+                if (status !== AfcError.SUCCESS) {
+                    const errorName = AfcError[status] || 'UNKNOWN';
+                    this.destroy(new Error(`fread error: ${errorName} (${status})`));
+                    return;
+                }
+                totalRead += BigInt(data.length);
+                left -= BigInt(data.length);
+                this.push(data);
+                if (BigInt(data.length) < toRead) {
+                    this.push(null);
+                }
+            }
+            catch (error) {
+                this.destroy(error);
+            }
+        },
+    });
+}
+export function createAfcWriteStream(handle, dispatch, receive, chunkSize) {
+    return new Writable({
+        async write(chunk, encoding, callback) {
+            try {
+                let offset = 0;
+                while (offset < chunk.length) {
+                    const end = Math.min(offset + (chunkSize ?? chunk.length), chunk.length);
+                    const subchunk = chunk.subarray(offset, end);
+                    await dispatch(AfcOpcode.WRITE, Buffer.concat([writeUInt64LE(handle), subchunk]), AFC_WRITE_THIS_LENGTH);
+                    const { status } = await receive();
+                    if (status !== AfcError.SUCCESS) {
+                        const errorName = AfcError[status] || 'UNKNOWN';
+                        callback(new Error(`fwrite chunk failed with ${errorName} (${status}) at offset ${offset}`));
+                        return;
+                    }
+                    offset = end;
+                }
+                callback();
+            }
+            catch (error) {
+                callback(error);
+            }
+        },
+    });
+}

package/build/src/services/ios/power-assertion/index.d.ts

@@ -0,0 +1,40 @@
+import type { PowerAssertionService as PowerAssertionServiceInterface } from '../../../lib/types.js';
+import { BaseService } from '../base-service.js';
+/**
+ * Power assertion types that can be used to prevent system sleep
+ */
+export declare enum PowerAssertionType {
+    WIRELESS_SYNC = "AMDPowerAssertionTypeWirelessSync",
+    PREVENT_USER_IDLE_SYSTEM_SLEEP = "PreventUserIdleSystemSleep",
+    PREVENT_SYSTEM_SLEEP = "PreventSystemSleep"
+}
+/**
+ * Options for power assertion creation
+ */
+export interface PowerAssertionOptions {
+    type: PowerAssertionType;
+    name: string;
+    timeout: number;
+    details?: string;
+}
+/**
+ * PowerAssertionService provides an API to create power assertions.
+ */
+declare class PowerAssertionService extends BaseService implements PowerAssertionServiceInterface {
+    static readonly RSD_SERVICE_NAME = "com.apple.mobile.assertion_agent.shim.remote";
+    private _conn;
+    /**
+     * Create a power assertion to prevent system sleep
+     * @param options Options for creating the power assertion
+     * @returns Promise that resolves when the assertion is created
+     */
+    createPowerAssertion(options: PowerAssertionOptions): Promise<void>;
+    /**
+     * Close the connection to the power assertion service
+     */
+    close(): Promise<void>;
+    private connectToPowerAssertionService;
+    private buildCreateAssertionRequest;
+}
+export { PowerAssertionService };
+//# sourceMappingURL=index.d.ts.map

package/build/src/services/ios/power-assertion/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/services/ios/power-assertion/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,qBAAqB,IAAI,8BAA8B,EACxD,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAIjD;;GAEG;AACH,oBAAY,kBAAkB;IAC5B,aAAa,sCAAsC;IACnD,8BAA8B,+BAA+B;IAC7D,oBAAoB,uBAAuB;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,kBAAkB,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,cAAM,qBACJ,SAAQ,WACR,YAAW,8BAA8B;IAEzC,MAAM,CAAC,QAAQ,CAAC,gBAAgB,kDACiB;IAEjD,OAAO,CAAC,KAAK,CAAkC;IAE/C;;;;OAIG;IACG,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IAYzE;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAQd,8BAA8B;IAW5C,OAAO,CAAC,2BAA2B;CAgBpC;AAED,OAAO,EAAE,qBAAqB,EAAE,CAAC"}