@ebowwa/mcp-ios-devices 1.0.0

package/src/tools/app.ts

@@ -0,0 +1,58 @@
+/**
+ * App Management Tools
+ * Install, uninstall, and manage apps on iOS devices
+ */
+
+import { z } from 'zod';
+import { registerTool } from '../registry.js';
+import { DeviceCtl } from '@ebowwa/ios-devices';
+
+const deviceCtl = new DeviceCtl();
+
+registerTool({
+  name: 'ios_list_apps',
+  description: 'List all installed apps on a device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+  }),
+  handler: async ({ deviceId }) => {
+    return deviceCtl.listApps(deviceId);
+  },
+});
+
+registerTool({
+  name: 'ios_install_app',
+  description: 'Install an app (.app or .ipa) on the device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    appPath: z.string().describe('Path to .app or .ipa file'),
+  }),
+  handler: async ({ deviceId, appPath }) => {
+    return deviceCtl.installApp(deviceId, appPath);
+  },
+});
+
+registerTool({
+  name: 'ios_uninstall_app',
+  description: 'Uninstall an app from the device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    bundleId: z.string().describe('App bundle identifier'),
+  }),
+  handler: async ({ deviceId, bundleId }) => {
+    return deviceCtl.uninstallApp(deviceId, bundleId);
+  },
+});
+
+registerTool({
+  name: 'ios_get_app_icon',
+  description: 'Get the icon for an app',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    bundleId: z.string().describe('App bundle identifier'),
+    outputPath: z.string().optional().describe('Path to save icon'),
+  }),
+  handler: async ({ deviceId, bundleId, outputPath }) => {
+    return deviceCtl.getAppIcon(deviceId, bundleId, outputPath);
+  },
+});

package/src/tools/backup.ts

@@ -0,0 +1,71 @@
+/**
+ * Backup & Restore Tools
+ * Create and restore device backups
+ */
+
+import { z } from 'zod';
+import { registerTool } from '../registry.js';
+import { LibIMobileDevice } from '@ebowwa/ios-devices';
+
+registerTool({
+  name: 'ios_create_backup',
+  description: 'Create a backup of the device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    directory: z.string().describe('Directory for backup'),
+    encrypt: z.boolean().optional().describe('Encrypt backup'),
+    password: z.string().optional().describe('Password for encrypted backup'),
+  }),
+  handler: async ({ deviceId, directory, encrypt, password }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.createBackup(directory, encrypt, password);
+  },
+});
+
+registerTool({
+  name: 'ios_restore_backup',
+  description: 'Restore a backup to the device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    directory: z.string().describe('Backup directory'),
+    password: z.string().optional().describe('Password for encrypted backup'),
+  }),
+  handler: async ({ deviceId, directory, password }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.restoreBackup(directory, password);
+  },
+});
+
+registerTool({
+  name: 'ios_list_backups',
+  description: 'List available backups',
+  inputSchema: z.object({}),
+  handler: async () => {
+    const lib = new LibIMobileDevice();
+    return lib.listBackups();
+  },
+});
+
+registerTool({
+  name: 'ios_get_backup_info',
+  description: 'Get information about a backup',
+  inputSchema: z.object({
+    directory: z.string().describe('Backup directory'),
+  }),
+  handler: async ({ directory }) => {
+    const lib = new LibIMobileDevice();
+    return lib.getBackupInfo(directory);
+  },
+});
+
+registerTool({
+  name: 'ios_unpack_backup',
+  description: 'Unpack a backup to a directory',
+  inputSchema: z.object({
+    directory: z.string().describe('Backup directory'),
+  }),
+  handler: async ({ directory }) => {
+    const lib = new LibIMobileDevice();
+    return lib.unpackBackup(directory);
+  },
+});

package/src/tools/device.ts

@@ -0,0 +1,200 @@
+/**
+ * Device Management Tools
+ * Physical iOS device control via devicectl and libimobiledevice
+ */
+
+import { z } from 'zod';
+import { registerTool } from '../registry.js';
+import { DeviceCtl, LibIMobileDevice } from '@ebowwa/ios-devices';
+
+const deviceCtl = new DeviceCtl();
+
+// ============================================================================
+// Device Listing & Info
+// ============================================================================
+
+registerTool({
+  name: 'ios_list_devices',
+  description: 'List all connected iOS devices',
+  inputSchema: z.object({}),
+  handler: async () => {
+    return deviceCtl.listDevices();
+  },
+});
+
+registerTool({
+  name: 'ios_device_info',
+  description: 'Get detailed information about a specific device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID, name, or ECID'),
+  }),
+  handler: async ({ deviceId }) => {
+    return deviceCtl.getDeviceInfo(deviceId);
+  },
+});
+
+registerTool({
+  name: 'ios_device_lock_state',
+  description: 'Get the lock state of a device (locked/unlocked)',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+  }),
+  handler: async ({ deviceId }) => {
+    return deviceCtl.getLockState(deviceId);
+  },
+});
+
+registerTool({
+  name: 'ios_device_displays',
+  description: 'Get display information for a device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+  }),
+  handler: async ({ deviceId }) => {
+    return deviceCtl.getDisplays(deviceId);
+  },
+});
+
+// ============================================================================
+// Pairing
+// ============================================================================
+
+registerTool({
+  name: 'ios_pair_device',
+  description: 'Pair with an iOS device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+  }),
+  handler: async ({ deviceId }) => {
+    return deviceCtl.pair(deviceId);
+  },
+});
+
+registerTool({
+  name: 'ios_unpair_device',
+  description: 'Unpair from an iOS device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+  }),
+  handler: async ({ deviceId }) => {
+    return deviceCtl.unpair(deviceId);
+  },
+});
+
+// ============================================================================
+// Device Control
+// ============================================================================
+
+registerTool({
+  name: 'ios_reboot_device',
+  description: 'Reboot an iOS device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+  }),
+  handler: async ({ deviceId }) => {
+    return deviceCtl.reboot(deviceId);
+  },
+});
+
+registerTool({
+  name: 'ios_set_orientation',
+  description: 'Set device orientation',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    orientation: z.enum(['portrait', 'landscape', 'portrait-upside-down', 'landscape-left', 'landscape-right']),
+  }),
+  handler: async ({ deviceId, orientation }) => {
+    return deviceCtl.setOrientation(deviceId, orientation);
+  },
+});
+
+registerTool({
+  name: 'ios_respring',
+  description: 'Respring the device (restart SpringBoard UI)',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+  }),
+  handler: async ({ deviceId }) => {
+    return deviceCtl.respring(deviceId);
+  },
+});
+
+// ============================================================================
+// LibIMobileDevice Tools (Additional)
+// ============================================================================
+
+registerTool({
+  name: 'ios_get_device_name',
+  description: 'Get or set the device name',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    newName: z.string().optional().describe('New name (omit to get current name)'),
+  }),
+  handler: async ({ deviceId, newName }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    if (newName) {
+      return lib.setDeviceName(newName);
+    }
+    return lib.getDeviceName();
+  },
+});
+
+registerTool({
+  name: 'ios_get_device_date',
+  description: 'Get the current date/time from the device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+  }),
+  handler: async ({ deviceId }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.getDeviceDate();
+  },
+});
+
+registerTool({
+  name: 'ios_shutdown_device',
+  description: 'Shutdown the device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+  }),
+  handler: async ({ deviceId }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.shutdown();
+  },
+});
+
+registerTool({
+  name: 'ios_restart_device',
+  description: 'Restart the device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+  }),
+  handler: async ({ deviceId }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.restart();
+  },
+});
+
+registerTool({
+  name: 'ios_sleep_device',
+  description: 'Put the device to sleep',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+  }),
+  handler: async ({ deviceId }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.sleep();
+  },
+});
+
+registerTool({
+  name: 'ios_enter_recovery',
+  description: 'Put device into recovery mode',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+  }),
+  handler: async ({ deviceId }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.enterRecovery();
+  },
+});

package/src/tools/diagnostics.ts

@@ -0,0 +1,87 @@
+/**
+ * Diagnostics Tools
+ * Device diagnostics and information
+ */
+
+import { z } from 'zod';
+import { registerTool } from '../registry.js';
+import { LibIMobileDevice } from '@ebowwa/ios-devices';
+
+registerTool({
+  name: 'ios_get_diagnostics',
+  description: 'Get device diagnostics (WiFi, Battery, NAND, etc.)',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    type: z.enum(['All', 'WiFi', 'GasGauge', 'NAND', 'Battery', 'HDMI']).default('All'),
+  }),
+  handler: async ({ deviceId, type }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.getDiagnostics(type);
+  },
+});
+
+registerTool({
+  name: 'ios_get_ioreg',
+  description: 'Get IO Registry information',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    plane: z.enum(['IODeviceTree', 'IOPower', 'IOService']).optional(),
+  }),
+  handler: async ({ deviceId, plane }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.getIORegistry(plane);
+  },
+});
+
+registerTool({
+  name: 'ios_get_mobilegestalt',
+  description: 'Get MobileGestalt values from device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    keys: z.array(z.string()).describe('Keys to query'),
+  }),
+  handler: async ({ deviceId, keys }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.getMobileGestalt(...keys);
+  },
+});
+
+registerTool({
+  name: 'ios_mount_image',
+  description: 'Mount developer disk image on device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    imagePath: z.string().describe('Path to developer disk image'),
+    signaturePath: z.string().optional().describe('Path to signature file'),
+  }),
+  handler: async ({ deviceId, imagePath, signaturePath }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.mountImage(imagePath, signaturePath);
+  },
+});
+
+registerTool({
+  name: 'ios_start_debug_server',
+  description: 'Start debug server proxy for remote debugging',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    port: z.number().default(6666).describe('Port for debug server'),
+  }),
+  handler: async ({ deviceId, port }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.startDebugServerProxy(port);
+  },
+});
+
+registerTool({
+  name: 'ios_start_bluetooth_logger',
+  description: 'Start Bluetooth packet logging',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    outputPath: z.string().optional().describe('Output file path'),
+  }),
+  handler: async ({ deviceId, outputPath }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.startBluetoothLogging(outputPath);
+  },
+});

package/src/tools/file.ts

@@ -0,0 +1,60 @@
+/**
+ * File System Tools
+ * Access files on iOS devices via AFC
+ */
+
+import { z } from 'zod';
+import { registerTool } from '../registry.js';
+import { DeviceCtl, LibIMobileDevice } from '@ebowwa/ios-devices';
+
+const deviceCtl = new DeviceCtl();
+
+registerTool({
+  name: 'ios_list_files',
+  description: 'List files in a directory on the device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    path: z.string().describe('Directory path to list'),
+  }),
+  handler: async ({ deviceId, path }) => {
+    return deviceCtl.listFiles(deviceId, path);
+  },
+});
+
+registerTool({
+  name: 'ios_copy_to_device',
+  description: 'Copy a file to the device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    source: z.string().describe('Local source path'),
+    destination: z.string().describe('Device destination path'),
+  }),
+  handler: async ({ deviceId, source, destination }) => {
+    return deviceCtl.copyToDevice(deviceId, source, destination);
+  },
+});
+
+registerTool({
+  name: 'ios_copy_from_device',
+  description: 'Copy a file from the device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    source: z.string().describe('Device source path'),
+    destination: z.string().describe('Local destination path'),
+  }),
+  handler: async ({ deviceId, source, destination }) => {
+    return deviceCtl.copyFromDevice(deviceId, source, destination);
+  },
+});
+
+registerTool({
+  name: 'ios_start_afc_shell',
+  description: 'Start an AFC shell for file system access',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+  }),
+  handler: async ({ deviceId }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.startAFCShell();
+  },
+});

package/src/tools/location.ts

@@ -0,0 +1,34 @@
+/**
+ * Location Tools
+ * Simulate GPS location on devices
+ */
+
+import { z } from 'zod';
+import { registerTool } from '../registry.js';
+import { LibIMobileDevice } from '@ebowwa/ios-devices';
+
+registerTool({
+  name: 'ios_set_location',
+  description: 'Set simulated GPS location on device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    latitude: z.number().min(-90).max(90).describe('Latitude'),
+    longitude: z.number().min(-180).max(180).describe('Longitude'),
+  }),
+  handler: async ({ deviceId, latitude, longitude }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.setLocation(latitude, longitude);
+  },
+});
+
+registerTool({
+  name: 'ios_reset_location',
+  description: 'Reset simulated GPS location (stop simulation)',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+  }),
+  handler: async ({ deviceId }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.resetLocation();
+  },
+});

package/src/tools/log.ts

@@ -0,0 +1,117 @@
+/**
+ * Logging & Diagnostics Tools
+ * Collect logs and diagnostic information from iOS devices
+ */
+
+import { z } from 'zod';
+import { registerTool } from '../registry.js';
+import { LibIMobileDevice, DeviceCtl } from '@ebowwa/ios-devices';
+
+registerTool({
+  name: 'ios_stream_syslog',
+  description: 'Stream syslog from device (real-time logs)',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    match: z.string().optional().describe('Only include logs matching pattern'),
+    exclude: z.string().optional().describe('Exclude logs matching pattern'),
+    process: z.string().optional().describe('Filter by process name'),
+    kernel: z.boolean().optional().describe('Include kernel logs only'),
+  }),
+  handler: async ({ deviceId, match, exclude, process, kernel }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.streamSyslog({ match, exclude, process, kernel });
+  },
+});
+
+registerTool({
+  name: 'ios_get_syslog_archive',
+  description: 'Download syslog archive from device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    outputPath: z.string().describe('Path to save archive'),
+  }),
+  handler: async ({ deviceId, outputPath }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.getSyslogArchive(outputPath);
+  },
+});
+
+registerTool({
+  name: 'ios_collect_diagnostics',
+  description: 'Collect diagnostic information from device',
+  inputSchema: z.object({
+    deviceId: z.string().optional().describe('Device UDID (omit for all devices)'),
+    archiveDestination: z.string().optional().describe('Path for diagnostic archive'),
+  }),
+  handler: async ({ deviceId, archiveDestination }) => {
+    const deviceCtl = new DeviceCtl();
+    return deviceCtl.collectDiagnostics({ devices: deviceId, archiveDestination });
+  },
+});
+
+registerTool({
+  name: 'ios_download_crash_reports',
+  description: 'Download crash reports from device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    outputDirectory: z.string().describe('Directory to save crash reports'),
+    extract: z.boolean().optional().describe('Extract crash reports'),
+    keep: z.boolean().optional().describe('Keep reports on device'),
+  }),
+  handler: async ({ deviceId, outputDirectory, extract, keep }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.downloadCrashReports(outputDirectory, { extract, keep });
+  },
+});
+
+registerTool({
+  name: 'ios_get_diagnostics',
+  description: 'Get diagnostics information (WiFi, Battery, NAND, etc.)',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    type: z.enum(['All', 'WiFi', 'GasGauge', 'NAND', 'Battery', 'HDMI']).optional().default('All'),
+  }),
+  handler: async ({ deviceId, type }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.getDiagnostics(type);
+  },
+});
+
+registerTool({
+  name: 'ios_get_ioreg',
+  description: 'Get IO Registry information',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    plane: z.enum(['IODeviceTree', 'IOPower', 'IOService']).optional(),
+  }),
+  handler: async ({ deviceId, plane }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.getIORegistry(plane);
+  },
+});
+
+registerTool({
+  name: 'ios_get_mobilegestalt',
+  description: 'Get MobileGestalt values from device',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    keys: z.array(z.string()).describe('Keys to query'),
+  }),
+  handler: async ({ deviceId, keys }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.getMobileGestalt(...keys);
+  },
+});
+
+registerTool({
+  name: 'ios_start_bluetooth_logger',
+  description: 'Start Bluetooth packet logging',
+  inputSchema: z.object({
+    deviceId: z.string().describe('Device UDID'),
+    outputPath: z.string().optional().describe('Path to save logs'),
+  }),
+  handler: async ({ deviceId, outputPath }) => {
+    const lib = new LibIMobileDevice({ udid: deviceId });
+    return lib.startBluetoothLogging(outputPath);
+  },
+});