@irdk/usbmux 0.2.0

package/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Sterling DeMille <sterlingdemille@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,298 @@
+# node-usbmux
+
+Node-usbmux is an iOS usbmuxd client library inspired by [tcprelay.py](https://github.com/rcg4u/iphonessh)
+
+
+## What is usbmuxd?
+
+All USB communication with iOS devices (including communication from iTunes) is handled by the usbmux daemon. When a device is plugged in, usbmuxd connects to it and acts as a middleman for communicating with the device, multiplexing TCP like connections to sockets on the device. (USB multiplexer = usbmux)
+
+
+## What does node-usbmux do?
+
+Node-usbmux provides tcp connections to sockets on iOS devices via USB.
+
+Installed globally, node-usbmux's CLI lets you create TCP relays that tunnel traffic from localhost through USB to the device. (useful for accessing ssh or veency over usb)
+
+The obvious advantages of a USB connection over a wifi connection are speed, not having to be on the same network, device doesn't need to be unlocked to maintain connection, etc.
+
+
+## Install
+
+```
+npm install [-g] usbmux
+```
+
+Prerequisites: iTunes or [libimobiledevice](http://www.libimobiledevice.org/)
+
+
+## CLI Usage
+
+Node-usbmux adds the `irelay` command:
+
+```sh
+# Relay localhost:2222 to port 22 on device through USB
+# (so you can ssh root@localhost -p 2222)
+irelay 22:2222
+
+# Relay multiple port pairs, extra verbose mode
+irelay 22:2222 1234:1234 -vv
+
+# Specify a device with -u, --udid option
+irelay 22:2222 1234:1234 --udid=12345abcde12345abcde12345abcde12345abcde
+
+# Show UDIDs of attached devices
+irelay listen
+
+# More info
+irelay --help
+```
+
+
+## Module Usage
+
+```javascript
+var usbmux = require('usbmux');
+
+// usbmux.Relay()
+// usbmux.createListener()
+// usbmux.getTunnel()
+// usbmux.devices
+
+```
+
+### new usbmux.Relay(devicePort, relayPort[, options])
+Create a tcp relay that pipes a local port to an attached iOS device port.
+
+- devicePort {integer} - Destination port on device
+- relayPort {integer} - Local port to start tcp server on
+- options {object}
+  - options.timeout - Search time (in ms) before emitting warning
+  - options.udid - UDID of specific device to connect to
+
+```javascript
+// Ex:
+var relay = new usbmux.Relay(22, 2222)
+  .on('error', function(err) {})
+  .on('ready', function(udid) {
+    // A USB device is connected and ready to be relayed to
+  })
+  ...
+
+// you can stop the relay when done
+relay.stop();
+```
+
+##### EVENTS:
+
+**error** - _err {Error}_ <br/>
+Fires when there is an error:
+- with the relay's TCP server (like EADDRINUSE), or
+- from usbmuxd
+
+**warning** - _err {Error}_ <br/>
+When a relay starts it will check for connected devices. If there isn't a device ready within the time limit (default 1s), the relay will issue a warning (but will continue to search for and use connected devices).
+
+**ready** - _UDID {string}_ <br/>
+Fires when a connected device is first detected by the relay
+
+**attached** - _UDID {string}_ <br/>
+Fires when a USB device is attached (or first detected)
+
+**detached** - _UDID {string}_ <br/>
+Fires when a USB device is detached
+
+**connect** <br/>
+Fires when a new connection is made to the relay's TCP server
+
+**disconnect** <br/>
+Fires when a connection to the relay's TCP server is ended
+
+**close** <br/>
+Fires when the relay's TCP server is closes (the net.Server event)
+
+
+### usbmux.createListener()
+Connects to usbmuxd and listens for iOS devices <br/>
+Returns a normal net.Socket connection with two added events:
+
+```javascript
+// Ex:
+var listener = new usbmux.createListener()
+  .on('error', function(err) {})
+  .on('attached', function(udid) {})
+  .on('detached', function(udid) {});
+
+// listener is just a net.Socket connection to usbmuxd
+assert(listener instanceof net.Socket);
+listener.end();
+```
+
+##### EVENTS:
+
+**attached** - _UDID {string}_ <br/>
+Fires when a USB device is attached (or first detected)
+
+**detached** - _UDID {string}_ <br/>
+Fires when a USB device is detached
+
+
+### usbmux.getTunnel(devicePort[, options])
+Get a tunneled connection to port on device within a timeout period <br/>
+Returns a promise that resolves a net.Socket connection to the requested port
+
+- devicePort {integer} - Destination port on device
+- options {object}
+  - options.timeout - Search time (in ms) before failing with error
+  - options.udid - UDID of specific device to connect to
+
+```javascript
+// Ex:
+usbmux.getTunnel(1234)
+  .then(function(tunnel) {
+    // tunnel is just a net.Socket connection to the device port
+    // you can write / .on('data') it like normal
+    assert(tunnel instanceof net.Socket);
+    tunnel.write('hello');
+  })
+  .catch(function(err) {
+    console.err(err);
+    // "Tunnel failed, Err #3: Port isn't available or open"
+  });
+```
+
+
+### usbmux.devices
+Currently connected USB devices, keyed by UDIDs
+
+```javascript
+// Ex:
+listener.on('attached', function(udid) {
+  console.log(usbmux.devices[udid]);
+});
+
+// {
+//   ConnectionType: 'USB',
+//   DeviceID: 19,
+//   LocationID: 0,
+//   ProductID: 4776,
+//   SerialNumber: '22226dd59aaac687f555f8521f8ffddac32d394b'
+// }
+```
+
+
+## Tests
+
+```
+npm test
+```
+
+Some of the tests require an attached device since that was easier than implementing an entire mock usbmuxd. These tests connect to device port 22 by default, but you can set a different port with the env var `TESTPORT`.
+
+
+## How does usbmuxd work?
+
+Usbmuxd operates over TCP and accepts two different requests: `listen` and `connect`.
+
+A `listen` request asks usbmuxd to turn the current tcp connection into a dedicated notification pipe, sending notifications about devices as they are attached and detached.
+
+A `connect` request asks usbmuxd to turn the current tcp connection into a tunneled connection to a port on the device. Connect requests need a DeviceID, which you get from the listener notifications.
+
+Each request must be sent in a new tcp connection, i.e. you can't send a listen request and a connect request in the same connection. Because of this, you'll always need at least two connections open, one listening for device status and one actually connecting to devices.
+
+
+## Usbmuxd protocol
+
+Usbmux messages are composed of a header and a payload plist.
+
+There used to be a [binary](https://www.theiphonewiki.com/wiki/Usbmux) version of the protocol, but it isn't used anymore. There is no documentation for usbmuxd, so this understanding is borrowed from looking at the implementation in [tcprelay.py](https://github.com/rcg4u/iphonessh).
+
+##### Header:
+
+Four 32-bit unsigned LE integers (in order):
+<br/> _Length:_ length of the header + plist (16 + plist.length)
+<br/> _Version:_ 0 for binary version, 1 for plist version
+<br/> _Request:_ always 8 (taken from tcprelay.py)
+<br/> _Tag:_ always 1 (taken from tcprelay.py)
+
+##### Listen:
+
+```plist
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>MessageType</key>
+    <string>Listen</string>
+    <key>ClientVersionString</key>
+    <string>node-usbmux</string>
+    <key>ProgName</key>
+    <string>node-usbmux</string>
+  </dict>
+</plist>
+```
+
+##### Connect:
+
+```plist
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>MessageType</key>
+    <string>Connect</string>
+    <key>ClientVersionString</key>
+    <string>node-usbmux</string>
+    <key>ProgName</key>
+    <string>node-usbmux</string>
+    <key>DeviceID</key>
+    <integer>3</integer>
+    <key>PortNumber</key>
+    <integer>5632</integer>
+  </dict>
+</plist>
+```
+
+It's important to note that the PortNumber must be byte-swapped to be network-endian. So port 22 in this example ends up being sent as 5632.
+
+##### Response:
+
+```plist
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>MessageType</key>
+    <string>Result</string>
+    <key>Number</key>
+    <integer>0</integer>
+  </dict>
+</plist>
+```
+
+The `Number` field indicates status. 0 is success, other numbers indicate an error:
+- 0: Success
+- 2: Device requested isn't connected
+- 3: Port requested isn't available \ open
+- 5: Malformed request
+
+
+## License
+
+The MIT License (MIT)
+
+Copyright (c) 2015 Sterling DeMille &lt;sterlingdemille@gmail.com&gt;
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/bin/cli.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+import * as usbmux from "../dist/usbmux.js";
+
+var argv = yargs(hideBin(process.argv))
+  .usage("Usage: irelay <port:port> [options]")
+  .demand(1)
+  .option("u", {
+    alias: "udid",
+    describe: "Specify device to connect to by UDID",
+    type: "string",
+  })
+  .command("listen", "Listen for attached devices")
+  .option("v", {
+    alias: "verbose",
+    describe: "Output debugging info",
+    count: "verbose",
+  })
+  .help("h")
+  .alias("h", "help")
+  .example("irelay 22:2222", "Pipe localhost:2222 to port 22 on device")
+  .example("irelay 22:2222 1234:1234", "Pipe multiple ports")
+  .example("irelay listen", "Show UDIDs of attached devices").argv;
+
+/**
+ * Shows debugging info only for verbosity = 1
+ * @param {*...} arguments
+ */
+function info() {
+  if (argv.verbose !== 1) return;
+  var args = Array.prototype.slice.call(arguments);
+  if (!args[args.length - 1]) args.pop(); // if last arg is undefined, remove it
+  console.log.apply(console, args);
+}
+
+/**
+ * Panic!
+ * @param {*...} arguments
+ */
+function panic() {
+  console.error("");
+  console.error.apply(console, arguments);
+  console.error("");
+  process.exit();
+}
+
+/**
+ * Error handler for listener and relay
+ * @param  {Error} err
+ */
+function onErr(err) {
+  // local port is in use
+  if (err.code === "EADDRINUSE") {
+    panic("Local port is in use \nFailing...");
+  }
+  // usbmux not there
+  if (err.code === "ECONNREFUSED" || err.code === "EADDRNOTAVAIL") {
+    panic("Usbmuxd not found at", usbmux.address, "\nFailing...");
+  }
+  // other
+  panic("%s \nFailing...", err);
+}
+
+/**
+ * Listen for and report connected devices
+ */
+function listenForDevices() {
+  console.log("Listening for connected devices... \n");
+
+  usbmux
+    .createListener()
+    .on("error", onErr)
+    .on("attached", function (udid) {
+      console.log("Device found: ", udid);
+    })
+    .on("detached", function (udid) {
+      console.log("Device removed: ", udid);
+    });
+}
+
+/**
+ * Parse port arg string into array of ints (ie, '22:2222' -> [22, 2222])
+ * @param  {string} arg
+ * @return {integer[]}
+ */
+function parsePorts(arg) {
+  // coerce and split
+  var ports = ("" + arg).split(":");
+  if (ports.length !== 2) {
+    panic("Error parsing ports.");
+  }
+
+  // parse ints
+  var devicePort = Number(ports[0] === "" ? NaN : ports[0]),
+    relayPort = Number(ports[1] === "" ? NaN : ports[1]);
+
+  // NaN check em
+  if (devicePort !== devicePort || relayPort !== relayPort) {
+    panic("Error parsing ports.");
+  }
+
+  return [devicePort, relayPort];
+}
+
+/**
+ * Start a new relay from a pair of given ports
+ * @param  {integer[]} portPair - [devicePort, relayPort]
+ */
+function startRelay(portPair) {
+  var devicePort = portPair[0],
+    relayPort = portPair[1];
+
+  console.log(
+    "Starting relay from local port: %s -> device port: %s",
+    relayPort,
+    devicePort,
+  );
+
+  new usbmux.Relay(devicePort, relayPort, { udid: argv.udid })
+    .on("error", onErr)
+    .on("warning", console.log.bind(console, "Warning: device not found..."))
+    .on("ready", info.bind(this, "Device ready: "))
+    .on("attached", info.bind(this, "Device attached: "))
+    .on("detached", info.bind(this, "Device detached: "))
+    .on("connect", info.bind(this, "New connection to relay started."))
+    .on("disconnect", info.bind(this, "Connection to relay closed."))
+    .on("close", info.bind(this, "Relay has closed."));
+}
+
+// Set debugging env vars if extra verbose (needs to be set before requiring)
+if (argv.verbose >= 2) process.env.DEBUG = "usbmux:*";
+
+// Either listen or start relays
+argv._[0] === "listen"
+  ? listenForDevices()
+  : argv._.map(parsePorts).forEach(startRelay);

package/lib/usbmux.ts

@@ -0,0 +1,542 @@
+import net from "node:net";
+import { EventEmitter } from "events";
+
+import plist from "plist";
+
+/**
+ * Debugging
+ * set with DEBUG=usbmux:* env variable
+ *
+ * on windows cmd set with: cmd /C "SET DEBUG=usbmux:* && node script.js"
+ */
+import bug from "debug";
+const debug = {
+  relay: bug("usbmux:relay"),
+  listen: bug("usbmux:listen"),
+  connect: bug("usbmux:connect"),
+};
+
+type Device = {
+  ConnectionType: string;
+  DeviceID: DeviceId;
+  LocationID: number;
+  ProductID: number;
+  SerialNumber: string;
+};
+/**
+ * Keep track of connected devices
+ *
+ * Maps device UDID to device properties, ie:
+ * '22226dd59aaac687f555f8521f8ffddac32d394b': {
+ *   ConnectionType: 'USB',
+ *   DeviceID: 19,
+ *   LocationID: 0,
+ *   ProductID: 4776,
+ *   SerialNumber: '22226dd59aaac687f555f8521f8ffddac32d394b'
+ * }
+ *
+ * Devices are added and removed to this obj only by createListener()
+ *
+ */
+export const devices: Record<string, Device> = {};
+
+/**
+ * usbmuxd address
+ *
+ * OSX usbmuxd listens on a unix socket at /var/run/usbmuxd
+ * Windows usbmuxd listens on port 27015
+ *
+ * libimobiledevice[1] looks like it operates at /var/run/usbmuxd too, but if
+ * your usbmuxd is listening somewhere else you'll need to set this manually.
+ *
+ * [1] github.com/libimobiledevice/usbmuxd
+ */
+export const address =
+  process.platform === "win32"
+    ? { port: 27015, family: 4 }
+    : { path: "/var/run/usbmuxd" };
+
+/**
+ * Exposes methods for dealing with usbmuxd protocol messages (send/receive)
+ *
+ * The usbmuxd message protocol has 2 versions. V1 doesn't look like its used
+ * anymore. V2 is a header + plist format like this:
+ *
+ * Header:
+ *   UInt32LE Length  - is the length of the header + plist (16 + plist.length)
+ *   UInt32LE Version - is 0 for binary version, 1 for plist version
+ *   UInt32LE Request - is always 8, for plist? from rcg4u/iphonessh
+ *   UInt32LE Tag     - is always 1, ? from rcg4u/iphonessh
+ *
+ * Plist:
+ *   <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+ *     "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+ *   <plist version="1.0">
+ *     <dict>
+ *       <key>MessageType</key>
+ *       <string>Listen</string>
+ *       <key>ClientVersionString</key>
+ *       <string>node-usbmux</string>
+ *       <key>ProgName</key>
+ *       <string>node-usbmux</string>
+ *     </dict>
+ *   </plist>
+ *
+ * References:
+ * - https://github.com/rcg4u/iphonessh
+ * - https://www.theiphonewiki.com/wiki/Usbmux (binary protocol)
+ */
+
+type DeviceId = number;
+type UsbMuxPlist =
+  | {
+      MessageType: "Result";
+      Number: number;
+    }
+  | {
+      MessageType: "Attached";
+      Number: number;
+      Properties: Device;
+    }
+  | { MessageType: "Detached"; Number: number; DeviceID: DeviceId };
+
+export const protocol = (function () {
+  /**
+   * Pack a request object into a buffer for usbmuxd
+   */
+  function pack(payload_obj: plist.PlistValue): Buffer {
+    const payload_plist = plist.build(payload_obj);
+    const payload_buf = Buffer.from(payload_plist);
+
+    var header = {
+      len: payload_buf.length + 16,
+      version: 1,
+      request: 8,
+      tag: 1,
+    };
+
+    const header_buf = Buffer.alloc(16);
+    header_buf.fill(0);
+    header_buf.writeUInt32LE(header.len, 0);
+    header_buf.writeUInt32LE(header.version, 4);
+    header_buf.writeUInt32LE(header.request, 8);
+    header_buf.writeUInt32LE(header.tag, 12);
+
+    return Buffer.concat([header_buf, payload_buf]);
+  }
+
+  /**
+   * Swap endianness of a 16bit value
+   */
+  function byteSwap16(val: number) {
+    return ((val & 0xff) << 8) | ((val >> 8) & 0xff);
+  }
+
+  /**
+   * Listen request
+   */
+  const listen: Buffer = pack({
+    MessageType: "Listen",
+    ClientVersionString: "node-usbmux",
+    ProgName: "node-usbmux",
+  });
+
+  /**
+   * Connect request
+   *
+   * Note: PortNumber must be network-endian, so it gets byte swapped here
+   */
+  function connect(deviceID: DeviceId, port: number): Buffer {
+    return pack({
+      MessageType: "Connect",
+      ClientVersionString: "node-usbmux",
+      ProgName: "node-usbmux",
+      DeviceID: deviceID,
+      PortNumber: byteSwap16(port),
+    });
+  }
+
+  /**
+   * Creates a function that will parse messages from data events
+   *
+   * net.Socket data events sometimes break up the incoming message across
+   * multiple events, making it necessary to combine them. This parser function
+   * assembles messages using the length given in the message header and calls
+   * the onComplete callback as new messages are assembled. Sometime multiple
+   * messages will be within a single data buffer too.
+   */
+  function makeParser(
+    onComplete: (msg: UsbMuxPlist) => void,
+  ): (data: Buffer) => void {
+    // Store status (remaining message length & msg text) of partial messages
+    // across multiple calls to the parse function
+    let len: number, msg: string;
+
+    return function parse(data: Buffer) {
+      // Check if this data represents a new incoming message or is part of an
+      // existing partially completed message
+      if (!len) {
+        // The length of the message's body is the total length (the first
+        // UInt32LE in the header) minus the length of header itself (16)
+        len = data.readUInt32LE(0) - 16;
+        msg = "";
+
+        // If there is data beyond the header then continue adding data to msg
+        data = data.subarray(16);
+        if (!data.length) return;
+      }
+
+      // Add in data until our remaining length is used up
+      var body = data.subarray(0, len);
+      msg += body;
+      len -= body.length;
+
+      // If msg is finished, convert plist to obj and run callback
+      if (len === 0) onComplete(plist.parse(msg) as UsbMuxPlist);
+
+      // If there is any data left over that means there is another message
+      // so we need to run this parse fct again using the rest of the data
+      data = data.subarray(body.length);
+      if (data.length) parse(data);
+    };
+  }
+
+  // Exposed methods
+  return {
+    listen: listen,
+    connect: connect,
+    makeParser: makeParser,
+  };
+})();
+
+/**
+ * Custom usbmuxd error
+ *
+ * There's no documentation for usbmuxd responses, but I think I've figured
+ * out these result numbers:
+ * 0 - Success
+ * 2 - Device requested isn't connected
+ * 3 - Port requested isn't available \ open
+ * 5 - Malformed request
+ */
+export class UsbmuxdError extends Error {
+  number: number;
+
+  constructor(message: string, number: number) {
+    if (number) {
+      message += ", Err #" + number;
+    }
+    if (number === 2) message += ": Device isn't connected";
+    if (number === 3) message += ": Port isn't available or open";
+    if (number === 5) message += ": Malformed request";
+    super(message);
+    if (number) {
+      this.number = number;
+    }
+  }
+}
+
+/**
+ * Connects to usbmuxd and listens for ios devices
+ *
+ * This connection stays open, listening as devices are plugged/unplugged and
+ * cant be upgraded into a tcp tunnel. You have to start a second connection
+ * with connect() to actually make tunnel.
+ *
+ * @return {net.Socket} - Socket with 2 bolted on events, attached & detached:
+ *
+ * Fires when devices are plugged in or first found by the listener
+ * @event net.Socket#attached
+ * @type {string} - UDID
+ *
+ * Fires when devices are unplugged
+ * @event net.Socket#detached
+ * @type {string} - UDID
+ */
+export function createListener(): net.Socket {
+  const conn = net.connect(address);
+  const req = protocol.listen;
+
+  /**
+   * Handle complete messages from usbmuxd
+   * @function
+   */
+  const parse = protocol.makeParser(function onMsgComplete(msg) {
+    debug.listen("Response: \n%o", msg);
+
+    // first response always acknowledges / denies the request:
+    if (msg.MessageType === "Result" && msg.Number !== 0) {
+      conn.emit("error", new UsbmuxdError("Listen failed", msg.Number));
+      conn.end();
+    }
+
+    // subsequent responses report on connected device status:
+    if (msg.MessageType === "Attached") {
+      devices[msg.Properties.SerialNumber] = msg.Properties;
+      conn.emit("attached", msg.Properties.SerialNumber);
+    }
+
+    if (msg.MessageType === "Detached") {
+      // given msg.DeviceID, find matching device and remove it
+      Object.keys(devices).forEach(function (key) {
+        if (devices[key].DeviceID === msg.DeviceID) {
+          conn.emit("detached", devices[key].SerialNumber);
+          delete devices[key];
+        }
+      });
+    }
+  });
+
+  debug.listen("Request: \n%s", req.subarray(16).toString());
+
+  conn.on("data", parse);
+  process.nextTick(function () {
+    conn.write(req);
+  });
+
+  return conn;
+}
+
+/**
+ * Connects to a device through usbmuxd for a tunneled tcp connection
+ */
+export function connect(
+  deviceID: DeviceId,
+  devicePort: number,
+): Promise<net.Socket> {
+  return new Promise(function (resolve, reject) {
+    const conn = net.connect(address),
+      req = protocol.connect(deviceID, devicePort);
+
+    /**
+     * Handle complete messages from usbmuxd
+     * @function
+     */
+    var parse = protocol.makeParser(function onMsgComplete(msg) {
+      debug.connect("Response: \n%o", msg);
+
+      if (msg.MessageType === "Result" && msg.Number === 0) {
+        conn.removeListener("data", parse);
+        resolve(conn);
+        return;
+      }
+
+      // anything other response means it failed
+      reject(new UsbmuxdError("Tunnel failed", msg.Number));
+      conn.end();
+    });
+
+    debug.connect("Request: \n%s", req.subarray(16).toString());
+
+    conn.on("data", parse);
+    process.nextTick(function () {
+      conn.write(req);
+    });
+  });
+}
+
+type RelayOpts = {
+  timeout?: number;
+  udid?: string;
+};
+/**
+ * Creates a new tcp relay to a port on connected usb device
+ *
+ * @constructor
+ * @param {integer} devicePort          - Port to connect to on device
+ * @param {integer} relayPort           - Local port that will listen as relay
+ * @param {object}  [opts]              - Options
+ * @param {integer} [opts.timeout=1000] - Search time (ms) before warning
+ * @param {string}  [opts.udid]         - UDID of specific device to connect to
+ *
+ * @public
+ */
+export class Relay extends EventEmitter {
+  _devicePort: number;
+  _relayPort: number;
+  _udid?: string;
+  constructor(devicePort: number, relayPort: number, opts: RelayOpts) {
+    super();
+    this._devicePort = devicePort;
+    this._relayPort = relayPort;
+
+    opts = opts || {};
+    this._udid = opts.udid;
+
+    this._startListener(opts.timeout || 1000);
+    this._startServer();
+  }
+  /**
+   * Stops the relay
+   */
+  stop = function () {
+    this._listener.end();
+    this._server.close();
+  };
+  /**
+   * Debugging wrapper for emits
+   */
+  _emit = function (event: string, data: any) {
+    debug.relay("Emit: %s", event + (data ? ", Data: " + data : ""));
+    this.emit(event, data);
+  };
+  /**
+   * Starts a usbmuxd listener
+   *
+   * Relay will start searching for connected devices and issue a warning if a
+   * device is not found within the timeout. If/when a device is found, it will
+   * emit a ready event.
+   *
+   * Listener events (attach, detach, error) are passed through as relay events.
+   */
+  _startListener = function (timeout: number) {
+    var _this = this;
+
+    var timer = setTimeout(function () {
+      // no UDID was given and no devices found yet
+      if (!_this._udid && !Object.keys(devices).length) {
+        _this._emit("warning", new Error("No devices connected"));
+      }
+      // UDID was given, but that device is not connected
+      if (_this._udid && !devices[_this._udid]) {
+        _this._emit("warning", new Error("Requested device not connected"));
+      }
+    }, timeout || 1000);
+
+    function readyCheck(udid: string) {
+      if (_this._udid && _this._udid !== udid) return;
+      _this._emit("ready", udid);
+      _this._listener.removeListener("attached", readyCheck);
+      clearTimeout(timer);
+    }
+
+    this._listener = createListener()
+      .on("attached", readyCheck)
+      .on("attached", _this._emit.bind(this, "attached"))
+      .on("detached", _this._emit.bind(this, "detached"))
+      .on("error", _this._emit.bind(this, "error"));
+  };
+  /**
+   * Start local TCP server that will pipe to the usbmuxd tunnel
+   *
+   * Server events (close and error) are passed through as relay events.
+   */
+  _startServer = function () {
+    var _this = this;
+    this._server = net
+      .createServer(this._handler.bind(this))
+      .on("close", _this._emit.bind(this, "close"))
+      .on("error", function (err) {
+        _this._listener.end();
+        _this._emit("error", err);
+      })
+      .listen(this._relayPort);
+  };
+  /**
+   * Handle & pipe connections from local server
+   *
+   * Fires error events and connection begin / disconnect events
+   */
+  _handler = function (conn: net.Socket) {
+    // emit error if there are no devices connected
+    if (!Object.keys(devices).length) {
+      this._emit("error", new Error("No devices connected"));
+      conn.end();
+      return;
+    }
+
+    // emit error if a udid was specified but that device isn't connected
+    if (this._udid && !devices[this._udid]) {
+      this._emit("error", new Error("Requested device not connected"));
+      conn.end();
+      return;
+    }
+
+    // Use specified device or choose one from available devices
+    var _this = this,
+      udid = this._udid || Object.keys(devices)[0],
+      deviceID = devices[udid].DeviceID;
+
+    connect(deviceID, this._devicePort)
+      .then(function (tunnel) {
+        // pipe connection & tunnel together
+        conn.pipe(tunnel).pipe(conn);
+
+        _this._emit("connect");
+
+        conn.on("end", function () {
+          _this._emit("disconnect");
+          tunnel.end();
+          conn.end();
+        });
+
+        conn.on("error", function () {
+          tunnel.end();
+          conn.end();
+        });
+      })
+      .catch(function (err) {
+        _this._emit("error", err);
+        conn.end();
+      });
+  };
+}
+
+/**
+ * Find a device (specified or not) within a timeout
+ *
+ * Usbmuxd has IDs it assigned to devices as they are plugged in. The IDs
+ * change as devices are unpplugged and plugged back in, so even if we have a
+ * UDID we need to get the current ID from usbmuxd before we can connect.
+ */
+export function findDevice(opts: RelayOpts): Promise<number> {
+  return new Promise(function (resolve, reject) {
+    var listener = createListener();
+    opts = opts || {};
+
+    var timer = setTimeout(function () {
+      listener.end();
+      opts.udid
+        ? reject(new Error("Requested device not connected"))
+        : reject(new Error("No devices connected"));
+    }, opts.timeout || 1000);
+
+    listener.on("attached", function (udid) {
+      if (opts.udid && opts.udid !== udid) return;
+      listener.end();
+      clearTimeout(timer);
+      resolve(devices[udid].DeviceID);
+    });
+  });
+}
+
+/**
+ * Get a tunneled connection to a device (specified or not) within a timeout
+ */
+export async function getTunnel(
+  devicePort: number,
+  opts: RelayOpts,
+): Promise<net.Socket> {
+  opts = opts || {};
+  let udid: string;
+  let deviceID: DeviceId;
+
+  // If UDID was specified and that device's DeviceID is known, connect to it
+  if (opts.udid && devices[opts.udid]) {
+    deviceID = devices[opts.udid].DeviceID;
+    return connect(deviceID, devicePort);
+  }
+
+  // If no UDID given, connect to any known device
+  // (random because no key order, but there's probably only 1 option anyways)
+  if (!opts.udid && Object.keys(devices).length) {
+    udid = Object.keys(devices)[0];
+    deviceID = devices[udid].DeviceID;
+    return connect(deviceID, devicePort);
+  }
+
+  // - Try to find and connect to requested the device (given opts.UDID),
+  // - or find and connect to any device (no opts.UDID given)
+  const deviceID_2 = await findDevice(opts);
+  return await connect(deviceID_2, devicePort);
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@irdk/usbmux",
+  "version": "0.2.0",
+  "description": "iOS usbmuxd client library",
+  "main": "./dist/usbmux.cjs",
+  "module": "./dist/usbmux.js",
+  "types": "./dist/usbmux.d.ts",
+  "type": "module",
+  "bin": {
+    "irelay": "./bin/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "tsup": {
+    "entry": [
+      "./lib/usbmux.ts"
+    ],
+    "target": [
+      "node18",
+      "es2020"
+    ],
+    "splitting": false,
+    "sourcemap": true,
+    "clean": true,
+    "dts": true,
+    "format": [
+      "cjs",
+      "esm"
+    ]
+  },
+  "scripts": {
+    "test": "./node_modules/.bin/mocha ./test/tests.cjs",
+    "build": "tsup",
+    "dev": "tsup --watch"
+  },
+  "keywords": [
+    "usbmuxd",
+    "ios",
+    "irelay"
+  ],
+  "author": {
+    "name": "Sterling DeMille",
+    "email": "sterlingdemille+npm@gmail.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/demille/node-usbmux.git"
+  },
+  "dependencies": {
+    "debug": "^4.3.6",
+    "plist": "^3.1.0",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.12",
+    "@types/plist": "^3.0.5",
+    "mocha": "^10.7.0",
+    "rewire": "^7.0.0",
+    "should": "^13.2.3",
+    "tsup": "^8.0.1",
+    "typescript": "^5.8.2"
+  },
+  "packageManager": "yarn@1.22.19+sha1.4ba7fc5c6e704fce2066ecbfb0b0d8976fe62447"
+}

package/test/tests.cjs

@@ -0,0 +1,328 @@
+var net = require("net"),
+  should = require("should"),
+  rewire = require("rewire");
+
+var usbmux = rewire("../dist/usbmux.cjs"),
+  protocol = usbmux.__get__("protocol");
+
+// tests connect to port 22 on attached ios device (or set env var)
+var port = process.env.TESTPORT || 22;
+
+//
+// TESTS AND EXPECTED RESULTS
+//
+
+var tests = {
+  // for testing protocol.listen
+  listen:
+    "gwEAAAEAAAAIAAAAAQAAADw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+CjwhRE9DVFlQRSBwbGlzdCBQVUJMSUMgIi0vL0FwcGxlLy9EVEQgUExJU1QgMS4wLy9FTiIgImh0dHA6Ly93d3cuYXBwbGUuY29tL0RURHMvUHJvcGVydHlMaXN0LTEuMC5kdGQiPgo8cGxpc3QgdmVyc2lvbj0iMS4wIj4KICA8ZGljdD4KICAgIDxrZXk+TWVzc2FnZVR5cGU8L2tleT4KICAgIDxzdHJpbmc+TGlzdGVuPC9zdHJpbmc+CiAgICA8a2V5PkNsaWVudFZlcnNpb25TdHJpbmc8L2tleT4KICAgIDxzdHJpbmc+bm9kZS11c2JtdXg8L3N0cmluZz4KICAgIDxrZXk+UHJvZ05hbWU8L2tleT4KICAgIDxzdHJpbmc+bm9kZS11c2JtdXg8L3N0cmluZz4KICA8L2RpY3Q+CjwvcGxpc3Q+",
+
+  // for testing
+  // - protocol.connect(12, 22)
+  // - protocol.connect(21, 1234)
+  connect: {
+    _12_22:
+      "7AEAAAEAAAAIAAAAAQAAADw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+CjwhRE9DVFlQRSBwbGlzdCBQVUJMSUMgIi0vL0FwcGxlLy9EVEQgUExJU1QgMS4wLy9FTiIgImh0dHA6Ly93d3cuYXBwbGUuY29tL0RURHMvUHJvcGVydHlMaXN0LTEuMC5kdGQiPgo8cGxpc3QgdmVyc2lvbj0iMS4wIj4KICA8ZGljdD4KICAgIDxrZXk+TWVzc2FnZVR5cGU8L2tleT4KICAgIDxzdHJpbmc+Q29ubmVjdDwvc3RyaW5nPgogICAgPGtleT5DbGllbnRWZXJzaW9uU3RyaW5nPC9rZXk+CiAgICA8c3RyaW5nPm5vZGUtdXNibXV4PC9zdHJpbmc+CiAgICA8a2V5PlByb2dOYW1lPC9rZXk+CiAgICA8c3RyaW5nPm5vZGUtdXNibXV4PC9zdHJpbmc+CiAgICA8a2V5PkRldmljZUlEPC9rZXk+CiAgICA8aW50ZWdlcj4xMjwvaW50ZWdlcj4KICAgIDxrZXk+UG9ydE51bWJlcjwva2V5PgogICAgPGludGVnZXI+NTYzMjwvaW50ZWdlcj4KICA8L2RpY3Q+CjwvcGxpc3Q+",
+    _21_1234:
+      "7QEAAAEAAAAIAAAAAQAAADw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+CjwhRE9DVFlQRSBwbGlzdCBQVUJMSUMgIi0vL0FwcGxlLy9EVEQgUExJU1QgMS4wLy9FTiIgImh0dHA6Ly93d3cuYXBwbGUuY29tL0RURHMvUHJvcGVydHlMaXN0LTEuMC5kdGQiPgo8cGxpc3QgdmVyc2lvbj0iMS4wIj4KICA8ZGljdD4KICAgIDxrZXk+TWVzc2FnZVR5cGU8L2tleT4KICAgIDxzdHJpbmc+Q29ubmVjdDwvc3RyaW5nPgogICAgPGtleT5DbGllbnRWZXJzaW9uU3RyaW5nPC9rZXk+CiAgICA8c3RyaW5nPm5vZGUtdXNibXV4PC9zdHJpbmc+CiAgICA8a2V5PlByb2dOYW1lPC9rZXk+CiAgICA8c3RyaW5nPm5vZGUtdXNibXV4PC9zdHJpbmc+CiAgICA8a2V5PkRldmljZUlEPC9rZXk+CiAgICA8aW50ZWdlcj4yMTwvaW50ZWdlcj4KICAgIDxrZXk+UG9ydE51bWJlcjwva2V5PgogICAgPGludGVnZXI+NTM3NjQ8L2ludGVnZXI+CiAgPC9kaWN0Pgo8L3BsaXN0Pg==",
+  },
+
+  // for testing the message parser
+  makeParser: {
+    // a confirmation message
+    confirmation: {
+      msg: {
+        MessageType: "Result",
+        Number: 0,
+      },
+      data: new Buffer(
+        "JgEAAAEAAAAIAAAAAQAAADw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+CjwhRE9DVFlQRSBwbGlzdCBQVUJMSUMgIi0vL0FwcGxlLy9EVEQgUExJU1QgMS4wLy9FTiIgImh0dHA6Ly93d3cuYXBwbGUuY29tL0RURHMvUHJvcGVydHlMaXN0LTEuMC5kdGQiPgo8cGxpc3QgdmVyc2lvbj0iMS4wIj4KPGRpY3Q+Cgk8a2V5Pk1lc3NhZ2VUeXBlPC9rZXk+Cgk8c3RyaW5nPlJlc3VsdDwvc3RyaW5nPgoJPGtleT5OdW1iZXI8L2tleT4KCTxpbnRlZ2VyPjA8L2ludGVnZXI+CjwvZGljdD4KPC9wbGlzdD4K",
+        "base64",
+      ),
+    },
+
+    // a device report message
+    device: {
+      msg: {
+        DeviceID: 7,
+        MessageType: "Attached",
+        Properties: {
+          ConnectionType: "USB",
+          DeviceID: 7,
+          LocationID: 0,
+          ProductID: 4776,
+          SerialNumber: "22226dd59068c222f46522221f8222da222d394b",
+        },
+      },
+      data: new Buffer(
+        "qAIAAAAAAAAAAAAAAAAAADw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+CjwhRE9DVFlQRSBwbGlzdCBQVUJMSUMgIi0vL0FwcGxlLy9EVEQgUExJU1QgMS4wLy9FTiIgImh0dHA6Ly93d3cuYXBwbGUuY29tL0RURHMvUHJvcGVydHlMaXN0LTEuMC5kdGQiPgo8cGxpc3QgdmVyc2lvbj0iMS4wIj4KICA8ZGljdD4KICAgIDxrZXk+RGV2aWNlSUQ8L2tleT4KICAgIDxpbnRlZ2VyPjc8L2ludGVnZXI+CiAgICA8a2V5Pk1lc3NhZ2VUeXBlPC9rZXk+CiAgICA8c3RyaW5nPkF0dGFjaGVkPC9zdHJpbmc+CiAgICA8a2V5PlByb3BlcnRpZXM8L2tleT4KICAgIDxkaWN0PgogICAgICA8a2V5PkNvbm5lY3Rpb25UeXBlPC9rZXk+CiAgICAgIDxzdHJpbmc+VVNCPC9zdHJpbmc+CiAgICAgIDxrZXk+RGV2aWNlSUQ8L2tleT4KICAgICAgPGludGVnZXI+NzwvaW50ZWdlcj4KICAgICAgPGtleT5Mb2NhdGlvbklEPC9rZXk+CiAgICAgIDxpbnRlZ2VyPjA8L2ludGVnZXI+CiAgICAgIDxrZXk+UHJvZHVjdElEPC9rZXk+CiAgICAgIDxpbnRlZ2VyPjQ3NzY8L2ludGVnZXI+CiAgICAgIDxrZXk+U2VyaWFsTnVtYmVyPC9rZXk+CiAgICAgIDxzdHJpbmc+MjIyMjZkZDU5MDY4YzIyMmY0NjUyMjIyMWY4MjIyZGEyMjJkMzk0Yjwvc3RyaW5nPgogICAgPC9kaWN0PgogIDwvZGljdD4KPC9wbGlzdD4=",
+        "base64",
+      ),
+    },
+  },
+};
+
+//
+// RUNNER
+//
+
+// Test the building and parsing of usbmuxd messages
+//
+describe("protocol", function () {
+  // Test packing a listen request obj -> a usbmuxd msg with header
+  // Comparing against a known working example
+  //
+  describe(".listen", function () {
+    it("matches test buffer", function () {
+      protocol.listen.toString("base64").should.be.eql(tests.listen);
+    });
+  });
+
+  // Test packing a connect request obj -> a usbmuxd msg with header
+  // Compare against known working examples
+  //
+  describe(".connect()", function () {
+    it("connect(12, 22)", function () {
+      protocol
+        .connect(12, 22)
+        .toString("base64")
+        .should.be.eql(tests.connect._12_22);
+    });
+    it("connect(21, 1234)", function () {
+      protocol
+        .connect(21, 1234)
+        .toString("base64")
+        .should.be.eql(tests.connect._21_1234);
+    });
+  });
+
+  // Test parse function, comparing known data & messages
+  //
+  // This is probably the most important test because there's a few cases that
+  // need to be handled and everything breaks if the messages don't get parsed
+  // correctly.
+  //
+  describe(".parse()", function () {
+    //
+    // Case 1: a whole message
+    //
+
+    /**
+     * Test conversion of one data buf -> one usbmuxd message
+     *
+     * @param {string}   messageType - 'confirmation' or 'device'
+     * @param {Function} done
+     */
+    function one_data_to_one_msg(messageType, done) {
+      var test = tests.makeParser[messageType].data,
+        expected = tests.makeParser[messageType].msg;
+
+      var build = protocol.makeParser(function (msg) {
+        msg.should.eql(expected);
+        done();
+      });
+
+      build(test);
+    }
+
+    describe("where 1 data event makes up 1 complete msg", function () {
+      it("confirmation msg", function (done) {
+        one_data_to_one_msg("confirmation", done);
+      });
+
+      it("device report msg", function (done) {
+        one_data_to_one_msg("device", done);
+      });
+    });
+
+    //
+    // Case 2: messages broken up across data events
+    //
+
+    /**
+     * Test conversion of multiple data buf -> one usbmuxd message
+     *
+     * @param {string}   messageType - 'confirmation' or 'device'
+     * @param {integer}  numSegments - Number of segments to break data buf into
+     * @param {Function} done
+     */
+    function more_datas_to_one_msg(messageType, numSegments, done) {
+      var test = tests.makeParser[messageType].data,
+        expected = tests.makeParser[messageType].msg;
+
+      var build = protocol.makeParser(function (msg) {
+        msg.should.eql(expected);
+        done();
+      });
+
+      for (var i = 0; i < numSegments; i++) {
+        var previous = (test.length / numSegments) * i,
+          next = (test.length / numSegments) * (i + 1);
+
+        build(test.slice(previous, next));
+      }
+    }
+
+    describe("where >1 data events make up 1 complete msg", function () {
+      it("confirmation msg (split in 2)", function (done) {
+        more_datas_to_one_msg("confirmation", 2, done);
+      });
+
+      it("device report msg (split in 3)", function (done) {
+        more_datas_to_one_msg("device", 3, done);
+      });
+    });
+
+    //
+    // Case 3: multiple messages (w/ headers) in a data event
+    //
+
+    /**
+     * Call cb after getting called n times
+     *
+     * Accumulates return values in array each time its called, then passes to cb
+     *
+     * @param {integer}  n - Number of times to call
+     * @param {Function} done
+     */
+    function callAfter(n, cb) {
+      var count = 0,
+        acc = [];
+
+      return function (item) {
+        count++;
+        acc.push(item);
+        if (count === n) cb(acc);
+      };
+    }
+
+    /**
+     * Test conversion of one data buf -> multiple usbmuxd messages
+     *
+     * @param {string[]} messageTypes - [] of 'confirmation's or 'device's
+     * @param {Function} done
+     */
+    function one_data_to_many_msg(messageTypes, done) {
+      var test = Buffer.concat(
+        messageTypes.map(function (messageType) {
+          return tests.makeParser[messageType].data;
+        }),
+      );
+
+      var expected = messageTypes.map(function (messageType) {
+        return tests.makeParser[messageType].msg;
+      });
+
+      var onFinished = callAfter(messageTypes.length, function (msgs) {
+        msgs.should.eql(expected);
+        done();
+      });
+
+      var build = protocol.makeParser(onFinished);
+
+      build(test);
+    }
+
+    describe("where 1 data event makes up >1 complete msg", function () {
+      it("confirmation + report", function (done) {
+        one_data_to_many_msg(["confirmation", "device"], done);
+      });
+
+      it("report + report", function (done) {
+        one_data_to_many_msg(["device", "device"], done);
+      });
+
+      it("confirmation + report + report", function (done) {
+        one_data_to_many_msg(["confirmation", "device", "device"], done);
+      });
+    });
+  });
+});
+
+// From here on testing depends on a real plugged in device; its just easier to
+// test the methods directly than mock out a tcp connection with fake buffers.
+//
+// These methods make up the core, so if they pass the rest of the module is
+// probably in good shape.
+//
+
+describe("createListener()", function () {
+  it("fires attached event when a device is plugged in", function (done) {
+    const listener = usbmux
+      .createListener()
+      .on("error", done)
+      .on("attached", function () {
+        listener.end();
+        done();
+      });
+  });
+});
+
+describe("connect()", function () {
+  it("resolves a tunneled connection (id from above)", function (done) {
+    const listener = usbmux
+      .createListener()
+      .on("error", done)
+      .once("attached", function (udid) {
+        const deviceID = usbmux.devices[udid].DeviceID;
+        usbmux
+          .__get__("connect")(deviceID, port)
+          .then(function (tunnel) {
+            tunnel.should.be.instanceof(net.Socket);
+            tunnel.end();
+            listener.end();
+            done();
+          })
+          .catch(done);
+      });
+  });
+});
+
+describe("getTunnel()", function () {
+  describe("resolves a tunneled connection", function () {
+    it("with the udid option", function (done) {
+      const listener = usbmux
+        .createListener()
+        .on("error", done)
+        .once("attached", function (udid) {
+          usbmux
+            .getTunnel(port, { udid: udid })
+            .then(function (tunnel) {
+              tunnel.should.be.instanceof(net.Socket);
+              tunnel.end();
+              listener.end();
+              done();
+            })
+            .catch(done);
+        });
+    });
+
+    it("and without udid option", function (done) {
+      // emptying out device cache to test that case too
+      usbmux.__set__("devices", {});
+
+      usbmux
+        .getTunnel(port)
+        .then(function (tunnel) {
+          tunnel.should.be.instanceof(net.Socket);
+          tunnel.end();
+          done();
+        })
+        .catch(done);
+    });
+  });
+});
+
+describe("Relay()", function () {
+  it("has a server, a listener, and fires a ready event", function (done) {
+    var relay = new usbmux.Relay(port, 2222)
+      .on("error", done)
+      .on("warning", done)
+      .on("ready", function () {
+        relay._server.should.instanceof(net.Server);
+        relay._listener.should.instanceof(net.Socket);
+        relay.stop();
+        done();
+      });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "es6",
+    "noImplicitAny": true,
+    "moduleResolution": "node",
+    "sourceMap": true,
+    "outDir": "dist",
+    "baseUrl": ".",
+    "paths": {
+      "*": ["node_modules/*"]
+    }
+  },
+  "include": ["lib/**/*"]
+}