appium-ios-remotexpc 0.0.3 → 0.0.5

package/test/integration/diagnostics-test.ts

@@ -1,44 +0,0 @@
-import { expect } from 'chai';
-
-import { Services } from '../../src/index.js';
-import type { DiagnosticsService } from '../../src/lib/types.js';
-
-describe('Diagnostics Service', function () {
-  // Increase timeout for integration tests
-  this.timeout(60000);
-
-  let remoteXPC: any;
-  let diagService: DiagnosticsService;
-  const udid = process.env.UDID || '';
-
-  before(async function () {
-    diagService = await Services.startDiagnosticsService(udid);
-  });
-
-  after(async function () {
-    // Close RemoteXPC connection
-    if (remoteXPC) {
-      try {
-        await remoteXPC.close();
-      } catch (error) {
-        // Ignore cleanup errors in tests
-      }
-    }
-  });
-
-  it('should query power information using ioregistry', async function () {
-    const rawInfo = await diagService.ioregistry({
-      ioClass: 'IOPMPowerSource',
-      returnRawJson: true,
-    });
-    expect(rawInfo).to.be.an('object');
-  });
-
-  it('should query wifi information using ioregistry ', async function () {
-    const wifiInfo = await diagService.ioregistry({
-      name: 'AppleBCMWLANSkywalkInterface',
-      returnRawJson: true,
-    });
-    expect(wifiInfo).to.be.an('object');
-  });
-});

package/test/integration/read-pair-record-test.ts

@@ -1,39 +0,0 @@
-import { expect } from 'chai';
-
-import { createUsbmux } from '../../src/lib/usbmux/index.js';
-
-describe('Pair Record', function () {
-  // Increase timeout for integration tests
-  this.timeout(60000);
-
-  let usb: any;
-
-  before(async function () {
-    usb = await createUsbmux();
-  });
-
-  after(async function () {
-    if (usb) {
-      await usb.close();
-    }
-  });
-
-  it('should read pair record', async function () {
-    try {
-      await usb.readPairRecord('');
-      // If no error is thrown, the test passes
-      expect(true).to.be.true;
-    } catch (err) {
-      console.log(err);
-      // If the error is expected (e.g., no pair record found), the test can still pass
-      // Otherwise, fail the test
-      expect(err).to.not.be.undefined;
-    }
-  });
-
-  it('should list devices', async function () {
-    const devices = await usb.listDevices();
-    console.log(devices);
-    expect(devices).to.be.an('array');
-  });
-});

package/test/integration/tunnel-test.ts

@@ -1,104 +0,0 @@
-import { logger } from '@appium/support';
-import { expect } from 'chai';
-
-import {
-  PacketStreamClient,
-  TunnelManager,
-} from '../../src/lib/tunnel/index.js';
-import type { SyslogService } from '../../src/lib/types.js';
-import {
-  createRemoteXPCConnection,
-  startSyslogService,
-} from '../../src/services.js';
-
-const log = logger.getLogger('TunnelTest');
-
-describe('Tunnel and Syslog Service', function () {
-  // Increase timeout for integration tests
-  this.timeout(60000);
-
-  let remoteXpc: any;
-  let syslogService: SyslogService;
-  let service: any;
-  let packetStreamClient: PacketStreamClient | null = null;
-  const udid = process.env.UDID || '';
-
-  before(async function () {
-    const { remoteXPC, tunnelConnection } =
-      await createRemoteXPCConnection(udid);
-    remoteXpc = remoteXPC;
-    packetStreamClient = new PacketStreamClient(
-      'localhost',
-      tunnelConnection.packetStreamPort,
-    );
-    try {
-      await packetStreamClient.connect();
-      log.info('Connected to packet stream server');
-    } catch (err) {
-      log.warn(`Failed to connect to packet stream server: ${err}`);
-      packetStreamClient = null;
-    }
-  });
-
-  after(async function () {
-    if (packetStreamClient) {
-      await packetStreamClient.disconnect();
-    }
-
-    await TunnelManager.closeAllTunnels();
-  });
-
-  it('should list all services', function () {
-    const services = remoteXpc.getServices();
-    expect(services).to.be.an('array');
-  });
-
-  it('should find os_trace_relay service', function () {
-    service = remoteXpc.findService('com.apple.os_trace_relay.shim.remote');
-    expect(service).to.not.be.undefined;
-  });
-
-  it('should start syslog service (requires active tunnel with packet source)', async function () {
-    syslogService = await startSyslogService(udid);
-    if (!packetStreamClient) {
-      this.skip();
-      return;
-    }
-
-    // Refresh the service object before using it
-    service = remoteXpc.findService('com.apple.os_trace_relay.shim.remote');
-    expect(service).to.not.be.undefined;
-
-    await syslogService.start(service, packetStreamClient, {
-      pid: -1,
-    });
-    expect(true).to.be.true;
-  });
-
-  it('should capture and emit syslog messages (requires active tunnel with packet source)', async function () {
-    if (!packetStreamClient) {
-      this.skip();
-      return;
-    }
-
-    // Refresh the service object before using it again
-    service = remoteXpc.findService('com.apple.os_trace_relay.shim.remote');
-    expect(service).to.not.be.undefined;
-
-    const messages: string[] = [];
-    syslogService.on('message', (message: string) => {
-      messages.push(message);
-    });
-
-    await syslogService.start(service, packetStreamClient, {
-      pid: -1,
-    });
-
-    // Wait for a few seconds to collect messages
-    await new Promise((resolve) => setTimeout(resolve, 3000));
-
-    await syslogService.stop();
-
-    expect(messages.length).to.be.greaterThan(0);
-  });
-});

package/test/unit/apple-tv/tlv/decoder.spec.ts

@@ -1,144 +0,0 @@
-import { expect } from 'chai';
-
-import { TLV8Error } from '../../../../src/lib/apple-tv/errors.js';
-import {
-  decodeTLV8,
-  decodeTLV8ToDict,
-} from '../../../../src/lib/apple-tv/tlv/decoder.js';
-
-describe('TLV8 Decoder', function () {
-  describe('decodeTLV8', function () {
-    it('should decode a single TLV8 item', function () {
-      const buffer = Buffer.from([0x01, 0x03, 0x42, 0x43, 0x44]);
-
-      const result = decodeTLV8(buffer);
-
-      expect(result).to.have.lengthOf(1);
-      expect(result[0].type).to.equal(0x01);
-      expect(result[0].data).to.deep.equal(Buffer.from([0x42, 0x43, 0x44]));
-    });
-
-    it('should decode multiple TLV8 items', function () {
-      const buffer = Buffer.from([
-        0x01, 0x01, 0x42, 0x02, 0x02, 0x43, 0x44, 0x03, 0x03, 0x45, 0x46, 0x47,
-      ]);
-
-      const result = decodeTLV8(buffer);
-
-      expect(result).to.have.lengthOf(3);
-
-      expect(result[0].type).to.equal(0x01);
-      expect(result[0].data).to.deep.equal(Buffer.from([0x42]));
-
-      expect(result[1].type).to.equal(0x02);
-      expect(result[1].data).to.deep.equal(Buffer.from([0x43, 0x44]));
-
-      expect(result[2].type).to.equal(0x03);
-      expect(result[2].data).to.deep.equal(Buffer.from([0x45, 0x46, 0x47]));
-    });
-
-    it('should handle empty buffer', function () {
-      const buffer = Buffer.alloc(0);
-
-      const result = decodeTLV8(buffer);
-
-      expect(result).to.deep.equal([]);
-    });
-
-    it('should decode fragmented data', function () {
-      const buffer = Buffer.from([
-        0x05,
-        0xff,
-        ...Buffer.alloc(255, 0xab),
-        0x05,
-        0x01,
-        0xab,
-      ]);
-
-      const result = decodeTLV8(buffer);
-
-      expect(result).to.have.lengthOf(2);
-      expect(result[0].type).to.equal(0x05);
-      expect(result[0].data).to.deep.equal(Buffer.alloc(255, 0xab));
-      expect(result[1].type).to.equal(0x05);
-      expect(result[1].data).to.deep.equal(Buffer.from([0xab]));
-    });
-
-    it('should throw error for insufficient data for type and length', function () {
-      const buffer = Buffer.from([0x01]);
-
-      expect(() => decodeTLV8(buffer)).to.throw(
-        TLV8Error,
-        'Invalid TLV8: insufficient data for type and length at offset 0',
-      );
-    });
-
-    it('should throw error for insufficient data for value', function () {
-      const buffer = Buffer.from([0x01, 0x05, 0x42, 0x43]);
-
-      expect(() => decodeTLV8(buffer)).to.throw(
-        TLV8Error,
-        'Invalid TLV8: insufficient data for value at offset 2',
-      );
-    });
-  });
-
-  describe('decodeTLV8ToDict', function () {
-    it('should decode to dictionary with unique types', function () {
-      const buffer = Buffer.from([
-        0x01, 0x01, 0x42, 0x02, 0x02, 0x43, 0x44, 0x03, 0x03, 0x45, 0x46, 0x47,
-      ]);
-
-      const result = decodeTLV8ToDict(buffer);
-
-      expect(result[0x01]).to.deep.equal(Buffer.from([0x42]));
-      expect(result[0x02]).to.deep.equal(Buffer.from([0x43, 0x44]));
-      expect(result[0x03]).to.deep.equal(Buffer.from([0x45, 0x46, 0x47]));
-    });
-
-    it('should concatenate data for repeated types', function () {
-      const buffer = Buffer.from([
-        0x05,
-        0xff,
-        ...Buffer.alloc(255, 0xab),
-        0x05,
-        0x01,
-        0xab,
-        0x06,
-        0x02,
-        0xcc,
-        0xdd,
-        0x05,
-        0x02,
-        0xee,
-        0xff,
-      ]);
-
-      const result = decodeTLV8ToDict(buffer);
-
-      expect(result[0x05]).to.deep.equal(
-        Buffer.concat([
-          Buffer.alloc(255, 0xab),
-          Buffer.from([0xab]),
-          Buffer.from([0xee, 0xff]),
-        ]),
-      );
-
-      expect(result[0x06]).to.deep.equal(Buffer.from([0xcc, 0xdd]));
-    });
-
-    it('should handle empty buffer', function () {
-      const buffer = Buffer.alloc(0);
-
-      const result = decodeTLV8ToDict(buffer);
-
-      expect(result).to.deep.equal({});
-    });
-
-    it('should throw error for malformed data', function () {
-      const buffer = Buffer.from([0x01, 0x05, 0x42]);
-
-      expect(() => decodeTLV8ToDict(buffer)).to.throw(TLV8Error);
-    });
-  });
-});

package/test/unit/apple-tv/tlv/encoder.spec.ts

@@ -1,91 +0,0 @@
-import { expect } from 'chai';
-
-import { TLV8_MAX_FRAGMENT_SIZE } from '../../../../src/lib/apple-tv/constants.js';
-import { encodeTLV8 } from '../../../../src/lib/apple-tv/tlv/encoder.js';
-import type { TLV8Item } from '../../../../src/lib/apple-tv/types.js';
-
-describe('TLV8 Encoder', function () {
-  describe('encodeTLV8', function () {
-    it('should encode a single TLV8 item', function () {
-      const items: TLV8Item[] = [
-        { type: 0x01, data: Buffer.from([0x42, 0x43, 0x44]) },
-      ];
-
-      const result = encodeTLV8(items);
-
-      expect(result).to.deep.equal(Buffer.from([0x01, 0x03, 0x42, 0x43, 0x44]));
-    });
-
-    it('should encode multiple TLV8 items', function () {
-      const items: TLV8Item[] = [
-        { type: 0x01, data: Buffer.from([0x42]) },
-        { type: 0x02, data: Buffer.from([0x43, 0x44]) },
-        { type: 0x03, data: Buffer.from([0x45, 0x46, 0x47]) },
-      ];
-
-      const result = encodeTLV8(items);
-
-      expect(result).to.deep.equal(
-        Buffer.from([
-          0x01, 0x01, 0x42, 0x02, 0x02, 0x43, 0x44, 0x03, 0x03, 0x45, 0x46,
-          0x47,
-        ]),
-      );
-    });
-
-    it('should handle empty items array', function () {
-      const items: TLV8Item[] = [];
-
-      const result = encodeTLV8(items);
-
-      expect(result).to.deep.equal(Buffer.alloc(0));
-    });
-
-    it('should fragment data exceeding TLV8_MAX_FRAGMENT_SIZE', function () {
-      const largeData = Buffer.alloc(256, 0xab);
-      const items: TLV8Item[] = [{ type: 0x05, data: largeData }];
-
-      const result = encodeTLV8(items);
-
-      expect(result.length).to.equal(
-        2 + TLV8_MAX_FRAGMENT_SIZE + 2 + (256 - TLV8_MAX_FRAGMENT_SIZE),
-      );
-      expect(result[0]).to.equal(0x05);
-      expect(result[1]).to.equal(TLV8_MAX_FRAGMENT_SIZE);
-      expect(result.subarray(2, 2 + TLV8_MAX_FRAGMENT_SIZE)).to.deep.equal(
-        Buffer.alloc(TLV8_MAX_FRAGMENT_SIZE, 0xab),
-      );
-      expect(result[2 + TLV8_MAX_FRAGMENT_SIZE]).to.equal(0x05);
-      expect(result[3 + TLV8_MAX_FRAGMENT_SIZE]).to.equal(
-        256 - TLV8_MAX_FRAGMENT_SIZE,
-      );
-      expect(result[4 + TLV8_MAX_FRAGMENT_SIZE]).to.equal(0xab);
-    });
-
-    it('should handle data exactly at TLV8_MAX_FRAGMENT_SIZE boundary', function () {
-      const boundaryData = Buffer.alloc(TLV8_MAX_FRAGMENT_SIZE, 0xef);
-      const items: TLV8Item[] = [{ type: 0x08, data: boundaryData }];
-
-      const result = encodeTLV8(items);
-
-      expect(result.length).to.equal(2 + TLV8_MAX_FRAGMENT_SIZE);
-      expect(result[0]).to.equal(0x08);
-      expect(result[1]).to.equal(TLV8_MAX_FRAGMENT_SIZE);
-      expect(result.subarray(2)).to.deep.equal(boundaryData);
-    });
-
-    it('should handle all possible type values', function () {
-      const items: TLV8Item[] = [
-        { type: 0x00, data: Buffer.from([0x00]) },
-        { type: 0x7f, data: Buffer.from([0x7f]) },
-        { type: 0xff, data: Buffer.from([0xff]) },
-      ];
-
-      const result = encodeTLV8(items);
-
-      expect(result).to.deep.equal(
-        Buffer.from([0x00, 0x01, 0x00, 0x7f, 0x01, 0x7f, 0xff, 0x01, 0xff]),
-      );
-    });
-  });
-});

package/test/unit/apple-tv/tlv/pairing-tlv.spec.ts

@@ -1,101 +0,0 @@
-import { expect } from 'chai';
-
-import { PairingDataComponentType } from '../../../../src/lib/apple-tv/constants.js';
-import { decodeTLV8ToDict } from '../../../../src/lib/apple-tv/tlv/decoder.js';
-import {
-  createPairVerificationData,
-  createSetupManualPairingData,
-} from '../../../../src/lib/apple-tv/tlv/pairing-tlv.js';
-
-describe('Pairing TLV', function () {
-  describe('createSetupManualPairingData', function () {
-    it('should create valid base64-encoded TLV8 data', function () {
-      const result = createSetupManualPairingData();
-
-      expect(result).to.be.a('string');
-      expect(() => Buffer.from(result, 'base64')).to.not.throw();
-    });
-
-    it('should contain correct METHOD and STATE values', function () {
-      const result = createSetupManualPairingData();
-      const decoded = Buffer.from(result, 'base64');
-      const tlvDict = decodeTLV8ToDict(decoded);
-
-      expect(tlvDict[PairingDataComponentType.METHOD]).to.exist;
-      expect(tlvDict[PairingDataComponentType.METHOD]).to.deep.equal(
-        Buffer.from([0x00]),
-      );
-
-      expect(tlvDict[PairingDataComponentType.STATE]).to.exist;
-      expect(tlvDict[PairingDataComponentType.STATE]).to.deep.equal(
-        Buffer.from([0x01]),
-      );
-    });
-
-    it('should always return the same value', function () {
-      const result1 = createSetupManualPairingData();
-      const result2 = createSetupManualPairingData();
-
-      expect(result1).to.equal(result2);
-    });
-  });
-
-  describe('createPairVerificationData', function () {
-    it('should create valid base64-encoded TLV8 data with public key', function () {
-      const publicKey = Buffer.from([0x01, 0x02, 0x03, 0x04]);
-      const result = createPairVerificationData(publicKey);
-
-      expect(result).to.be.a('string');
-      expect(() => Buffer.from(result, 'base64')).to.not.throw();
-    });
-
-    it('should contain correct STATE and PUBLIC_KEY values', function () {
-      const publicKey = Buffer.from([0xaa, 0xbb, 0xcc, 0xdd]);
-      const result = createPairVerificationData(publicKey);
-      const decoded = Buffer.from(result, 'base64');
-      const tlvDict = decodeTLV8ToDict(decoded);
-
-      expect(tlvDict[PairingDataComponentType.STATE]).to.exist;
-      expect(tlvDict[PairingDataComponentType.STATE]).to.deep.equal(
-        Buffer.from([0x01]),
-      );
-
-      expect(tlvDict[PairingDataComponentType.PUBLIC_KEY]).to.exist;
-      expect(tlvDict[PairingDataComponentType.PUBLIC_KEY]).to.deep.equal(
-        publicKey,
-      );
-    });
-
-    it('should handle typical X25519 public key (32 bytes)', function () {
-      const x25519PublicKey = Buffer.alloc(32, 0xef);
-      const result = createPairVerificationData(x25519PublicKey);
-      const decoded = Buffer.from(result, 'base64');
-      const tlvDict = decodeTLV8ToDict(decoded);
-
-      expect(tlvDict[PairingDataComponentType.PUBLIC_KEY]).to.deep.equal(
-        x25519PublicKey,
-      );
-    });
-
-    it('should handle large public key that requires fragmentation', function () {
-      const largeKey = Buffer.alloc(300, 0x42);
-      const result = createPairVerificationData(largeKey);
-      const decoded = Buffer.from(result, 'base64');
-      const tlvDict = decodeTLV8ToDict(decoded);
-
-      expect(tlvDict[PairingDataComponentType.PUBLIC_KEY]).to.deep.equal(
-        largeKey,
-      );
-    });
-
-    it('should produce different results for different public keys', function () {
-      const key1 = Buffer.from([0x01, 0x02, 0x03]);
-      const key2 = Buffer.from([0x04, 0x05, 0x06]);
-
-      const result1 = createPairVerificationData(key1);
-      const result2 = createPairVerificationData(key2);
-
-      expect(result1).to.not.equal(result2);
-    });
-  });
-});

package/test/unit/apple-tv/tlv/tlv-integration.spec.ts

@@ -1,146 +0,0 @@
-import { expect } from 'chai';
-
-import { TLV8_MAX_FRAGMENT_SIZE } from '../../../../src/lib/apple-tv/constants.js';
-import {
-  decodeTLV8,
-  decodeTLV8ToDict,
-} from '../../../../src/lib/apple-tv/tlv/decoder.js';
-import { encodeTLV8 } from '../../../../src/lib/apple-tv/tlv/encoder.js';
-import type { TLV8Item } from '../../../../src/lib/apple-tv/types.js';
-
-describe('TLV8 Integration Tests', function () {
-  describe('Round-trip encoding and decoding', function () {
-    it('should maintain data integrity for simple items', function () {
-      const originalItems: TLV8Item[] = [
-        { type: 0x01, data: Buffer.from([0x42, 0x43, 0x44]) },
-        { type: 0x02, data: Buffer.from([0x45, 0x46]) },
-        { type: 0x03, data: Buffer.from([0x47]) },
-      ];
-
-      const encoded = encodeTLV8(originalItems);
-      const decoded = decodeTLV8(encoded);
-
-      expect(decoded).to.deep.equal(originalItems);
-    });
-
-    it('should handle fragmented data round-trip', function () {
-      const largeData = Buffer.alloc(512);
-      for (let i = 0; i < 512; i++) {
-        largeData[i] = i % 256;
-      }
-
-      const originalItems: TLV8Item[] = [{ type: 0x05, data: largeData }];
-
-      const encoded = encodeTLV8(originalItems);
-      const decoded = decodeTLV8(encoded);
-
-      expect(decoded).to.have.lengthOf(3);
-      expect(decoded[0].type).to.equal(0x05);
-      expect(decoded[1].type).to.equal(0x05);
-      expect(decoded[2].type).to.equal(0x05);
-
-      const reassembled = Buffer.concat(decoded.map((item) => item.data));
-      expect(reassembled).to.deep.equal(largeData);
-    });
-
-    it('should handle mixed fragmented and non-fragmented items', function () {
-      const smallData = Buffer.from([0xaa, 0xbb]);
-      const largeData = Buffer.alloc(300, 0xcc);
-      const mediumData = Buffer.alloc(100, 0xdd);
-
-      const originalItems: TLV8Item[] = [
-        { type: 0x01, data: smallData },
-        { type: 0x02, data: largeData },
-        { type: 0x03, data: mediumData },
-      ];
-
-      const encoded = encodeTLV8(originalItems);
-      const decoded = decodeTLV8(encoded);
-
-      expect(decoded).to.have.lengthOf(4);
-
-      expect(decoded[0]).to.deep.equal({ type: 0x01, data: smallData });
-
-      expect(decoded[1].type).to.equal(0x02);
-      expect(decoded[1].data.length).to.equal(255);
-      expect(decoded[2].type).to.equal(0x02);
-      expect(decoded[2].data.length).to.equal(45);
-
-      expect(decoded[3]).to.deep.equal({ type: 0x03, data: mediumData });
-    });
-  });
-
-  describe('Round-trip with decodeTLV8ToDict', function () {
-    it('should correctly reassemble fragmented data in dictionary', function () {
-      const largeData = Buffer.alloc(512, 0xee);
-      const originalItems: TLV8Item[] = [{ type: 0x10, data: largeData }];
-
-      const encoded = encodeTLV8(originalItems);
-      const decodedDict = decodeTLV8ToDict(encoded);
-
-      expect(decodedDict[0x10]).to.deep.equal(largeData);
-    });
-
-    it('should handle multiple types with fragmentation', function () {
-      const data1 = Buffer.alloc(300, 0x11);
-      const data2 = Buffer.alloc(50, 0x22);
-      const data3 = Buffer.alloc(400, 0x33);
-
-      const originalItems: TLV8Item[] = [
-        { type: 0x01, data: data1 },
-        { type: 0x02, data: data2 },
-        { type: 0x03, data: data3 },
-      ];
-
-      const encoded = encodeTLV8(originalItems);
-      const decodedDict = decodeTLV8ToDict(encoded);
-
-      expect(decodedDict[0x01]).to.deep.equal(data1);
-      expect(decodedDict[0x02]).to.deep.equal(data2);
-      expect(decodedDict[0x03]).to.deep.equal(data3);
-    });
-  });
-
-  describe('Edge cases', function () {
-    it('should handle maximum size data at boundary', function () {
-      const boundaryData = Buffer.alloc(TLV8_MAX_FRAGMENT_SIZE);
-      for (let i = 0; i < TLV8_MAX_FRAGMENT_SIZE; i++) {
-        boundaryData[i] = i % 256;
-      }
-
-      const items: TLV8Item[] = [{ type: 0x42, data: boundaryData }];
-
-      const encoded = encodeTLV8(items);
-      const decoded = decodeTLV8(encoded);
-
-      expect(decoded).to.have.lengthOf(1);
-      expect(decoded[0]).to.deep.equal(items[0]);
-    });
-
-    it('should handle empty items array', function () {
-      const items: TLV8Item[] = [];
-
-      const encoded = encodeTLV8(items);
-      const decoded = decodeTLV8(encoded);
-      const decodedDict = decodeTLV8ToDict(encoded);
-
-      expect(encoded).to.deep.equal(Buffer.alloc(0));
-      expect(decoded).to.deep.equal([]);
-      expect(decodedDict).to.deep.equal({});
-    });
-
-    it('should preserve exact byte sequences through round-trip', function () {
-      const problematicData = Buffer.from([
-        0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x01, 0x02, 0x03, 0x00, 0xff, 0x00,
-        0xff,
-      ]);
-
-      const items: TLV8Item[] = [{ type: 0x77, data: problematicData }];
-
-      const encoded = encodeTLV8(items);
-      const decoded = decodeTLV8(encoded);
-
-      expect(decoded[0].data).to.deep.equal(problematicData);
-    });
-  });
-});