@mcesystems/apple-kit 1.0.0

package/dist/index.js

@@ -0,0 +1,680 @@
+// src/logic/appleDeviceKit.ts
+import { spawn } from "node:child_process";
+
+// src/utils/debug.ts
+import createDebug from "debug";
+var debug = createDebug("apple-kit");
+var debugTask = createDebug("apple-kit:task");
+function logInfo(message) {
+  debug(message);
+}
+function logTask(message) {
+  debugTask(message);
+}
+
+// src/utils/exec.ts
+import { exec as execCallback } from "node:child_process";
+import { promisify } from "node:util";
+
+// src/utils/idevicePath.ts
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function getResourcesBinPath() {
+  const packageRoot = dirname(dirname(__dirname));
+  const platform = process.platform;
+  let platformDir;
+  switch (platform) {
+    case "win32":
+      platformDir = "windows";
+      break;
+    case "darwin":
+      platformDir = "darwin";
+      break;
+    case "linux":
+      platformDir = "linux";
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${platform}`);
+  }
+  return join(packageRoot, "resources", "bin", platformDir);
+}
+function getIDeviceToolPath(toolName) {
+  const binPath = getResourcesBinPath();
+  const ext = process.platform === "win32" ? ".exe" : "";
+  const toolPath = join(binPath, `${toolName}${ext}`);
+  if (existsSync(toolPath)) {
+    return toolPath;
+  }
+  return null;
+}
+function getIDeviceBinPath() {
+  return getResourcesBinPath();
+}
+
+// src/utils/exec.ts
+var execAsync = promisify(execCallback);
+async function execIDevice(command, options = {}) {
+  const binPath = getIDeviceBinPath();
+  const env = {
+    ...process.env,
+    PATH: `${binPath};${process.env.PATH}`
+  };
+  const result = await execAsync(command, {
+    ...options,
+    env,
+    windowsHide: true,
+    encoding: "utf8"
+  });
+  return {
+    stdout: result.stdout.toString(),
+    stderr: result.stderr.toString()
+  };
+}
+async function runIDeviceTool(toolPath, args = [], options = {}) {
+  const command = `"${toolPath}" ${args.map((a) => `"${a}"`).join(" ")}`;
+  return execIDevice(command, options);
+}
+
+// src/logic/appleDeviceKit.ts
+function parsePlistOutput(output) {
+  const result = {};
+  const lines = output.split("\n");
+  for (const line of lines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex > 0) {
+      const key = line.substring(0, colonIndex).trim();
+      const value = line.substring(colonIndex + 1).trim();
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function parseDeviceList(output) {
+  const devices = [];
+  const lines = output.trim().split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed) {
+      const match = trimmed.match(/^([A-Fa-f0-9-]+)(?:\s+\((\w+)\))?/);
+      if (match) {
+        devices.push({
+          udid: match[1],
+          connectionType: match[2] === "Network" ? 2 : 1
+        });
+      }
+    }
+  }
+  return devices;
+}
+function parseAppList(output) {
+  const apps = [];
+  const lines = output.trim().split("\n");
+  for (const line of lines) {
+    const match = line.match(/^([^,]+),\s*([^,]+),\s*"?([^"]+)"?/);
+    if (match) {
+      apps.push({
+        bundleId: match[1].trim(),
+        version: match[2].trim(),
+        displayName: match[3].trim(),
+        bundleVersion: ""
+      });
+    }
+  }
+  return apps;
+}
+var AppleDeviceKit = class {
+  constructor(udid, port) {
+    this.port = port;
+    this.deviceId = udid;
+    logInfo(`AppleDeviceKit initialized for device: ${this.deviceId}`);
+  }
+  deviceId;
+  // ==================== Device Info ====================
+  /**
+   * Get detailed device information
+   */
+  async getDeviceInfo() {
+    logTask(`Getting device info for ${this.deviceId}`);
+    const toolPath = getIDeviceToolPath("ideviceinfo");
+    if (!toolPath) {
+      throw new Error("ideviceinfo tool not found");
+    }
+    const { stdout } = await runIDeviceTool(toolPath, ["-u", this.deviceId]);
+    const props = parsePlistOutput(stdout);
+    return {
+      deviceName: props.DeviceName || "",
+      productType: props.ProductType || "",
+      productVersion: props.ProductVersion || "",
+      buildVersion: props.BuildVersion || "",
+      serialNumber: props.SerialNumber || "",
+      udid: props.UniqueDeviceID || this.deviceId,
+      wifiAddress: props.WiFiAddress || "",
+      bluetoothAddress: props.BluetoothAddress || "",
+      phoneNumber: props.PhoneNumber || "",
+      cpuArchitecture: props.CPUArchitecture || "",
+      hardwareModel: props.HardwareModel || "",
+      modelNumber: props.ModelNumber || "",
+      regionInfo: props.RegionInfo || "",
+      timeZone: props.TimeZone || "",
+      uniqueChipID: props.UniqueChipID || "",
+      isPaired: true
+      // If we can get info, device is paired
+    };
+  }
+  // ==================== Trust/Pairing ====================
+  /**
+   * Check if device is paired/trusted with this computer
+   */
+  async isPaired() {
+    logTask(`Checking pairing status for ${this.deviceId}`);
+    const toolPath = getIDeviceToolPath("idevicepair");
+    if (!toolPath) {
+      throw new Error("idevicepair tool not found");
+    }
+    try {
+      const { stdout } = await runIDeviceTool(toolPath, ["-u", this.deviceId, "validate"]);
+      return stdout.toLowerCase().includes("success");
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Wait for device to be paired
+   * Polls the pairing status until successful or timeout
+   * 
+   * @param timeout Timeout in milliseconds (default: 120000)
+   * @param pollInterval Poll interval in milliseconds (default: 1000)
+   */
+  async waitForPairing(timeout = 12e4, pollInterval = 1e3) {
+    logTask(`Waiting for pairing on device ${this.deviceId}`);
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      if (await this.isPaired()) {
+        logInfo(`Device ${this.deviceId} is now paired`);
+        return true;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Timeout waiting for device pairing after ${timeout}ms`);
+  }
+  /**
+   * Attempt to pair/trust the device
+   * User must accept the trust dialog on the device
+   */
+  async pair() {
+    logTask(`Initiating pairing for device ${this.deviceId}`);
+    const toolPath = getIDeviceToolPath("idevicepair");
+    if (!toolPath) {
+      throw new Error("idevicepair tool not found");
+    }
+    try {
+      const { stdout } = await runIDeviceTool(toolPath, ["-u", this.deviceId, "pair"]);
+      return stdout.toLowerCase().includes("success");
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      if (errorMsg.includes("Please accept the trust dialog")) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Unpair/untrust the device
+   */
+  async unpair() {
+    logTask(`Unpairing device ${this.deviceId}`);
+    const toolPath = getIDeviceToolPath("idevicepair");
+    if (!toolPath) {
+      throw new Error("idevicepair tool not found");
+    }
+    try {
+      const { stdout } = await runIDeviceTool(toolPath, ["-u", this.deviceId, "unpair"]);
+      return stdout.toLowerCase().includes("success");
+    } catch {
+      return false;
+    }
+  }
+  // ==================== App Installation ====================
+  /**
+   * Install an IPA file on the device (install agent)
+   * 
+   * @param ipaPath Path to the IPA file
+   */
+  async installApp(ipaPath) {
+    logTask(`Installing app ${ipaPath} on device ${this.deviceId}`);
+    if (!await this.isPaired()) {
+      await this.waitForPairing(1e4);
+    }
+    const toolPath = getIDeviceToolPath("ideviceinstaller");
+    if (!toolPath) {
+      throw new Error("ideviceinstaller tool not found");
+    }
+    await runIDeviceTool(toolPath, ["-u", this.deviceId, "-i", ipaPath]);
+  }
+  /**
+   * Uninstall an app by bundle ID (uninstall agent)
+   * 
+   * @param bundleId Application bundle identifier
+   */
+  async uninstallApp(bundleId) {
+    logTask(`Uninstalling app ${bundleId} from device ${this.deviceId}`);
+    if (!await this.isPaired()) {
+      await this.waitForPairing(1e4);
+    }
+    const toolPath = getIDeviceToolPath("ideviceinstaller");
+    if (!toolPath) {
+      throw new Error("ideviceinstaller tool not found");
+    }
+    await runIDeviceTool(toolPath, ["-u", this.deviceId, "-U", bundleId]);
+  }
+  /**
+   * Check if an app is installed on the device
+   * 
+   * @param bundleId Application bundle identifier
+   */
+  async isAppInstalled(bundleId) {
+    logTask(`Checking if app ${bundleId} is installed on device ${this.deviceId}`);
+    const apps = await this.listApps();
+    return apps.some((app) => app.bundleId === bundleId);
+  }
+  /**
+   * List all installed user applications
+   */
+  async listApps() {
+    logTask(`Listing apps on device ${this.deviceId}`);
+    if (!await this.isPaired()) {
+      await this.waitForPairing(1e4);
+    }
+    const toolPath = getIDeviceToolPath("ideviceinstaller");
+    if (!toolPath) {
+      throw new Error("ideviceinstaller tool not found");
+    }
+    try {
+      const { stdout } = await runIDeviceTool(toolPath, ["-u", this.deviceId, "-l"]);
+      return parseAppList(stdout);
+    } catch {
+      return [];
+    }
+  }
+  // ==================== Launch Application ====================
+  /**
+   * Launch an application on the device
+   * 
+   * @param bundleId Application bundle identifier to launch
+   * @param args Optional arguments to pass to the app
+   */
+  async launchApp(bundleId, args = []) {
+    logTask(`Launching app ${bundleId} on device ${this.deviceId}`);
+    if (!await this.isPaired()) {
+      await this.waitForPairing(1e4);
+    }
+    const toolPath = getIDeviceToolPath("idevicedebug");
+    if (!toolPath) {
+      throw new Error("idevicedebug tool not found");
+    }
+    const toolArgs = ["-u", this.deviceId, "run", bundleId, ...args];
+    await runIDeviceTool(toolPath, toolArgs);
+  }
+  // ==================== Port Forwarding ====================
+  /**
+   * Start port forwarding from local port to device port
+   * 
+   * @param localPort Local port to listen on
+   * @param devicePort Device port to forward to
+   * @returns Handle to stop the port forwarding
+   */
+  startPortForward(localPort, devicePort) {
+    logTask(`Starting port forward ${localPort} -> ${devicePort} for device ${this.deviceId}`);
+    const toolPath = getIDeviceToolPath("iproxy");
+    if (!toolPath) {
+      throw new Error("iproxy tool not found");
+    }
+    const binPath = getIDeviceBinPath();
+    const env = {
+      ...process.env,
+      PATH: `${binPath};${process.env.PATH}`
+    };
+    const proc = spawn(toolPath, [
+      localPort.toString(),
+      devicePort.toString(),
+      "-u",
+      this.deviceId
+    ], {
+      env,
+      windowsHide: true,
+      stdio: "pipe"
+    });
+    proc.on("error", (err) => {
+      logInfo(`Port forward error: ${err.message}`);
+    });
+    return {
+      stop: () => {
+        proc.kill();
+      },
+      localPort,
+      devicePort,
+      process: proc
+    };
+  }
+  /**
+   * Start port forwarding and wait for it to be ready
+   * 
+   * @param localPort Local port to listen on
+   * @param devicePort Device port to forward to
+   * @param _timeout Timeout in milliseconds (reserved for future use)
+   */
+  async startPortForwardAsync(localPort, devicePort, _timeout = 5e3) {
+    const handle = this.startPortForward(localPort, devicePort);
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    if (handle.process.killed || handle.process.exitCode !== null) {
+      throw new Error("Port forwarding failed to start");
+    }
+    return handle;
+  }
+  // ==================== Activation ====================
+  /**
+   * Get the activation state of the device
+   */
+  async getActivationState() {
+    logTask(`Getting activation state for device ${this.deviceId}`);
+    const toolPath = getIDeviceToolPath("ideviceinfo");
+    if (!toolPath) {
+      throw new Error("ideviceinfo tool not found");
+    }
+    try {
+      const { stdout } = await runIDeviceTool(toolPath, ["-u", this.deviceId, "-k", "ActivationState"]);
+      const state = stdout.trim();
+      return {
+        isActivated: state === "Activated",
+        activationState: state
+      };
+    } catch {
+      return {
+        isActivated: false,
+        activationState: "Unknown"
+      };
+    }
+  }
+  /**
+   * Activate the device
+   * Note: This requires a valid activation record or Apple server access
+   */
+  async activate() {
+    logTask(`Activating device ${this.deviceId}`);
+    const toolPath = getIDeviceToolPath("ideviceactivation");
+    if (!toolPath) {
+      throw new Error("ideviceactivation tool not found");
+    }
+    try {
+      const { stdout } = await runIDeviceTool(toolPath, ["-u", this.deviceId, "activate"]);
+      return stdout.toLowerCase().includes("success") || stdout.toLowerCase().includes("activated");
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      throw new Error(`Activation failed: ${errorMsg}`);
+    }
+  }
+  /**
+   * Deactivate the device
+   */
+  async deactivate() {
+    logTask(`Deactivating device ${this.deviceId}`);
+    const toolPath = getIDeviceToolPath("ideviceactivation");
+    if (!toolPath) {
+      throw new Error("ideviceactivation tool not found");
+    }
+    try {
+      const { stdout } = await runIDeviceTool(toolPath, ["-u", this.deviceId, "deactivate"]);
+      return stdout.toLowerCase().includes("success");
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get activation state as string
+   */
+  async getActivationStateString() {
+    const state = await this.getActivationState();
+    return state.activationState;
+  }
+  // ==================== Device Identifiers ====================
+  /**
+   * Get the device UDID
+   */
+  getDeviceId() {
+    return this.deviceId;
+  }
+  /**
+   * Get the logical port number
+   */
+  getPort() {
+    return this.port;
+  }
+  // ==================== Static Methods ====================
+  /**
+   * Static method to list all connected iOS devices
+   */
+  static async listDevices() {
+    const toolPath = getIDeviceToolPath("idevice_id");
+    if (!toolPath) {
+      throw new Error("idevice_id tool not found");
+    }
+    try {
+      const { stdout } = await runIDeviceTool(toolPath, ["-l"]);
+      return parseDeviceList(stdout);
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/logic/devicesMonitor.ts
+import EventEmitter from "node:events";
+import usbDeviceListener from "@mcesystems/usb-device-listener";
+var APPLE_VID = 1452;
+var DevicesMonitor = class {
+  constructor(config = {}, identifyAlreadyConnected = false) {
+    this.config = config;
+    this.identifyAlreadyConnected = identifyAlreadyConnected;
+  }
+  kits = /* @__PURE__ */ new Map();
+  eventEmitter;
+  /**
+   * Start tracking iOS device connections
+   * 
+   * @returns EventEmitter that emits:
+   *   - 'added': (deviceKit: AppleDeviceKit) when a device is connected
+   *   - 'removed': (deviceId: string, port: number) when a device is disconnected
+   */
+  async startTracking() {
+    logInfo("Starting iOS devices monitor");
+    const listenerConfig = {
+      logicalPortMap: this.config.logicalPortMap,
+      // Filter for Apple devices only
+      listenOnlyDevices: [
+        { vid: APPLE_VID.toString(16).toUpperCase().padStart(4, "0"), pid: "" }
+      ]
+    };
+    usbDeviceListener.startListening(listenerConfig);
+    this.eventEmitter = new EventEmitter();
+    if (this.identifyAlreadyConnected || this.config.identifyAlreadyConnected) {
+      await this.identifyConnectedDevices();
+    }
+    usbDeviceListener.onDeviceAdd((device) => {
+      if (device.vid !== APPLE_VID) {
+        return;
+      }
+      logInfo(`Apple device connected: ${device.deviceId}`);
+      this.findAndEmitDevice(device);
+    });
+    usbDeviceListener.onDeviceRemove((device) => {
+      if (device.vid !== APPLE_VID) {
+        return;
+      }
+      logInfo(`Apple device disconnected: ${device.deviceId}`);
+      for (const [udid, kit] of this.kits.entries()) {
+        if (kit.getPort() === device.logicalPort) {
+          this.kits.delete(udid);
+          this.eventEmitter?.emit("removed", udid, device.logicalPort);
+          break;
+        }
+      }
+    });
+    return this.eventEmitter;
+  }
+  /**
+   * Stop tracking device connections
+   */
+  async stopTracking() {
+    if (!this.eventEmitter) {
+      return;
+    }
+    logInfo("Stopping iOS devices monitor");
+    this.eventEmitter.removeAllListeners();
+    this.kits.clear();
+    this.eventEmitter = void 0;
+    usbDeviceListener.stopListening();
+  }
+  /**
+   * Get all currently tracked device kits
+   */
+  getKits() {
+    return new Map(this.kits);
+  }
+  /**
+   * Get a specific device kit by UDID
+   */
+  getKit(udid) {
+    return this.kits.get(udid);
+  }
+  /**
+   * Find connected iOS device and emit event
+   */
+  async findAndEmitDevice(usbDevice) {
+    const iOSDevices = await AppleDeviceKit.listDevices();
+    if (iOSDevices.length === 0) {
+      setTimeout(() => this.findAndEmitDevice(usbDevice), 500);
+      return;
+    }
+    for (const iDevice of iOSDevices) {
+      if (this.kits.has(iDevice.udid)) {
+        continue;
+      }
+      const port = usbDevice.logicalPort ?? 0;
+      const kit = new AppleDeviceKit(iDevice.udid, port);
+      this.kits.set(iDevice.udid, kit);
+      setTimeout(() => {
+        this.eventEmitter?.emit("added", kit);
+      }, 0);
+      break;
+    }
+  }
+  /**
+   * Identify already connected iOS devices
+   */
+  async identifyConnectedDevices() {
+    logInfo("Identifying already connected iOS devices");
+    const iOSDevices = await AppleDeviceKit.listDevices();
+    const usbDevices = usbDeviceListener.listDevices().filter((d) => d.vid === APPLE_VID);
+    for (let i = 0; i < iOSDevices.length; i++) {
+      const iDevice = iOSDevices[i];
+      const usbDevice = usbDevices[i];
+      if (this.kits.has(iDevice.udid)) {
+        continue;
+      }
+      const port = usbDevice?.logicalPort ?? 0;
+      const kit = new AppleDeviceKit(iDevice.udid, port);
+      this.kits.set(iDevice.udid, kit);
+      setTimeout(() => {
+        this.eventEmitter?.emit("added", kit);
+      }, 0);
+    }
+  }
+};
+
+// src/utils/usbmuxd.ts
+import { spawn as spawn2 } from "node:child_process";
+var usbmuxdProcess = null;
+function startUsbmuxd(foreground = false) {
+  if (usbmuxdProcess && !usbmuxdProcess.killed) {
+    logInfo("usbmuxd is already running");
+    return {
+      stop: () => stopUsbmuxd(),
+      isRunning: () => !usbmuxdProcess?.killed,
+      process: usbmuxdProcess
+    };
+  }
+  const toolPath = getIDeviceToolPath("usbmuxd");
+  if (!toolPath) {
+    throw new Error("usbmuxd executable not found");
+  }
+  const binPath = getIDeviceBinPath();
+  const env = {
+    ...process.env,
+    PATH: `${binPath};${process.env.PATH}`
+  };
+  const args = [];
+  if (foreground) {
+    args.push("-f");
+  }
+  args.push("-v");
+  logInfo(`Starting usbmuxd: ${toolPath}`);
+  usbmuxdProcess = spawn2(toolPath, args, {
+    env,
+    windowsHide: true,
+    stdio: "pipe",
+    detached: !foreground
+  });
+  usbmuxdProcess.stdout?.on("data", (data) => {
+    logInfo(`usbmuxd: ${data.toString().trim()}`);
+  });
+  usbmuxdProcess.stderr?.on("data", (data) => {
+    logInfo(`usbmuxd error: ${data.toString().trim()}`);
+  });
+  usbmuxdProcess.on("error", (err) => {
+    logInfo(`usbmuxd failed to start: ${err.message}`);
+  });
+  usbmuxdProcess.on("exit", (code) => {
+    logInfo(`usbmuxd exited with code ${code}`);
+    usbmuxdProcess = null;
+  });
+  if (!foreground) {
+    usbmuxdProcess.unref();
+  }
+  return {
+    stop: () => stopUsbmuxd(),
+    isRunning: () => usbmuxdProcess !== null && !usbmuxdProcess.killed,
+    process: usbmuxdProcess
+  };
+}
+function stopUsbmuxd() {
+  if (usbmuxdProcess && !usbmuxdProcess.killed) {
+    logInfo("Stopping usbmuxd");
+    usbmuxdProcess.kill();
+    usbmuxdProcess = null;
+  }
+}
+function isUsbmuxdRunning() {
+  return usbmuxdProcess !== null && !usbmuxdProcess.killed;
+}
+function ensureUsbmuxd() {
+  if (isUsbmuxdRunning()) {
+    return {
+      stop: () => stopUsbmuxd(),
+      isRunning: () => isUsbmuxdRunning(),
+      process: usbmuxdProcess
+    };
+  }
+  return startUsbmuxd();
+}
+export {
+  AppleDeviceKit,
+  DevicesMonitor,
+  ensureUsbmuxd,
+  isUsbmuxdRunning,
+  startUsbmuxd,
+  stopUsbmuxd
+};
+//# sourceMappingURL=index.js.map