appium-ios-remotexpc 0.0.3 → 0.0.5

package/build/src/lib/remote-xpc/handshake-frames.d.ts

@@ -0,0 +1,74 @@
+declare class Struct {
+    private readonly types;
+    constructor(fmt: string);
+    byteLength(): number;
+    pack(...values: number[]): Buffer;
+}
+declare const STRUCT_HL: Struct;
+type StreamAssociation = 'has-stream' | 'no-stream' | 'either';
+declare class HyperframeError extends Error {
+}
+declare class InvalidDataError extends HyperframeError {
+}
+declare class Flag {
+    name: string;
+    bit: number;
+    constructor(name: string, bit: number);
+}
+declare class Flags {
+    definedFlags: Flag[];
+    flags: Set<string>;
+    constructor(definedFlags: Flag[]);
+    add(flag: string): void;
+    has(flag: string): boolean;
+    toString(): string;
+}
+export declare class Frame {
+    protected definedFlags: Flag[];
+    type: number | null;
+    streamAssociation: StreamAssociation | null;
+    streamId: number;
+    flags: Flags;
+    bodyLen: number;
+    constructor(streamId: number, flags?: string[]);
+    toString(): string;
+    serialize(): Buffer;
+    serializeBody(): Buffer;
+    protected bodyRepr(): string;
+}
+export declare class SettingsFrame extends Frame {
+    static MAX_CONCURRENT_STREAMS: number;
+    static INITIAL_WINDOW_SIZE: number;
+    settings: Record<number, number>;
+    constructor(streamId?: number, settings?: Record<number, number> | null, flags?: string[]);
+    bodyRepr(): string;
+    serializeBody(): Buffer;
+}
+export declare class DataFrame extends Frame {
+    data: Buffer;
+    padLength: number;
+    constructor(streamId: number, data?: Buffer | string, flags?: string[]);
+    serializePaddingData(): Buffer;
+    serializeBody(): Buffer;
+}
+export declare class HeadersFrame extends Frame {
+    data: Buffer;
+    padLength: number;
+    dependsOn: number;
+    streamWeight: number;
+    exclusive: boolean;
+    static ALL_FLAGS: Record<string, number>;
+    constructor(streamId: number, data?: Buffer | string, flags?: string[]);
+    serializePaddingData(): Buffer;
+    serializePriorityData(): Buffer;
+    bodyRepr(): string;
+    serializeBody(): Buffer;
+}
+export declare class WindowUpdateFrame extends Frame {
+    windowIncrement: number;
+    constructor(streamId: number, windowIncrement?: number, flags?: string[]);
+    bodyRepr(): string;
+    serializeBody(): Buffer;
+}
+export { InvalidDataError, STRUCT_HL };
+//# sourceMappingURL=handshake-frames.d.ts.map

package/build/src/lib/remote-xpc/handshake-frames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handshake-frames.d.ts","sourceRoot":"","sources":["../../../../src/lib/remote-xpc/handshake-frames.ts"],"names":[],"mappings":"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"}

package/build/src/lib/remote-xpc/handshake-frames.js

@@ -0,0 +1,285 @@
+class Struct {
+    types;
+    constructor(fmt) {
+        if (!fmt.startsWith('>')) {
+            throw new Error('Only big-endian formats supported');
+        }
+        this.types = [];
+        for (const ch of fmt.slice(1)) {
+            if ('0123456789'.includes(ch)) {
+                continue;
+            }
+            this.types.push(ch);
+        }
+    }
+    byteLength() {
+        let total = 0;
+        for (const t of this.types) {
+            switch (t) {
+                case 'H':
+                    total += 2;
+                    break;
+                case 'B':
+                    total += 1;
+                    break;
+                case 'L':
+                    total += 4;
+                    break;
+                default:
+                    throw new TypeError('Unsupported type: ' + t);
+            }
+        }
+        return total;
+    }
+    pack(...values) {
+        if (values.length !== this.types.length) {
+            throw new TypeError('Incorrect number of values to pack');
+        }
+        const buf = Buffer.alloc(this.byteLength());
+        let offset = 0;
+        for (const [i, t] of this.types.entries()) {
+            const v = values[i];
+            switch (t) {
+                case 'H':
+                    buf.writeUInt16BE(v, offset);
+                    offset += 2;
+                    break;
+                case 'B':
+                    buf.writeUInt8(v, offset);
+                    offset += 1;
+                    break;
+                case 'L':
+                    buf.writeUInt32BE(v, offset);
+                    offset += 4;
+                    break;
+                default:
+                    throw new TypeError('Unsupported type: ' + t);
+            }
+        }
+        return buf;
+    }
+}
+// Struct constants
+const STRUCT_HBBBL = new Struct('>HBBBL');
+const STRUCT_HL = new Struct('>HL');
+const STRUCT_LB = new Struct('>LB');
+const STRUCT_L = new Struct('>L');
+const STRUCT_B = new Struct('>B');
+const STREAM_ASSOC_HAS_STREAM = 'has-stream';
+const STREAM_ASSOC_NO_STREAM = 'no-stream';
+const STREAM_ASSOC_EITHER = 'either';
+// Error classes
+class HyperframeError extends Error {
+}
+class InvalidDataError extends HyperframeError {
+}
+// Flag handling
+class Flag {
+    name;
+    bit;
+    constructor(name, bit) {
+        this.name = name;
+        this.bit = bit;
+    }
+}
+class Flags {
+    definedFlags;
+    flags;
+    constructor(definedFlags) {
+        this.definedFlags = definedFlags;
+        this.flags = new Set();
+    }
+    add(flag) {
+        this.flags.add(flag);
+    }
+    has(flag) {
+        return this.flags.has(flag);
+    }
+    toString() {
+        return Array.from(this.flags).join(', ');
+    }
+}
+// Utility function
+function rawDataRepr(data) {
+    if (!data || data.length === 0) {
+        return 'None';
+    }
+    let r = data.toString('hex');
+    if (r.length > 20) {
+        r = r.slice(0, 20) + '\u2026';
+    }
+    return '<hex:' + r + '>';
+}
+// Base frame class
+export class Frame {
+    definedFlags = [];
+    type = null;
+    streamAssociation = null;
+    streamId;
+    flags;
+    bodyLen;
+    constructor(streamId, flags = []) {
+        this.streamId = streamId;
+        this.flags = new Flags(this.definedFlags);
+        this.bodyLen = 0;
+        for (const flag of flags) {
+            this.flags.add(flag);
+        }
+        if (!this.streamId && this.streamAssociation === STREAM_ASSOC_HAS_STREAM) {
+            throw new InvalidDataError(`Stream ID must be non-zero for ${this.constructor.name}`);
+        }
+        if (this.streamId && this.streamAssociation === STREAM_ASSOC_NO_STREAM) {
+            throw new InvalidDataError(`Stream ID must be zero for ${this.constructor.name} with streamId=${this.streamId}`);
+        }
+    }
+    toString() {
+        return `${this.constructor.name}(streamId=${this.streamId}, flags=${this.flags.toString()}): ${this.bodyRepr()}`;
+    }
+    serialize() {
+        const body = this.serializeBody();
+        this.bodyLen = body.length;
+        let flagsVal = 0;
+        for (const f of this.definedFlags) {
+            if (this.flags.has(f.name)) {
+                flagsVal |= f.bit;
+            }
+        }
+        const header = STRUCT_HBBBL.pack((this.bodyLen >> 8) & 0xffff, this.bodyLen & 0xff, this.type, flagsVal, this.streamId & 0x7fffffff);
+        return Buffer.concat([header, body]);
+    }
+    serializeBody() {
+        throw new Error('Not implemented');
+    }
+    bodyRepr() {
+        return rawDataRepr(this.serializeBody());
+    }
+}
+// Specific frame implementations
+export class SettingsFrame extends Frame {
+    static MAX_CONCURRENT_STREAMS = 0x03;
+    static INITIAL_WINDOW_SIZE = 0x04;
+    settings;
+    constructor(streamId = 0, settings = null, flags = []) {
+        super(streamId, flags);
+        this.definedFlags = [new Flag('ACK', 0x01)];
+        this.type = 0x04;
+        this.streamAssociation = STREAM_ASSOC_NO_STREAM;
+        if (settings && flags.includes('ACK')) {
+            throw new InvalidDataError('Settings must be empty if ACK flag is set.');
+        }
+        this.settings = settings || {};
+    }
+    bodyRepr() {
+        return `settings=${JSON.stringify(this.settings)}`;
+    }
+    serializeBody() {
+        if (this.flags.has('ACK')) {
+            return Buffer.alloc(0);
+        }
+        const buffers = [];
+        for (const setting of Object.keys(this.settings)) {
+            const buf = STRUCT_HL.pack(Number(setting) & 0xff, this.settings[Number(setting)]);
+            buffers.push(buf);
+        }
+        return Buffer.concat(buffers);
+    }
+}
+export class DataFrame extends Frame {
+    data;
+    padLength;
+    constructor(streamId, data = Buffer.from(''), flags = []) {
+        super(streamId, flags);
+        this.definedFlags = [
+            new Flag('END_STREAM', 0x01),
+            new Flag('PADDED', 0x08),
+        ];
+        this.type = 0x0;
+        this.streamAssociation = STREAM_ASSOC_HAS_STREAM;
+        this.padLength = 0;
+        this.data = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    }
+    serializePaddingData() {
+        if (this.flags.has('PADDED')) {
+            return STRUCT_B.pack(this.padLength);
+        }
+        return Buffer.alloc(0);
+    }
+    serializeBody() {
+        const paddingData = this.serializePaddingData();
+        const padding = Buffer.alloc(this.padLength, 0);
+        // Ensure data is a Buffer
+        if (!Buffer.isBuffer(this.data)) {
+            this.data = Buffer.from(this.data);
+        }
+        const payload = Buffer.concat([paddingData, this.data, padding]);
+        this.bodyLen = payload.length;
+        return payload;
+    }
+}
+export class HeadersFrame extends Frame {
+    data;
+    padLength;
+    dependsOn;
+    streamWeight;
+    exclusive;
+    static ALL_FLAGS = {
+        END_STREAM: 0x01,
+        END_HEADERS: 0x04,
+        PADDED: 0x08,
+        PRIORITY: 0x20,
+    };
+    constructor(streamId, data = Buffer.from(''), flags = []) {
+        super(streamId, flags);
+        // Map given flags to Flag objects using ALL_FLAGS
+        this.definedFlags = flags.map((flag) => new Flag(flag, HeadersFrame.ALL_FLAGS[flag]));
+        this.type = 0x01;
+        this.streamAssociation = STREAM_ASSOC_HAS_STREAM;
+        this.padLength = 0;
+        this.dependsOn = 0;
+        this.streamWeight = 0;
+        this.exclusive = false;
+        this.data = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    }
+    serializePaddingData() {
+        if (this.flags.has('PADDED')) {
+            return STRUCT_B.pack(this.padLength);
+        }
+        return Buffer.alloc(0);
+    }
+    serializePriorityData() {
+        return STRUCT_LB.pack(this.dependsOn + (this.exclusive ? 0x80000000 : 0), this.streamWeight);
+    }
+    bodyRepr() {
+        return `exclusive=${this.exclusive}, dependsOn=${this.dependsOn}, streamWeight=${this.streamWeight}, data=${rawDataRepr(this.data)}`;
+    }
+    serializeBody() {
+        const paddingData = this.serializePaddingData();
+        const padding = Buffer.alloc(this.padLength, 0);
+        let priorityData;
+        if (this.flags.has('PRIORITY')) {
+            priorityData = this.serializePriorityData();
+        }
+        else {
+            priorityData = Buffer.alloc(0);
+        }
+        return Buffer.concat([paddingData, priorityData, this.data, padding]);
+    }
+}
+export class WindowUpdateFrame extends Frame {
+    windowIncrement;
+    constructor(streamId, windowIncrement = 0, flags = []) {
+        super(streamId, flags);
+        this.definedFlags = [];
+        this.type = 0x08;
+        this.streamAssociation = STREAM_ASSOC_EITHER;
+        this.windowIncrement = windowIncrement;
+    }
+    bodyRepr() {
+        return `windowIncrement=${this.windowIncrement}`;
+    }
+    serializeBody() {
+        return STRUCT_L.pack(this.windowIncrement & 0x7fffffff);
+    }
+}
+// Exported constants and types
+export { InvalidDataError, STRUCT_HL };

package/build/src/lib/remote-xpc/handshake.d.ts

@@ -0,0 +1,14 @@
+import { Socket } from 'net';
+import { type XPCDictionary } from '../types.js';
+export type ChannelId = number;
+export type MessageId = number;
+declare class Handshake {
+    private _socket;
+    private readonly _nextMessageId;
+    constructor(socket: Socket);
+    sendFrame(frame: Buffer): Promise<void>;
+    sendRequest(data: XPCDictionary): Promise<void>;
+    perform(): Promise<void>;
+}
+export default Handshake;
+//# sourceMappingURL=handshake.d.ts.map

package/build/src/lib/remote-xpc/handshake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handshake.d.ts","sourceRoot":"","sources":["../../../../src/lib/remote-xpc/handshake.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAUjD,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AAC/B,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AAE/B,cAAM,SAAS;IACb,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA+B;gBAElD,MAAM,EAAE,MAAM;IAQpB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAYvC,WAAW,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAiB/C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CA6F/B;AAED,eAAe,SAAS,CAAC"}

package/build/src/lib/remote-xpc/handshake.js

@@ -0,0 +1,95 @@
+import { Socket } from 'net';
+import {} from '../types.js';
+import { Http2Constants, XpcConstants } from './constants.js';
+import { DataFrame, HeadersFrame, SettingsFrame, WindowUpdateFrame, } from './handshake-frames.js';
+import { encodeMessage } from './xpc-protocol.js';
+class Handshake {
+    _socket;
+    _nextMessageId;
+    constructor(socket) {
+        this._socket = socket;
+        this._nextMessageId = {
+            [Http2Constants.ROOT_CHANNEL]: 0,
+            [Http2Constants.REPLY_CHANNEL]: 0,
+        };
+    }
+    async sendFrame(frame) {
+        return new Promise((resolve, reject) => {
+            if (!this._socket.writable) {
+                return reject(new Error('Socket is not writable'));
+            }
+            this._socket.write(frame, (error) => error ? reject(error) : resolve());
+        });
+    }
+    async sendRequest(data) {
+        const flags = XpcConstants.XPC_FLAGS_ALWAYS_SET;
+        const requestMessage = {
+            flags,
+            id: BigInt(this._nextMessageId[Http2Constants.ROOT_CHANNEL]),
+            body: data,
+        };
+        const encodedMessage = encodeMessage(requestMessage);
+        const dataFrame = new DataFrame(Http2Constants.ROOT_CHANNEL, encodedMessage, []);
+        await this.sendFrame(dataFrame.serialize());
+    }
+    async perform() {
+        try {
+            // Step 1: Send HTTP/2 magic sequence with proper error handling
+            await new Promise((resolve, reject) => {
+                if (!this._socket.writable) {
+                    return reject(new Error('Socket is not writable for HTTP/2 magic sequence'));
+                }
+                this._socket.write(Http2Constants.HTTP2_MAGIC, (err) => err ? reject(err) : resolve());
+            });
+            // Step 2: Send SETTINGS frame on stream 0.
+            const settings = {
+                [SettingsFrame.MAX_CONCURRENT_STREAMS]: 100,
+                [SettingsFrame.INITIAL_WINDOW_SIZE]: 1048576,
+            };
+            const settingsFrame = new SettingsFrame(0, settings, []);
+            await this.sendFrame(settingsFrame.serialize());
+            // Step 3: Send WINDOW_UPDATE frame on stream 0.
+            const windowUpdateFrame = new WindowUpdateFrame(0, 983041);
+            await this.sendFrame(windowUpdateFrame.serialize());
+            // Step 4: Send a HEADERS frame on stream 1.
+            const headersFrameRoot = new HeadersFrame(Http2Constants.ROOT_CHANNEL, Buffer.from(''), ['END_HEADERS']);
+            await this.sendFrame(headersFrameRoot.serialize());
+            // Step 5: Send first DataFrame on stream 1 (empty payload).
+            await this.sendRequest({});
+            // Step 6: Send second DataFrame on stream 1 with specific flags.
+            const dataMessage = {
+                flags: 0x0201,
+                id: 0,
+                body: null,
+            };
+            const encodedDataMessage = encodeMessage(dataMessage);
+            const dataFrame = new DataFrame(Http2Constants.ROOT_CHANNEL, encodedDataMessage, []);
+            await this.sendFrame(dataFrame.serialize());
+            this._nextMessageId[Http2Constants.ROOT_CHANNEL]++;
+            // Step 7: Send a HEADERS frame on stream 3.
+            const headersFrameReply = new HeadersFrame(Http2Constants.REPLY_CHANNEL, Buffer.from(''), ['END_HEADERS']);
+            await this.sendFrame(headersFrameReply.serialize());
+            // Step 8: Open REPLY_CHANNEL with INIT_HANDSHAKE flags.
+            const replyMessage = {
+                flags: XpcConstants.XPC_FLAGS_ALWAYS_SET |
+                    XpcConstants.XPC_FLAGS_INIT_HANDSHAKE,
+                id: 0,
+                body: null,
+            };
+            const encodedReplyMessage = encodeMessage(replyMessage);
+            const replyDataFrame = new DataFrame(Http2Constants.REPLY_CHANNEL, encodedReplyMessage, []);
+            await this.sendFrame(replyDataFrame.serialize());
+            this._nextMessageId[Http2Constants.REPLY_CHANNEL]++;
+            // Step 9: Send SETTINGS ACK frame.
+            const ackFrame = new SettingsFrame(0, null, ['ACK']);
+            await this.sendFrame(ackFrame.serialize());
+        }
+        catch (error) {
+            // Provide detailed error information
+            throw new Error(error instanceof Error
+                ? `Handshake failed at step: ${error.message}`
+                : 'Unknown handshake error');
+        }
+    }
+}
+export default Handshake;

package/build/src/lib/remote-xpc/remote-xpc-connection.d.ts

@@ -0,0 +1,55 @@
+interface Service {
+    serviceName: string;
+    port: string;
+}
+interface ServicesResponse {
+    services: Service[];
+}
+declare class RemoteXpcConnection {
+    private readonly _address;
+    private _socket;
+    private _handshake;
+    private _isConnected;
+    private _services;
+    constructor(address: [string, number]);
+    /**
+     * Connect to the remote device and perform handshake
+     * @returns Promise that resolves with the list of available services
+     */
+    connect(): Promise<ServicesResponse>;
+    /**
+     * Close the connection
+     */
+    close(): Promise<void>;
+    /**
+     * Get the list of available services
+     * @returns Array of available services
+     */
+    getServices(): Service[];
+    /**
+     * List all available services
+     * @returns Array of all available services
+     */
+    listAllServices(): Service[];
+    /**
+     * Find a service by name
+     * @param serviceName The name of the service to find
+     * @returns The service or throws an error if not found
+     */
+    findService(serviceName: string): Service;
+    /**
+     * Remove all listeners from the socket to prevent memory leaks
+     */
+    private cleanupSocket;
+    /**
+     * Clean up all resources
+     */
+    private cleanupResources;
+    /**
+     * Force cleanup by destroying the socket and cleaning up resources
+     */
+    private forceCleanup;
+}
+export default RemoteXpcConnection;
+export { type Service, type ServicesResponse };
+//# sourceMappingURL=remote-xpc-connection.d.ts.map

package/build/src/lib/remote-xpc/remote-xpc-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-xpc-connection.d.ts","sourceRoot":"","sources":["../../../../src/lib/remote-xpc/remote-xpc-connection.ts"],"names":[],"mappings":"AAgBA,UAAU,OAAO;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,gBAAgB;IACxB,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB;AAKD,cAAM,mBAAmB;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAC5C,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,UAAU,CAAwB;IAC1C,OAAO,CAAC,YAAY,CAAU;IAC9B,OAAO,CAAC,SAAS,CAAwB;gBAE7B,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC;IAQrC;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,gBAAgB,CAAC;IA0J1C;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA0E5B;;;OAGG;IACH,WAAW,IAAI,OAAO,EAAE;IAOxB;;;OAGG;IACH,eAAe,IAAI,OAAO,EAAE;IAI5B;;;;OAIG;IACH,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IAYzC;;OAEG;IACH,OAAO,CAAC,aAAa;IAgCrB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAOxB;;OAEG;IACH,OAAO,CAAC,YAAY;CAerB;AAkFD,eAAe,mBAAmB,CAAC;AACnC,OAAO,EAAE,KAAK,OAAO,EAAE,KAAK,gBAAgB,EAAE,CAAC"}