@ebowwa/mcp-ios-devices 1.0.0

package/dist/tools/location.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Location Tools
+ * Simulate GPS location on devices
+ */
+export {};
+//# sourceMappingURL=location.d.ts.map

package/dist/tools/location.js

@@ -0,0 +1,32 @@
+/**
+ * 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();
+    },
+});
+//# sourceMappingURL=location.js.map

package/dist/tools/log.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Logging & Diagnostics Tools
+ * Collect logs and diagnostic information from iOS devices
+ */
+export {};
+//# sourceMappingURL=log.d.ts.map

package/dist/tools/log.js

@@ -0,0 +1,109 @@
+/**
+ * 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);
+    },
+});
+//# sourceMappingURL=log.js.map

package/dist/tools/process.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Process Management Tools
+ * List, launch, terminate, and signal processes on iOS devices
+ */
+export {};
+//# sourceMappingURL=process.d.ts.map

package/dist/tools/process.js

@@ -0,0 +1,100 @@
+/**
+ * Process Management Tools
+ * List, launch, terminate, and signal processes 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_processes',
+    description: 'List all running processes on a device',
+    inputSchema: z.object({
+        deviceId: z.string().describe('Device UDID'),
+    }),
+    handler: async ({ deviceId }) => {
+        return deviceCtl.listProcesses(deviceId);
+    },
+});
+registerTool({
+    name: 'ios_launch_app',
+    description: 'Launch an app on the device',
+    inputSchema: z.object({
+        deviceId: z.string().describe('Device UDID'),
+        bundleId: z.string().describe('App bundle identifier (e.g., com.apple.MobileSMS)'),
+        arguments: z.array(z.string()).optional().describe('Arguments to pass to the app'),
+        environment: z.record(z.string()).optional().describe('Environment variables'),
+    }),
+    handler: async ({ deviceId, bundleId, arguments: args, environment }) => {
+        return deviceCtl.launchApp(deviceId, bundleId, { arguments: args, environment });
+    },
+});
+registerTool({
+    name: 'ios_terminate_process',
+    description: 'Terminate a process by PID or name',
+    inputSchema: z.object({
+        deviceId: z.string().describe('Device UDID'),
+        process: z.union([z.number(), z.string()]).describe('Process PID (number) or name (string)'),
+    }),
+    handler: async ({ deviceId, process }) => {
+        return deviceCtl.terminateProcess(deviceId, process);
+    },
+});
+registerTool({
+    name: 'ios_signal_process',
+    description: 'Send a signal to a process',
+    inputSchema: z.object({
+        deviceId: z.string().describe('Device UDID'),
+        pid: z.number().describe('Process ID'),
+        signal: z.enum(['SIGTERM', 'SIGKILL', 'SIGHUP', 'SIGINT', 'SIGSTOP', 'SIGCONT', 'SIGUSR1', 'SIGUSR2']),
+    }),
+    handler: async ({ deviceId, pid, signal }) => {
+        return deviceCtl.signalProcess(deviceId, pid, signal);
+    },
+});
+registerTool({
+    name: 'ios_suspend_process',
+    description: 'Suspend a running process',
+    inputSchema: z.object({
+        deviceId: z.string().describe('Device UDID'),
+        pid: z.number().describe('Process ID'),
+    }),
+    handler: async ({ deviceId, pid }) => {
+        return deviceCtl.suspendProcess(deviceId, pid);
+    },
+});
+registerTool({
+    name: 'ios_resume_process',
+    description: 'Resume a suspended process',
+    inputSchema: z.object({
+        deviceId: z.string().describe('Device UDID'),
+        pid: z.number().describe('Process ID'),
+    }),
+    handler: async ({ deviceId, pid }) => {
+        return deviceCtl.resumeProcess(deviceId, pid);
+    },
+});
+registerTool({
+    name: 'ios_send_memory_warning',
+    description: 'Send a memory warning to a process',
+    inputSchema: z.object({
+        deviceId: z.string().describe('Device UDID'),
+        pid: z.number().describe('Process ID'),
+    }),
+    handler: async ({ deviceId, pid }) => {
+        return deviceCtl.sendMemoryWarning(deviceId, pid);
+    },
+});
+registerTool({
+    name: 'ios_post_notification',
+    description: 'Post a Darwin notification to the device',
+    inputSchema: z.object({
+        deviceId: z.string().describe('Device UDID'),
+        name: z.string().describe('Notification name'),
+        userInfo: z.record(z.any()).optional().describe('Optional user info dictionary'),
+    }),
+    handler: async ({ deviceId, name, userInfo }) => {
+        return deviceCtl.postNotification(deviceId, name, userInfo);
+    },
+});
+//# sourceMappingURL=process.js.map

package/dist/tools/profile.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Provisioning Profile Tools
+ * Manage provisioning profiles on devices
+ */
+export {};
+//# sourceMappingURL=profile.d.ts.map

package/dist/tools/profile.js

@@ -0,0 +1,52 @@
+/**
+ * Provisioning Profile Tools
+ * Manage provisioning profiles on devices
+ */
+import { z } from 'zod';
+import { registerTool } from '../registry.js';
+import { LibIMobileDevice } from '@ebowwa/ios-devices';
+registerTool({
+    name: 'ios_list_profiles',
+    description: 'List installed provisioning profiles',
+    inputSchema: z.object({
+        deviceId: z.string().describe('Device UDID'),
+    }),
+    handler: async ({ deviceId }) => {
+        const lib = new LibIMobileDevice({ udid: deviceId });
+        return lib.listProfiles();
+    },
+});
+registerTool({
+    name: 'ios_install_profile',
+    description: 'Install a provisioning profile',
+    inputSchema: z.object({
+        deviceId: z.string().describe('Device UDID'),
+        profilePath: z.string().describe('Path to .mobileprovision file'),
+    }),
+    handler: async ({ deviceId, profilePath }) => {
+        const lib = new LibIMobileDevice({ udid: deviceId });
+        return lib.installProfile(profilePath);
+    },
+});
+registerTool({
+    name: 'ios_remove_profile',
+    description: 'Remove a provisioning profile',
+    inputSchema: z.object({
+        deviceId: z.string().describe('Device UDID'),
+        uuid: z.string().describe('Profile UUID'),
+    }),
+    handler: async ({ deviceId, uuid }) => {
+        const lib = new LibIMobileDevice({ udid: deviceId });
+        return lib.removeProfile(uuid);
+    },
+});
+registerTool({
+    name: 'ios_list_dev_mode',
+    description: 'List developer mode status for devices',
+    inputSchema: z.object({}),
+    handler: async () => {
+        const lib = new LibIMobileDevice();
+        return lib.listDevMode();
+    },
+});
+//# sourceMappingURL=profile.js.map

package/dist/tools/screenshot.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Screenshot Tools
+ * Capture screenshots from devices
+ */
+export {};
+//# sourceMappingURL=screenshot.d.ts.map

package/dist/tools/screenshot.js

@@ -0,0 +1,20 @@
+/**
+ * Screenshot Tools
+ * Capture screenshots from devices
+ */
+import { z } from 'zod';
+import { registerTool } from '../registry.js';
+import { LibIMobileDevice } from '@ebowwa/ios-devices';
+registerTool({
+    name: 'ios_screenshot',
+    description: 'Take a screenshot of the device screen',
+    inputSchema: z.object({
+        deviceId: z.string().describe('Device UDID'),
+        outputPath: z.string().optional().describe('Output file path (.tiff)'),
+    }),
+    handler: async ({ deviceId, outputPath }) => {
+        const lib = new LibIMobileDevice({ udid: deviceId });
+        return lib.takeScreenshot(outputPath);
+    },
+});
+//# sourceMappingURL=screenshot.js.map

package/dist/tools/simulator.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Simulator Tools
+ * Control iOS Simulator via simctl
+ */
+export {};
+//# sourceMappingURL=simulator.d.ts.map