appium-ios-remotexpc 0.9.0 → 0.10.0

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.d.ts

@@ -1,5 +1,6 @@
 import { RemoteXpcConnection } from './lib/remote-xpc/remote-xpc-connection.js';
 import type { DiagnosticsServiceWithConnection, MobileConfigServiceWithConnection, MobileImageMounterServiceWithConnection, NotificationProxyServiceWithConnection, PowerAssertionServiceWithConnection, SpringboardServiceWithConnection, SyslogService as SyslogServiceType, WebInspectorServiceWithConnection } from './lib/types.js';
+import AfcService from './services/ios/afc/index.js';
 export declare function startDiagnosticsService(udid: string): Promise<DiagnosticsServiceWithConnection>;
 export declare function startNotificationProxyService(udid: string): Promise<NotificationProxyServiceWithConnection>;
 export declare function startMobileConfigService(udid: string): Promise<MobileConfigServiceWithConnection>;
@@ -7,6 +8,11 @@ export declare function startMobileImageMounterService(udid: string): Promise<Mo
 export declare function startSpringboardService(udid: string): Promise<SpringboardServiceWithConnection>;
 export declare function startPowerAssertionService(udid: string): Promise<PowerAssertionServiceWithConnection>;
 export declare function startSyslogService(udid: string): Promise<SyslogServiceType>;
+/**
+ * Start AFC service over RemoteXPC shim.
+ * Resolves the AFC service port via RemoteXPC and returns a ready-to-use AfcService instance.
+ */
+export declare function startAfcService(udid: string): Promise<AfcService>;
 export declare function startWebInspectorService(udid: string): Promise<WebInspectorServiceWithConnection>;
 export declare function createRemoteXPCConnection(udid: string): Promise<{
     remoteXPC: RemoteXpcConnection;

package/build/src/services.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/services.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAGhF,OAAO,KAAK,EACV,gCAAgC,EAChC,iCAAiC,EACjC,uCAAuC,EACvC,sCAAsC,EACtC,mCAAmC,EACnC,gCAAgC,EAChC,aAAa,IAAI,iBAAiB,EAClC,iCAAiC,EAClC,MAAM,gBAAgB,CAAC;AAaxB,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,gCAAgC,CAAC,CAY3C;AAED,wBAAsB,6BAA6B,CACjD,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,sCAAsC,CAAC,CAYjD;AAED,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,iCAAiC,CAAC,CAY5C;AACD,wBAAsB,8BAA8B,CAClD,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,uCAAuC,CAAC,CAYlD;AAED,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,gCAAgC,CAAC,CAY3C;AAED,wBAAsB,0BAA0B,CAC9C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,mCAAmC,CAAC,CAY9C;AAED,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,iBAAiB,CAAC,CAG5B;AAED,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,iCAAiC,CAAC,CAY5C;AAED,wBAAsB,yBAAyB,CAAC,IAAI,EAAE,MAAM;;;;;;;;GAO3D"}
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/services.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAGhF,OAAO,KAAK,EACV,gCAAgC,EAChC,iCAAiC,EACjC,uCAAuC,EACvC,sCAAsC,EACtC,mCAAmC,EACnC,gCAAgC,EAChC,aAAa,IAAI,iBAAiB,EAClC,iCAAiC,EAClC,MAAM,gBAAgB,CAAC;AACxB,OAAO,UAAU,MAAM,6BAA6B,CAAC;AAarD,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,gCAAgC,CAAC,CAY3C;AAED,wBAAsB,6BAA6B,CACjD,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,sCAAsC,CAAC,CAYjD;AAED,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,iCAAiC,CAAC,CAY5C;AAED,wBAAsB,8BAA8B,CAClD,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,uCAAuC,CAAC,CAYlD;AAED,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,gCAAgC,CAAC,CAY3C;AAED,wBAAsB,0BAA0B,CAC9C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,mCAAmC,CAAC,CAY9C;AAED,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,iBAAiB,CAAC,CAG5B;AAED;;;GAGG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAOvE;AAED,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,iCAAiC,CAAC,CAY5C;AAED,wBAAsB,yBAAyB,CAAC,IAAI,EAAE,MAAM;;;;;;;;GAO3D"}

package/build/src/services.js

@@ -2,6 +2,7 @@ import { strongbox } from '@appium/strongbox';
 import { RemoteXpcConnection } from './lib/remote-xpc/remote-xpc-connection.js';
 import { TunnelManager } from './lib/tunnel/index.js';
 import { TunnelApiClient } from './lib/tunnel/tunnel-api-client.js';
+import AfcService from './services/ios/afc/index.js';
 import DiagnosticsService from './services/ios/diagnostic-service/index.js';
 import { MobileConfigService } from './services/ios/mobile-config/index.js';
 import MobileImageMounterService from './services/ios/mobile-image-mounter/index.js';
@@ -82,6 +83,18 @@ export async function startSyslogService(udid) {
     const { tunnelConnection } = await createRemoteXPCConnection(udid);
     return new SyslogService([tunnelConnection.host, tunnelConnection.port]);
 }
+/**
+ * Start AFC service over RemoteXPC shim.
+ * Resolves the AFC service port via RemoteXPC and returns a ready-to-use AfcService instance.
+ */
+export async function startAfcService(udid) {
+    const { remoteXPC, tunnelConnection } = await createRemoteXPCConnection(udid);
+    const afcDescriptor = remoteXPC.findService(AfcService.RSD_SERVICE_NAME);
+    return new AfcService([
+        tunnelConnection.host,
+        parseInt(afcDescriptor.port, 10),
+    ]);
+}
 export async function startWebInspectorService(udid) {
     const { remoteXPC, tunnelConnection } = await createRemoteXPCConnection(udid);
     const webInspectorService = remoteXPC.findService(WebInspectorService.RSD_SERVICE_NAME);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appium-ios-remotexpc",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "main": "build/src/index.js",
   "types": "build/src/index.d.ts",
   "type": "module",
@@ -33,6 +33,7 @@
     "test:mobile-config": "mocha test/integration/mobile-config-test.ts --exit --timeout 1m",
     "test:springboard": "mocha test/integration/springboard-service-test.ts --exit --timeout 1m",
     "test:webinspector": "mocha test/integration/webinspector-test.ts --exit --timeout 1m",
+    "test:afc": "mocha test/integration/afc-test.ts --exit --timeout 1m",
     "test:power-assertion": "mocha test/integration/power-assertion-test.ts --exit --timeout 1m",
     "test:unit": "mocha 'test/unit/**/*.ts' --exit --timeout 2m",
     "test:tunnel-creation": "sudo tsx scripts/test-tunnel-creation.ts",

package/src/services/index.ts

@@ -2,6 +2,7 @@ import {
   TunnelRegistryServer,
   startTunnelRegistryServer,
 } from '../lib/tunnel/tunnel-registry-server.js';
+import * as afc from './ios/afc/index.js';
 import * as diagnostics from './ios/diagnostic-service/index.js';
 import * as mobileImageMounter from './ios/mobile-image-mounter/index.js';
 import * as powerAssertion from './ios/power-assertion/index.js';
@@ -15,6 +16,7 @@ export {
   powerAssertion,
   syslog,
   tunnel,
+  afc,
   webinspector,
   TunnelRegistryServer,
   startTunnelRegistryServer,