appium-ios-device 2.0.0 → 2.3.0

package/README.md

@@ -3,10 +3,8 @@ appium-ios-device
 
 [![NPM version](http://img.shields.io/npm/v/appium-ios-device.svg)](https://npmjs.org/package/appium-ios-device)
 [![Downloads](http://img.shields.io/npm/dm/appium-ios-device.svg)](https://npmjs.org/package/appium-ios-device)
-[![Dependency Status](https://david-dm.org/appium/appium-ios-device/master.svg)](https://david-dm.org/appium/appium-ios-device/master)
-[![devDependency Status](https://david-dm.org/appium/appium-ios-device/master/dev-status.svg)](https://david-dm.org/appium/appium-ios-device/master#info=devDependencies)
 
-[![Build Status](https://api.travis-ci.org/appium/appium-ios-device.png?branch=master)](https://travis-ci.org/appium/appium-ios-device)
+[![Release](https://github.com/appium/appium-ios-device/actions/workflows/publish.js.yml/badge.svg)](https://github.com/appium/appium-ios-device/actions/workflows/publish.js.yml)
 
 Appium API for dealing with iOS devices. This is mainly a rewrite of libimobiledevice in nodejs. The APIs allow Appium to talk directly to the phone over usbmuxd
 
@@ -22,6 +20,7 @@ More information can be found at the links below:
 - `utilities.getOSVersion`
 - `utilities.getDeviceTime`
 - `utilities.getDeviceName`
+- `utilities.getDeviceInfo`
 - `utilities.startLockdownSession`
 - `utilities.connectPort`
 - `utilities.connectPortSSL`
@@ -32,6 +31,8 @@ More information can be found at the links below:
 - `services.startAfcService`
 - `services.startNotificationProxyService`
 - `services.startHouseArrestService`
+- `services.startInstrumentService`
+- `services.startMCInstallService`
 
 ### Usage
 

package/build/lib/instrument/headers.js

@@ -0,0 +1,356 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FLAG_TYPES = exports.DTX_MESSAGE_PAYLOAD_HEADER_LENGTH = exports.DTX_MESSAGE_HEADER_MAGIC_LEN = exports.DTX_MESSAGE_HEADER_MAGIC = exports.DTX_MESSAGE_HEADER_LENGTH = exports.DTXMessagePayloadHeader = exports.DTXMessageHeader = exports.DTXMessageAuxBuffer = exports.DTXMessageAux = exports.DTXMessage = void 0;
+
+require("source-map-support/register");
+
+var _nskeyed = require("./transformer/nskeyed");
+
+var _bplistParser = _interopRequireDefault(require("bplist-parser"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+const DTX_MESSAGE_PAYLOAD_HEADER_LENGTH = 16;
+exports.DTX_MESSAGE_PAYLOAD_HEADER_LENGTH = DTX_MESSAGE_PAYLOAD_HEADER_LENGTH;
+const DTX_MESSAGE_HEADER_LENGTH = 32;
+exports.DTX_MESSAGE_HEADER_LENGTH = DTX_MESSAGE_HEADER_LENGTH;
+const DTX_MESSAGE_HEADER_MAGIC = 0x1F3D5B79;
+exports.DTX_MESSAGE_HEADER_MAGIC = DTX_MESSAGE_HEADER_MAGIC;
+const DTX_MESSAGE_HEADER_MAGIC_LEN = 4;
+exports.DTX_MESSAGE_HEADER_MAGIC_LEN = DTX_MESSAGE_HEADER_MAGIC_LEN;
+const DTX_MESSAGE_AUX_HEADER = 0x01F0;
+const DTX_AUXILIARY_MAGIC = 0xa;
+const FLAG_TYPES = Object.freeze({
+  recv: 1,
+  send: 2,
+  reply: 3
+});
+exports.FLAG_TYPES = FLAG_TYPES;
+const AUX_TYPES = Object.freeze({
+  NSKeyed: 2,
+  UInt32LE: 3,
+  BigUInt64LE: 4,
+  BigInt64LE: 6
+});
+
+class DTXMessageHeader {
+  static build(data) {
+    const messageHeader = Buffer.alloc(DTX_MESSAGE_HEADER_LENGTH);
+    messageHeader.writeUInt32LE(DTX_MESSAGE_HEADER_MAGIC, 0);
+    messageHeader.writeUInt32LE(DTX_MESSAGE_HEADER_LENGTH, 4);
+    messageHeader.writeUInt16LE(0, 8);
+    messageHeader.writeUInt16LE(1, 10);
+    messageHeader.writeUInt32LE(data.payloadLength, 12);
+    messageHeader.writeUInt32LE(data.identifier, 16);
+    messageHeader.writeUInt32LE(data.conversationIndex, 20);
+    messageHeader.writeUInt32LE(data.channelCode, 24);
+    messageHeader.writeUInt32LE(data.expectsReply, 28);
+    return messageHeader;
+  }
+
+  static parse(headerBuffer) {
+    return {
+      magic: headerBuffer.readUInt32LE(0),
+      headerLength: headerBuffer.readUInt32LE(4),
+      fragmentId: headerBuffer.readUInt16LE(8),
+      fragmentCount: headerBuffer.readUInt16LE(10),
+      payloadLength: headerBuffer.readUInt32LE(12),
+      identifier: headerBuffer.readUInt32LE(16),
+      conversationIndex: headerBuffer.readUInt32LE(20),
+      channel: headerBuffer.readUInt32LE(24),
+      expectsReply: headerBuffer.readUInt32LE(28)
+    };
+  }
+
+}
+
+exports.DTXMessageHeader = DTXMessageHeader;
+
+class DTXMessagePayloadHeader {
+  static build(data) {
+    const messageHeader = Buffer.alloc(DTX_MESSAGE_PAYLOAD_HEADER_LENGTH);
+    messageHeader.writeUInt32LE(data.flags, 0);
+    messageHeader.writeUInt32LE(data.auxLength, 4);
+    messageHeader.writeBigUInt64LE(data.totalLength, 8);
+    return messageHeader;
+  }
+
+  static parse(headerBuffer) {
+    return {
+      flags: headerBuffer.readUInt32LE(0),
+      auxLength: headerBuffer.readUInt32LE(4),
+      totalLength: headerBuffer.readBigInt64LE(8)
+    };
+  }
+
+}
+
+exports.DTXMessagePayloadHeader = DTXMessagePayloadHeader;
+
+class DTXMessageAux {
+  constructor(data = []) {
+    this.data = data;
+  }
+
+  build() {
+    const messageAux = new DTXMessageAuxBuffer();
+    let buf = Buffer.alloc(0);
+
+    if (this.data.length === 0) {
+      return buf;
+    }
+
+    for (const arg of this.data) {
+      if (arg instanceof DTXMessageAuxBuffer) {
+        buf = Buffer.concat([buf, arg.getBytes()]);
+      } else if (_lodash.default.isNumber(arg)) {
+        messageAux.appendInt(arg);
+      } else if (typeof arg == 'bigint') {
+        messageAux.appendLong(arg);
+      } else {
+        messageAux.appendObject(arg);
+      }
+    }
+
+    return Buffer.concat([buf, messageAux.getBytes()]);
+  }
+
+  static parse(headerBuffer) {
+    let cursor = 0;
+    const data = [];
+    const length = headerBuffer.readBigInt64LE(8);
+    cursor += 16;
+
+    while (cursor <= length) {
+      const m = headerBuffer.readUInt32LE(cursor);
+
+      if (m !== DTX_AUXILIARY_MAGIC) {
+        throw new Error(`incorrect auxiliary magic: ${m}`);
+      }
+
+      const type = headerBuffer.readUInt32LE(cursor + 4);
+      cursor += 8;
+
+      switch (type) {
+        case AUX_TYPES.NSKeyed:
+          {
+            const strLen = headerBuffer.readUInt32LE(cursor);
+            cursor += 4;
+            const archived_data = headerBuffer.slice(cursor, cursor + strLen);
+            data.push((0, _nskeyed.unarchive)(archived_data));
+            cursor += strLen;
+            break;
+          }
+
+        case AUX_TYPES.UInt32LE:
+          data.push(headerBuffer.readUInt32LE(cursor));
+          cursor += 4;
+          break;
+
+        case AUX_TYPES.BigUInt64LE:
+          data.push(headerBuffer.readBigUInt64LE(cursor));
+          cursor += 8;
+          break;
+
+        case AUX_TYPES.BigInt64LE:
+          data.push(headerBuffer.readBigInt64LE(cursor));
+          cursor += 8;
+          break;
+
+        default:
+          throw new Error(`Unknown type ${type}`);
+      }
+    }
+
+    return data;
+  }
+
+}
+
+exports.DTXMessageAux = DTXMessageAux;
+
+class InstrumentRPCParseError {
+  constructor(data) {
+    this.data = data;
+  }
+
+}
+
+class DTXMessageAuxBuffer {
+  constructor() {
+    this._buf = Buffer.alloc(0);
+  }
+
+  appendInt(value) {
+    const buf = Buffer.alloc(12);
+    buf.writeUInt32LE(DTX_AUXILIARY_MAGIC, 0);
+    buf.writeUInt32LE(3, 4);
+    buf.writeUInt32LE(value, 8);
+    this._buf = Buffer.concat([this._buf, buf]);
+  }
+
+  appendLong(value) {
+    const buf = Buffer.alloc(16);
+    buf.writeUInt32LE(DTX_AUXILIARY_MAGIC, 0);
+    buf.writeUInt32LE(4, 4);
+    buf.writeBigUInt64LE(value, 8);
+    this._buf = Buffer.concat([this._buf, buf]);
+  }
+
+  appendSignedInt(value) {
+    const buf = Buffer.alloc(12);
+    buf.writeUInt32LE(DTX_AUXILIARY_MAGIC, 0);
+    buf.writeUInt32LE(3, 4);
+    buf.writeInt32LE(value, 8);
+    this._buf = Buffer.concat([this._buf, buf]);
+  }
+
+  appendSignedLong(value) {
+    const buf = Buffer.alloc(16);
+
+    this._buf.writeUInt32LE(DTX_AUXILIARY_MAGIC, 0);
+
+    this._buf.writeUInt32LE(6, 4);
+
+    this._buf.writeBigInt64LE(value, 8);
+
+    this._buf = Buffer.concat([this._buf, buf]);
+  }
+
+  appendObject(value) {
+    const buf = (0, _nskeyed.archive)(value);
+    const buf2 = Buffer.alloc(12);
+    buf2.writeUInt32LE(DTX_AUXILIARY_MAGIC, 0);
+    buf2.writeUInt32LE(2, 4);
+    buf2.writeUInt32LE(buf.length, 8);
+    this._buf = Buffer.concat([this._buf, buf2, buf]);
+  }
+
+  getBytes() {
+    const out = Buffer.alloc(16);
+    out.writeUInt32LE(DTX_MESSAGE_AUX_HEADER, 0);
+    out.writeUInt32LE(this._buf.length, 8);
+    return Buffer.concat([out, this._buf]);
+  }
+
+}
+
+exports.DTXMessageAuxBuffer = DTXMessageAuxBuffer;
+
+class DTXMessage {
+  constructor(opts = {}) {
+    const {
+      identifier,
+      channelCode,
+      selector,
+      expectsReply,
+      conversationIndex = 0,
+      flags = FLAG_TYPES.send
+    } = opts;
+    this._messageHeader = undefined;
+    this._payloadHeader = undefined;
+    this._identifier = identifier;
+    this._channelCode = channelCode;
+    this._expectsReply = expectsReply;
+    this._selector = selector;
+    this._conversationIndex = conversationIndex;
+    this._flags = flags;
+    this.auxiliaries = new DTXMessageAux();
+  }
+
+  get identifier() {
+    var _this$_messageHeader;
+
+    return (_this$_messageHeader = this._messageHeader) === null || _this$_messageHeader === void 0 ? void 0 : _this$_messageHeader.identifier;
+  }
+
+  get channelCode() {
+    var _this$_messageHeader2;
+
+    return (_this$_messageHeader2 = this._messageHeader) === null || _this$_messageHeader2 === void 0 ? void 0 : _this$_messageHeader2.channel;
+  }
+
+  get expectsReply() {
+    var _this$_messageHeader3;
+
+    return (_this$_messageHeader3 = this._messageHeader) === null || _this$_messageHeader3 === void 0 ? void 0 : _this$_messageHeader3.expectsReply;
+  }
+
+  get selector() {
+    return this._selector;
+  }
+
+  set selector(data) {
+    this._selector = data;
+  }
+
+  get conversationIndex() {
+    var _this$_messageHeader4;
+
+    return (_this$_messageHeader4 = this._messageHeader) === null || _this$_messageHeader4 === void 0 ? void 0 : _this$_messageHeader4.conversationIndex;
+  }
+
+  build() {
+    const sel = this._selector ? (0, _nskeyed.archive)(this._selector) : Buffer.alloc(0);
+    const aux = this.auxiliaries.build();
+    const payloadHeader = DTXMessagePayloadHeader.build({
+      flags: this._flags,
+      auxLength: aux.length,
+      totalLength: BigInt(aux.length + sel.length)
+    });
+    const messageHeader = DTXMessageHeader.build({
+      payloadLength: DTX_MESSAGE_PAYLOAD_HEADER_LENGTH + aux.length + sel.length,
+      identifier: this._identifier,
+      conversationIndex: this._conversationIndex,
+      channelCode: this._channelCode,
+      expectsReply: this._expectsReply
+    });
+    return Buffer.concat([messageHeader, payloadHeader, aux, sel]);
+  }
+
+  static parse(headerBuf, payloadBuf) {
+    let cursor = 0;
+    const ret = new DTXMessage();
+    ret._messageHeader = DTXMessageHeader.parse(headerBuf);
+
+    if (ret._messageHeader.payloadLength === 0) {
+      return ret;
+    }
+
+    ret._payloadHeader = DTXMessagePayloadHeader.parse(payloadBuf.slice(cursor, DTX_MESSAGE_PAYLOAD_HEADER_LENGTH));
+    cursor += DTX_MESSAGE_PAYLOAD_HEADER_LENGTH;
+
+    if (ret._payloadHeader.totalLength === 0n) {
+      return ret;
+    }
+
+    if (ret._payloadHeader.auxLength > 0) {
+      ret.auxiliaries = DTXMessageAux.parse(payloadBuf.slice(cursor, cursor + ret._payloadHeader.auxLength));
+      cursor += ret._payloadHeader.auxLength;
+    }
+
+    const data = payloadBuf.slice(cursor, cursor + payloadBuf.length);
+
+    for (const fun of [_nskeyed.unarchive, _bplistParser.default.parseBuffer]) {
+      try {
+        ret.selector = fun(data);
+        break;
+      } catch (e) {
+        ret.selector = new InstrumentRPCParseError(data);
+      }
+    }
+
+    return ret;
+  }
+
+}
+
+exports.DTXMessage = DTXMessage;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/instrument/headers.js"],"names":["DTX_MESSAGE_PAYLOAD_HEADER_LENGTH","DTX_MESSAGE_HEADER_LENGTH","DTX_MESSAGE_HEADER_MAGIC","DTX_MESSAGE_HEADER_MAGIC_LEN","DTX_MESSAGE_AUX_HEADER","DTX_AUXILIARY_MAGIC","FLAG_TYPES","Object","freeze","recv","send","reply","AUX_TYPES","NSKeyed","UInt32LE","BigUInt64LE","BigInt64LE","DTXMessageHeader","build","data","messageHeader","Buffer","alloc","writeUInt32LE","writeUInt16LE","payloadLength","identifier","conversationIndex","channelCode","expectsReply","parse","headerBuffer","magic","readUInt32LE","headerLength","fragmentId","readUInt16LE","fragmentCount","channel","DTXMessagePayloadHeader","flags","auxLength","writeBigUInt64LE","totalLength","readBigInt64LE","DTXMessageAux","constructor","messageAux","DTXMessageAuxBuffer","buf","length","arg","concat","getBytes","_","isNumber","appendInt","appendLong","appendObject","cursor","m","Error","type","strLen","archived_data","slice","push","readBigUInt64LE","InstrumentRPCParseError","_buf","value","appendSignedInt","writeInt32LE","appendSignedLong","writeBigInt64LE","buf2","out","DTXMessage","opts","selector","_messageHeader","undefined","_payloadHeader","_identifier","_channelCode","_expectsReply","_selector","_conversationIndex","_flags","auxiliaries","sel","aux","payloadHeader","BigInt","headerBuf","payloadBuf","ret","fun","unarchive","plistlib","parseBuffer","e"],"mappings":"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","sourcesContent":["import {archive, unarchive} from './transformer/nskeyed';\nimport plistlib from 'bplist-parser';\nimport _ from 'lodash';\n\nconst DTX_MESSAGE_PAYLOAD_HEADER_LENGTH = 16;\nconst DTX_MESSAGE_HEADER_LENGTH = 32;\nconst DTX_MESSAGE_HEADER_MAGIC = 0x1F3D5B79;\nconst DTX_MESSAGE_HEADER_MAGIC_LEN = 4;\nconst DTX_MESSAGE_AUX_HEADER = 0x01F0;\nconst DTX_AUXILIARY_MAGIC = 0xa;\n\nconst FLAG_TYPES = Object.freeze({\n  recv: 1,\n  send: 2,\n  reply: 3\n});\n\nconst AUX_TYPES = Object.freeze({\n  NSKeyed: 2,\n  UInt32LE: 3,\n  BigUInt64LE: 4,\n  BigInt64LE: 6\n});\n\n/**\n * DTXMessageHeader length 32\n * struct DTXMessageHeader {\n *     u32 magic DTX_MESSAGE_HEADER_MAGIC\n *     u32 headerLength\n *     u16 fragmentId   packet number\n *     u16 fragmentCount  packets total number\n *     u32 payloadLength\n *     u32 identifier\n *     u32 conversationIndex\n *     u32 channel\n *     u32 expectsReply\n *     }\n */\n\n/**\n * @typedef {Object} DTXMessageOptions\n * @property {number} identifier packet transmission sequence, this value is incremented for each request\n * @property {number} channelCode the data transmission of the service will use this channel code.\n * Each service has a separate channel\n * @property {?number} payloadLength DTXMessageAuxBuffer.length(nullable) + selectorBuffer.length(nullable)\n * @property {boolean} expectsReply if true reply a ack message\n * @property {number} conversationIndex  raw data +1 indicate a reply message\n * @property {number} flags message status\n */\n\nclass DTXMessageHeader {\n  /**\n   * @param {DTXMessageOptions} data\n   * @returns {Buffer} DTXMessageHeaderBuffer\n   */\n  static build (data) {\n    const messageHeader = Buffer.alloc(DTX_MESSAGE_HEADER_LENGTH);\n    messageHeader.writeUInt32LE(DTX_MESSAGE_HEADER_MAGIC, 0);\n    messageHeader.writeUInt32LE(DTX_MESSAGE_HEADER_LENGTH, 4);\n    messageHeader.writeUInt16LE(0, 8);\n    messageHeader.writeUInt16LE(1, 10);\n    messageHeader.writeUInt32LE(data.payloadLength, 12);\n    messageHeader.writeUInt32LE(data.identifier, 16);\n    messageHeader.writeUInt32LE(data.conversationIndex, 20);\n    messageHeader.writeUInt32LE(data.channelCode, 24);\n    messageHeader.writeUInt32LE(data.expectsReply, 28);\n    return messageHeader;\n  }\n\n  /**\n   * @param headerBuffer DTXMessageHeaderBuffer\n   * @returns {Object}\n   */\n  static parse (headerBuffer) {\n    return {\n      magic: headerBuffer.readUInt32LE(0),\n      headerLength: headerBuffer.readUInt32LE(4),\n      fragmentId: headerBuffer.readUInt16LE(8),\n      fragmentCount: headerBuffer.readUInt16LE(10),\n      payloadLength: headerBuffer.readUInt32LE(12),\n      identifier: headerBuffer.readUInt32LE(16),\n      conversationIndex: headerBuffer.readUInt32LE(20),\n      channel: headerBuffer.readUInt32LE(24),\n      expectsReply: headerBuffer.readUInt32LE(28),\n    };\n  }\n}\n\n/**\n * DTXMessagePayloadHeader length 16\n * struct DTXMessageHeader {\n *     u32 flags FLAG_TYPES\n *     u32 auxLength\n *     u64 totalLength\n *     }\n */\n\n/**\n * @typedef {Object} DTXMessagePayloadHeaderObject\n * @property {number} flags message status\n * @property {number} auxLength DTXMessageAuxBuffer.length(nullable)\n * @property {bigint} totalLength DTXMessageAuxBuffer.length(nullable) + selectorBuffer.length\n */\nclass DTXMessagePayloadHeader {\n  /**\n   * @param data {DTXMessagePayloadHeaderObject}\n   * @returns {Buffer} DTXMessagePayloadHeaderBuffer\n   */\n  static build (data) {\n    const messageHeader = Buffer.alloc(DTX_MESSAGE_PAYLOAD_HEADER_LENGTH);\n    messageHeader.writeUInt32LE(data.flags, 0);\n    messageHeader.writeUInt32LE(data.auxLength, 4);\n    messageHeader.writeBigUInt64LE(data.totalLength, 8);\n    return messageHeader;\n  }\n\n  /**\n   * @param headerBuffer\n   * @returns {{flags: number, totalLength: bigint, auxLength: number}}\n   */\n  static parse (headerBuffer) {\n    return {\n      flags: headerBuffer.readUInt32LE(0),\n      auxLength: headerBuffer.readUInt32LE(4),\n      totalLength: headerBuffer.readBigInt64LE(8)\n    };\n  }\n}\n\n\nclass DTXMessageAux {\n  constructor (data = []) {\n    this.data = data;\n  }\n\n  /**\n   * JS Array to Apple NSKeyed Buffer\n   * @returns {Buffer}\n   */\n  build () {\n    const messageAux = new DTXMessageAuxBuffer();\n    let buf = Buffer.alloc(0);\n    if (this.data.length === 0) {\n      return buf;\n    }\n    for (const arg of this.data) {\n      if (arg instanceof DTXMessageAuxBuffer) {\n        buf = Buffer.concat([buf, arg.getBytes()]);\n      } else if (_.isNumber(arg)) {\n        messageAux.appendInt(arg);\n      } else if (typeof arg == 'bigint') {\n        messageAux.appendLong(arg);\n      } else {\n        messageAux.appendObject(arg);\n      }\n    }\n    return Buffer.concat([buf, messageAux.getBytes()]);\n  }\n\n  /**\n   * Parses nskeyed Buffer into js array\n   * @param headerBuffer\n   * @returns {Array}\n   */\n  static parse (headerBuffer) {\n    let cursor = 0;\n    const data = [];\n    const length = headerBuffer.readBigInt64LE(8);\n    cursor += 16;\n    while (cursor <= length) {\n      const m = headerBuffer.readUInt32LE(cursor);\n      if (m !== DTX_AUXILIARY_MAGIC) {\n        throw new Error(`incorrect auxiliary magic: ${m}`);\n      }\n      const type = headerBuffer.readUInt32LE(cursor + 4);\n      cursor += 8;\n      switch (type) {\n        case AUX_TYPES.NSKeyed: {\n          const strLen = headerBuffer.readUInt32LE(cursor);\n          cursor += 4;\n          const archived_data = headerBuffer.slice(cursor, cursor + strLen);\n          data.push(unarchive(archived_data));\n          cursor += strLen;\n          break;\n        }\n        case AUX_TYPES.UInt32LE:\n          data.push(headerBuffer.readUInt32LE(cursor));\n          cursor += 4;\n          break;\n        case AUX_TYPES.BigUInt64LE:\n          data.push(headerBuffer.readBigUInt64LE(cursor));\n          cursor += 8;\n          break;\n        case AUX_TYPES.BigInt64LE:\n          data.push(headerBuffer.readBigInt64LE(cursor));\n          cursor += 8;\n          break;\n        default:\n          throw new Error(`Unknown type ${type}`);\n      }\n    }\n    return data;\n  }\n}\n\nclass InstrumentRPCParseError {\n  constructor (data) {\n    this.data = data;\n  }\n}\n\nclass DTXMessageAuxBuffer {\n  constructor () {\n    this._buf = Buffer.alloc(0);\n  }\n\n  /**\n   * @param {number} value\n   */\n  appendInt (value) {\n    const buf = Buffer.alloc(12);\n    buf.writeUInt32LE(DTX_AUXILIARY_MAGIC, 0);\n    buf.writeUInt32LE(3, 4);\n    buf.writeUInt32LE(value, 8);\n    this._buf = Buffer.concat([this._buf, buf]);\n  }\n\n  /**\n   * @param {bigint} value\n   */\n  appendLong (value) {\n    const buf = Buffer.alloc(16);\n    buf.writeUInt32LE(DTX_AUXILIARY_MAGIC, 0);\n    buf.writeUInt32LE(4, 4);\n    buf.writeBigUInt64LE(value, 8);\n    this._buf = Buffer.concat([this._buf, buf]);\n  }\n\n  /**\n   * @param {number} value\n   */\n  appendSignedInt (value) {\n    const buf = Buffer.alloc(12);\n    buf.writeUInt32LE(DTX_AUXILIARY_MAGIC, 0);\n    buf.writeUInt32LE(3, 4);\n    buf.writeInt32LE(value, 8);\n    this._buf = Buffer.concat([this._buf, buf]);\n  }\n\n  /**\n   * @param {bigint} value\n   */\n  appendSignedLong (value) {\n    const buf = Buffer.alloc(16);\n    this._buf.writeUInt32LE(DTX_AUXILIARY_MAGIC, 0);\n    this._buf.writeUInt32LE(6, 4);\n    this._buf.writeBigInt64LE(value, 8);\n    this._buf = Buffer.concat([this._buf, buf]);\n  }\n\n  /**\n   * @param {Object} value\n   */\n  appendObject (value) {\n    const buf = archive(value);\n    const buf2 = Buffer.alloc(12);\n    buf2.writeUInt32LE(DTX_AUXILIARY_MAGIC, 0);\n    buf2.writeUInt32LE(2, 4);\n    buf2.writeUInt32LE(buf.length, 8);\n    this._buf = Buffer.concat([this._buf, buf2, buf]);\n  }\n\n  getBytes () {\n    const out = Buffer.alloc(16);\n    out.writeUInt32LE(DTX_MESSAGE_AUX_HEADER, 0);\n    out.writeUInt32LE(this._buf.length, 8);\n    return Buffer.concat([out, this._buf]);\n  }\n}\n\n\n\nclass DTXMessage {\n  /**\n   * @param {DTXMessageOptions} opts\n   */\n  constructor (opts = {}) {\n    const {\n      identifier,\n      channelCode,\n      selector,\n      expectsReply,\n      conversationIndex = 0,\n      flags = FLAG_TYPES.send\n    } = opts;\n    this._messageHeader = undefined;\n    this._payloadHeader = undefined;\n    this._identifier = identifier;\n    this._channelCode = channelCode;\n    this._expectsReply = expectsReply;\n    this._selector = selector;\n    this._conversationIndex = conversationIndex;\n    this._flags = flags;\n    this.auxiliaries = new DTXMessageAux();\n  }\n\n  /**\n   * get DTXMessageHeader identifier. Packet transmission sequence\n   * @returns {number}\n   */\n  get identifier () {\n    return this._messageHeader?.identifier;\n  }\n\n  /**\n   * get DTXMessageHeader channelCode.\n   * Packet transmission channelCode. Use this value to distinguish when there are multiple channels\n   * call this method `InstrumentService.registerChannelCallback` get the channel message\n   * @returns {number}\n   */\n  get channelCode () {\n    return this._messageHeader?.channel;\n  }\n\n  /**\n   * get DTXMessageHeader expectsReply. Whether to need ack message\n   * if expectsReply is true must reply ack message\n   * @returns {boolean}\n   */\n  get expectsReply () {\n    return this._messageHeader?.expectsReply;\n  }\n\n  /**\n   * call this method `InstrumentService.registerSelectorCallback` get the selector message\n   * @returns {*} Unknown data\n   */\n  get selector () {\n    return this._selector;\n  }\n\n  /**\n   * @param data\n   */\n  set selector (data) {\n    this._selector = data;\n  }\n\n  /**\n   * get DTXMessageHeader conversationIndex\n   * @returns {number}\n   */\n  get conversationIndex () {\n    return this._messageHeader?.conversationIndex;\n  }\n\n  /**\n   * DTXMessage Buffer: DTXMessageHeader + PayloadHeader + DTXMessageAuxBuffer(nullable) + selector(nullable)\n   * @returns {Buffer}\n   */\n  build () {\n    const sel = this._selector ? archive(this._selector) : Buffer.alloc(0);\n    const aux = this.auxiliaries.build();\n    const payloadHeader = DTXMessagePayloadHeader.build({\n      flags: this._flags,\n      auxLength: aux.length,\n      // need to convert to bigint in any case\n      // eslint-disable-next-line no-undef\n      totalLength: BigInt(aux.length + sel.length),\n    });\n\n    const messageHeader = DTXMessageHeader.build({\n      payloadLength: DTX_MESSAGE_PAYLOAD_HEADER_LENGTH + aux.length + sel.length,\n      identifier: this._identifier,\n      conversationIndex: this._conversationIndex,\n      channelCode: this._channelCode,\n      expectsReply: this._expectsReply\n    });\n    return Buffer.concat([messageHeader, payloadHeader, aux, sel]);\n  }\n\n  /**\n   * Parses DTX buffer into an js object. Returned in DTXDecoder Stream.Transform\n   * @param {Buffer} headerBuf  DTXMessageHeader buffer\n   * @param {Buffer} payloadBuf  PayloadHeaderBuffer + DTXMessageAuxBuffer(nullable) + selectorBuffer(nullable)\n   * @returns {DTXMessage}\n   */\n  static parse (headerBuf, payloadBuf) {\n    let cursor = 0;\n    const ret = new DTXMessage();\n    ret._messageHeader = DTXMessageHeader.parse(headerBuf);\n    if (ret._messageHeader.payloadLength === 0) {\n      return ret;\n    }\n    ret._payloadHeader = DTXMessagePayloadHeader.parse(payloadBuf.slice(cursor, DTX_MESSAGE_PAYLOAD_HEADER_LENGTH));\n    cursor += DTX_MESSAGE_PAYLOAD_HEADER_LENGTH;\n    // totalLength is bigint use 0n\n    if (ret._payloadHeader.totalLength === 0n) {\n      return ret;\n    }\n    if (ret._payloadHeader.auxLength > 0) {\n      ret.auxiliaries = DTXMessageAux.parse(payloadBuf.slice(cursor, cursor + ret._payloadHeader.auxLength));\n      cursor += ret._payloadHeader.auxLength;\n    }\n\n    const data = payloadBuf.slice(cursor, cursor + payloadBuf.length);\n    for (const fun of [unarchive, plistlib.parseBuffer]) {\n      try {\n        ret.selector = fun(data);\n        break;\n      } catch (e) {\n        ret.selector = new InstrumentRPCParseError(data);\n      }\n    }\n    return ret;\n  }\n}\n\nexport { DTXMessageHeader, DTXMessagePayloadHeader, DTXMessageAuxBuffer, DTXMessageAux, DTXMessage,\n  DTX_MESSAGE_PAYLOAD_HEADER_LENGTH, DTX_MESSAGE_HEADER_LENGTH, DTX_MESSAGE_HEADER_MAGIC, DTX_MESSAGE_HEADER_MAGIC_LEN,\n  FLAG_TYPES};"],"file":"lib/instrument/headers.js","sourceRoot":"../../.."}

package/build/lib/instrument/index.js

@@ -0,0 +1,187 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SERVICE = exports.InstrumentService = exports.INSTRUMENT_SERVICE_NAME_VERSION_14 = exports.INSTRUMENT_SERVICE_NAME = void 0;
+
+require("source-map-support/register");
+
+var _baseService = require("../base-service");
+
+var _headers = require("./headers");
+
+var _dtxEncode = require("./transformer/dtx-encode");
+
+var _dtxDecode = require("./transformer/dtx-decode");
+
+var _events = _interopRequireDefault(require("events"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _asyncbox = require("asyncbox");
+
+const CHECK_FREQ_MS = 500;
+const WAIT_REPLY_TIME_MS = 10000;
+const EMPTY_MESSAGE_SIZE = 16;
+const CHANNEL_CANCELED = '_channelCanceled';
+const CHANNEL_OFFSET = 2 ** 32;
+const INSTRUMENT_SERVICE_NAME_VERSION_14 = 'com.apple.instruments.remoteserver.DVTSecureSocketProxy';
+exports.INSTRUMENT_SERVICE_NAME_VERSION_14 = INSTRUMENT_SERVICE_NAME_VERSION_14;
+const INSTRUMENT_SERVICE_NAME = 'com.apple.instruments.remoteserver';
+exports.INSTRUMENT_SERVICE_NAME = INSTRUMENT_SERVICE_NAME;
+const SERVICE = Object.freeze({
+  DEVICE_INFO: 'com.apple.instruments.server.services.deviceinfo',
+  PROCESS_CONTROL: 'com.apple.instruments.server.services.processcontrol',
+  SYSMONTAP: 'com.apple.instruments.server.services.sysmontap',
+  NETWORKING: 'com.apple.instruments.server.services.networking',
+  MOBILE_NOTIFICATIONS: 'com.apple.instruments.server.services.mobilenotifications',
+  GRAPHICS_OPENGL: 'com.apple.instruments.server.services.graphics.opengl',
+  APPLICATION_LISTING: 'com.apple.instruments.server.services.device.applictionListing',
+  CONDITION_INDUCER: 'com.apple.instruments.server.services.ConditionInducer'
+});
+exports.SERVICE = SERVICE;
+
+function defaultDict(createValue) {
+  return new Proxy(Object.create(null), {
+    get(storage, property) {
+      if (!(property in storage)) {
+        storage[property] = createValue(property);
+      }
+
+      return storage[property];
+    }
+
+  });
+}
+
+class InstrumentService extends _baseService.BaseServiceSocket {
+  constructor(socketClient, event) {
+    super(socketClient);
+    this._undefinedCallback = event;
+    this._callbacks = new _events.default.EventEmitter();
+    this._channelCallbacks = new _events.default.EventEmitter();
+    this._replyQueues = defaultDict(() => []);
+    this._channels = {};
+    this._nextIdentifier = 1;
+    this._encoder = new _dtxEncode.DTXEncoder();
+
+    this._encoder.pipe(this._socketClient);
+
+    this._assignClientFailureHandlers(this._encoder);
+
+    this._decoder = new _dtxDecode.DTXDecoder();
+
+    this._socketClient.pipe(this._decoder);
+
+    this._decoder.on('data', this._handleData.bind(this));
+  }
+
+  registerSelectorCallback(selector, event) {
+    this._callbacks.addListener(selector, event);
+  }
+
+  registerUndefinedCallback(event) {
+    this._undefinedCallback = event;
+  }
+
+  async registerChannelCallback(channel, event) {
+    const channelId = await this.makeChannel(channel);
+
+    this._channelCallbacks.addListener(channelId, event);
+  }
+
+  async makeChannel(channel) {
+    if (channel in this._channels) {
+      return this._channels[channel];
+    }
+
+    const channelCode = Object.keys(this._channels).length + 1;
+    await this._callChannel(true, 0, '_requestChannelWithCode:identifier:', channelCode, channel);
+    this._channels[channel] = channelCode;
+    return channelCode;
+  }
+
+  async callChannel(channel, selector, ...auxiliaries) {
+    const channelCode = await this.makeChannel(channel);
+    return await this._callChannel(true, channelCode, selector, ...auxiliaries);
+  }
+
+  async _callChannel(sync, channelCode, selector, ...auxiliaries) {
+    const identifier = this._nextIdentifier;
+
+    this._encoder.write({
+      sync,
+      channelCode,
+      selector,
+      auxiliaries,
+      identifier
+    });
+
+    ++this._nextIdentifier;
+
+    if (sync) {
+      try {
+        return await (0, _asyncbox.waitForCondition)(() => {
+          const queue = this._replyQueues[identifier];
+          const data = queue.shift();
+
+          if (!_lodash.default.isUndefined(data)) {
+            return data;
+          }
+        }, {
+          waitMs: WAIT_REPLY_TIME_MS,
+          intervalMs: CHECK_FREQ_MS,
+          error: 'reply channel data timeout'
+        });
+      } catch (err) {
+        this.close();
+        throw new Error(err);
+      }
+    }
+  }
+
+  _handleData(data) {
+    if (_lodash.default.includes(data.selector, CHANNEL_CANCELED)) {
+      this.close();
+    }
+
+    if (data.conversationIndex === 1) {
+      this._replyQueues[data.identifier].push(data);
+    } else if (this._channelCallbacks.listenerCount(CHANNEL_OFFSET - data.channelCode) > 0) {
+      this._channelCallbacks.emit(CHANNEL_OFFSET - data.channelCode, data);
+    } else {
+      const selector = data.selector;
+
+      if (_lodash.default.isString(selector) && this._callbacks.listenerCount(selector) > 0) {
+        this._callbacks.emit(selector, data);
+      } else if (this._undefinedCallback) {
+        this._undefinedCallback(data);
+      }
+
+      if (data.expectsReply) {
+        this._replyAck(data);
+      }
+    }
+  }
+
+  _replyAck(data) {
+    const reply = new _headers.DTXMessage({
+      identifier: data.identifier,
+      channelCode: data.channelCode,
+      selector: Buffer.alloc(EMPTY_MESSAGE_SIZE),
+      conversationIndex: data.conversationIndex + 1,
+      flags: _headers.FLAG_TYPES.reply
+    });
+
+    this._socketClient.write(reply.build());
+  }
+
+}
+
+exports.InstrumentService = InstrumentService;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/instrument/index.js"],"names":["CHECK_FREQ_MS","WAIT_REPLY_TIME_MS","EMPTY_MESSAGE_SIZE","CHANNEL_CANCELED","CHANNEL_OFFSET","INSTRUMENT_SERVICE_NAME_VERSION_14","INSTRUMENT_SERVICE_NAME","SERVICE","Object","freeze","DEVICE_INFO","PROCESS_CONTROL","SYSMONTAP","NETWORKING","MOBILE_NOTIFICATIONS","GRAPHICS_OPENGL","APPLICATION_LISTING","CONDITION_INDUCER","defaultDict","createValue","Proxy","create","get","storage","property","InstrumentService","BaseServiceSocket","constructor","socketClient","event","_undefinedCallback","_callbacks","events","EventEmitter","_channelCallbacks","_replyQueues","_channels","_nextIdentifier","_encoder","DTXEncoder","pipe","_socketClient","_assignClientFailureHandlers","_decoder","DTXDecoder","on","_handleData","bind","registerSelectorCallback","selector","addListener","registerUndefinedCallback","registerChannelCallback","channel","channelId","makeChannel","channelCode","keys","length","_callChannel","callChannel","auxiliaries","sync","identifier","write","queue","data","shift","_","isUndefined","waitMs","intervalMs","error","err","close","Error","includes","conversationIndex","push","listenerCount","emit","isString","expectsReply","_replyAck","reply","DTXMessage","Buffer","alloc","flags","FLAG_TYPES","build"],"mappings":"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","sourcesContent":["// Adapted from https://github.com/YueChen-C/py-ios-device\n\nimport {BaseServiceSocket} from '../base-service';\nimport {DTXMessage, FLAG_TYPES} from './headers';\nimport {DTXEncoder} from './transformer/dtx-encode';\nimport {DTXDecoder} from './transformer/dtx-decode';\nimport events from 'events';\nimport _ from 'lodash';\nimport {waitForCondition} from 'asyncbox';\n\nconst CHECK_FREQ_MS = 500;\nconst WAIT_REPLY_TIME_MS = 10000;\nconst EMPTY_MESSAGE_SIZE = 16;\nconst CHANNEL_CANCELED = '_channelCanceled';\nconst CHANNEL_OFFSET = 2 ** 32;\n\nconst INSTRUMENT_SERVICE_NAME_VERSION_14 = 'com.apple.instruments.remoteserver.DVTSecureSocketProxy';\nconst INSTRUMENT_SERVICE_NAME = 'com.apple.instruments.remoteserver';\n\nexport const SERVICE = Object.freeze({\n  DEVICE_INFO: 'com.apple.instruments.server.services.deviceinfo',\n  PROCESS_CONTROL: 'com.apple.instruments.server.services.processcontrol',\n  SYSMONTAP: 'com.apple.instruments.server.services.sysmontap',\n  NETWORKING: 'com.apple.instruments.server.services.networking',\n  MOBILE_NOTIFICATIONS: 'com.apple.instruments.server.services.mobilenotifications',\n  GRAPHICS_OPENGL: 'com.apple.instruments.server.services.graphics.opengl',\n  APPLICATION_LISTING: 'com.apple.instruments.server.services.device.applictionListing',\n  CONDITION_INDUCER: 'com.apple.instruments.server.services.ConditionInducer'\n});\n\nfunction defaultDict (createValue) {\n  return new Proxy(Object.create(null), {\n    get (storage, property) {\n      if (!(property in storage)) {\n        storage[property] = createValue(property);\n      }\n      return storage[property];\n    }\n  });\n}\n\n/** The callback function which will be called during the data transmission in instrument serve\n * @name DTXCallback\n * @function\n * @param {DTXMessage} object\n*/\n\n/**\n * @param {Socket} socketClient  DTXMessage.selector\n * @param {?DTXCallback} event if empty will ignore any messages\n */\nclass InstrumentService extends BaseServiceSocket {\n  constructor (socketClient, event) {\n    super(socketClient);\n    this._undefinedCallback = event;\n    this._callbacks = new events.EventEmitter();\n    this._channelCallbacks = new events.EventEmitter();\n    this._replyQueues = defaultDict(() => []);\n    this._channels = {};\n    this._nextIdentifier = 1;\n    this._encoder = new DTXEncoder();\n    this._encoder.pipe(this._socketClient);\n    this._assignClientFailureHandlers(this._encoder);\n    this._decoder = new DTXDecoder();\n    this._socketClient.pipe(this._decoder);\n    this._decoder.on('data', this._handleData.bind(this));\n  }\n\n  /**\n   * If the selector is registered, The message of the selector event will be returned. refer to this._handleData\n   * @param {string} selector  Listen for return DTXMessage.selector data\n   * @param {DTXCallback} event\n   */\n  registerSelectorCallback (selector, event) {\n    this._callbacks.addListener(selector, event);\n  }\n\n  /**\n   * If the event is registered, all unregistered messages will be returned to event. refer to this._handleData\n   * @param {DTXCallback} event\n   */\n  registerUndefinedCallback (event) {\n    this._undefinedCallback = event;\n  }\n\n  /**\n   * If the event is registered, this channel {SERVICE} messages will be returned to event. refer to this._handleData\n   * It's actually listening for int channelCode. In this._channel object to record channel key and int value\n   * @param {string} channel instruments service channel e.g: SERVICE.DEVICE_INFO.\n   * @param {DTXCallback} event\n   */\n  async registerChannelCallback (channel, event) {\n    const channelId = await this.makeChannel(channel);\n    this._channelCallbacks.addListener(channelId, event);\n  }\n\n  /**\n   * Create a service channel, data transmission of the service will use this channelCode\n   * @param {string} channel  instruments service channel e.g: SERVICE.DEVICE_INFO\n   * @returns {Promise<number|*>} instruments service channel code for data transmission\n   */\n  async makeChannel (channel) {\n    if (channel in this._channels) {\n      return this._channels[channel];\n    }\n    const channelCode = Object.keys(this._channels).length + 1;\n    await this._callChannel(true, 0, '_requestChannelWithCode:identifier:', channelCode, channel);\n    this._channels[channel] = channelCode;\n    return channelCode;\n  }\n\n  /**\n   * In general, we call this method to start the instrument dtx service\n   * @param {string} channel instrument dtx service e.g: SERVICE.DEVICE_INFO\n   * @param {string} selector instrument service method name (reflection calls)\n   * @param {...any} auxiliaries parameters required by selector\n   * @returns {Promise<DTXMessage>}\n   * example：\n   * instrumentService.callChannel(SERVICE.PROCESS_CONTROL,\n        'launchSuspendedProcessWithDevicePath:bundleIdentifier:environment:arguments:options:', '',\n        bundleID, {}, [], {'StartSuspendedKey': 0, 'KillExisting': 1}\n   */\n  async callChannel (channel, selector, ...auxiliaries) {\n    const channelCode = await this.makeChannel(channel);\n    return await this._callChannel(true, channelCode, selector, ...auxiliaries);\n  }\n\n  async _callChannel (sync, channelCode, selector, ...auxiliaries) {\n    const identifier = this._nextIdentifier;\n    this._encoder.write({sync, channelCode, selector, auxiliaries, identifier});\n    ++this._nextIdentifier;\n    if (sync) {\n      try {\n        return await waitForCondition(() => {\n          const queue = this._replyQueues[identifier];\n          const data = queue.shift();\n          if (!_.isUndefined(data)) {\n            return data;\n          }\n        }, {waitMs: WAIT_REPLY_TIME_MS, intervalMs: CHECK_FREQ_MS, error: 'reply channel data timeout'});\n      } catch (err) {\n        this.close();\n        throw new Error(err);\n      }\n    }\n  }\n\n  /**\n   * Handling registered asynchronous message callbacks\n   * @param {DTXMessage} data\n   * @private\n   */\n  _handleData (data) {\n    if (_.includes(data.selector, CHANNEL_CANCELED)) {\n      this.close();\n    }\n    if (data.conversationIndex === 1) {\n      this._replyQueues[data.identifier].push(data);\n    } else if (this._channelCallbacks.listenerCount(CHANNEL_OFFSET - data.channelCode) > 0) {\n      this._channelCallbacks.emit(CHANNEL_OFFSET - data.channelCode, data);\n    } else {\n      const selector = data.selector;\n      if (_.isString(selector) && this._callbacks.listenerCount(selector) > 0) {\n        this._callbacks.emit(selector, data);\n      } else if (this._undefinedCallback) {\n        this._undefinedCallback(data);\n      }\n      if (data.expectsReply) {\n        this._replyAck(data);\n      }\n    }\n  }\n\n  /**\n   * return a empty ack message\n   * @param {DTXMessage} data\n   */\n  _replyAck (data) {\n    const reply = new DTXMessage({\n      identifier: data.identifier,\n      channelCode: data.channelCode,\n      selector: Buffer.alloc(EMPTY_MESSAGE_SIZE),\n      conversationIndex: data.conversationIndex + 1,\n      flags: FLAG_TYPES.reply\n    });\n    this._socketClient.write(reply.build());\n  }\n}\n\nexport { InstrumentService, INSTRUMENT_SERVICE_NAME_VERSION_14, INSTRUMENT_SERVICE_NAME };\n"],"file":"lib/instrument/index.js","sourceRoot":"../../.."}