mobile-debug-mcp 0.5.0 → 0.7.0

package/test/wait_for_element_real.js

@@ -0,0 +1,67 @@
+import { AndroidInteract } from "../src/android/interact.js";
+import { AndroidObserve } from "../src/android/observe.js";
+// Configure ADB path and target via env vars or CLI args.
+// Usage: node test/wait_for_element_real.js [deviceId] [appId]
+// Priority: CLI args > environment variables
+const args = process.argv.slice(2);
+const DEVICE_ID = args[0] || process.env.DEVICE_ID;
+const APP_ID = args[1] || process.env.APP_ID;
+
+// Do not hard-code ADB_PATH here. If the user supplied ADB_PATH in the environment, leave it as-is.
+// (process.env.ADB_PATH may be set externally before running this script.)
+
+if (!DEVICE_ID || !APP_ID) {
+  console.error("Usage: node test/wait_for_element_real.js <deviceId> <appId> or set DEVICE_ID and APP_ID env vars");
+  process.exit(1);
+}
+async function runRealTest() {
+    console.log(`Connecting to device ${DEVICE_ID}...`);
+    const interact = new AndroidInteract();
+    const observe = new AndroidObserve();
+    try {
+        // 1. Start App
+        console.log(`\nStarting app ${APP_ID}...`);
+        await interact.startApp(APP_ID, DEVICE_ID);
+        // Give it a moment to render
+        console.log("Waiting 3s for app to render...");
+        await new Promise(r => setTimeout(r, 3000));
+        // 2. Get UI Tree to find a valid text target
+        console.log("\nFetching UI Tree to find a target text...");
+        const tree = await observe.getUITree(DEVICE_ID);
+        if (tree.error) {
+            console.error("Failed to get UI Tree:", tree.error);
+            return;
+        }
+        // Find first visible element with text
+        const targetElement = tree.elements.find(e => e.text && e.text.length > 0 && e.visible);
+        if (!targetElement || !targetElement.text) {
+            console.warn("No visible text elements found on screen to test with.");
+            console.log("Elements found:", tree.elements.length);
+            return;
+        }
+        const targetText = targetElement.text;
+        console.log(`Found target element: "${targetText}"`);
+        // 3. Test waitForElement (Success Case)
+        console.log(`\nTest 1: Waiting for existing element "${targetText}" (should succeed)...`);
+        const start1 = Date.now();
+        const result1 = await interact.waitForElement(targetText, 5000, DEVICE_ID);
+        const elapsed1 = Date.now() - start1;
+        console.log(`Result: ${result1.found ? "PASS" : "FAIL"}`);
+        console.log(`Found Element: ${result1.element?.text}`);
+        console.log(`Time taken: ${elapsed1}ms`);
+        // 4. Test waitForElement (Timeout Case)
+        const missingText = "THIS_TEXT_SHOULD_NOT_EXIST_XYZ_123";
+        console.log(`\nTest 2: Waiting for missing element "${missingText}" (should timeout)...`);
+        const start2 = Date.now();
+        // Use short timeout 2s
+        const result2 = await interact.waitForElement(missingText, 2000, DEVICE_ID);
+        const elapsed2 = Date.now() - start2;
+        console.log(`Result: ${!result2.found ? "PASS" : "FAIL"}`);
+        console.log(`Found: ${result2.found}`);
+        console.log(`Time taken: ${elapsed2}ms (expected ~2000ms)`);
+    }
+    catch (error) {
+        console.error("Test failed with error:", error);
+    }
+}
+runRealTest();

package/test-ui-tree.js

@@ -0,0 +1,68 @@
+/**
+ * Test script for verify UI Tree functionality.
+ *
+ * Usage:
+ *   npx tsx test-ui-tree.ts [android|ios] [deviceId]
+ *
+ * Examples:
+ *   npx tsx test-ui-tree.ts android
+ *   npx tsx test-ui-tree.ts ios booted
+ */
+import { AndroidObserve } from "./src/android/observe.js";
+import { iOSObserve } from "./src/ios/observe.js";
+async function main() {
+    const args = process.argv.slice(2);
+    const platform = (args[0] || 'android').toLowerCase();
+    const deviceId = args[1];
+    console.log(`Starting UI Tree Test for ${platform}...`);
+    if (deviceId)
+        console.log(`Targeting device: ${deviceId}`);
+    try {
+        let result;
+        if (platform === 'ios') {
+            const observer = new iOSObserve();
+            result = await observer.getUITree(deviceId || 'booted');
+        }
+        else {
+            const observer = new AndroidObserve();
+            result = await observer.getUITree(deviceId);
+        }
+        console.log("\nUI Tree Result Summary:");
+        console.log("-----------------------");
+        if (result.error) {
+            console.error("❌ Error:", result.error);
+            process.exit(1);
+        }
+        console.log(`Device: ${result.device.platform} (${result.device.model || 'Unknown Model'})`);
+        console.log(`Resolution: ${result.resolution.width}x${result.resolution.height}`);
+        console.log(`Elements Found: ${result.elements.length}`);
+        if (result.elements.length === 0) {
+            console.warn("⚠️ Warning: No elements found. Is the screen empty or locked?");
+        }
+        else {
+            // Print sample element to verify structure
+            const first = result.elements[0];
+            console.log("\nSample Element (First):");
+            console.log(JSON.stringify(first, null, 2));
+            // Check for new fields
+            if (first.center && first.depth !== undefined) {
+                console.log("\n✅ Verified 'center' and 'depth' fields exist.");
+            }
+            else {
+                console.error("\n❌ 'center' or 'depth' fields missing!");
+                process.exit(1);
+            }
+            // Check for filtering
+            const interactive = result.elements.filter(e => e.clickable).length;
+            const withText = result.elements.filter(e => e.text).length;
+            console.log(`\nStats:`);
+            console.log(`- Interactive elements: ${interactive}`);
+            console.log(`- Elements with text: ${withText}`);
+        }
+    }
+    catch (error) {
+        console.error("\n❌ Test Failed:", error);
+        process.exit(1);
+    }
+}
+main();

package/test-ui-tree.ts

@@ -0,0 +1,76 @@
+/**
+ * Test script for verify UI Tree functionality.
+ * 
+ * Usage:
+ *   npx tsx test-ui-tree.ts [android|ios] [deviceId]
+ * 
+ * Examples:
+ *   npx tsx test-ui-tree.ts android
+ *   npx tsx test-ui-tree.ts ios booted
+ */
+
+import { AndroidObserve } from "./src/android/observe.js";
+import { iOSObserve } from "./src/ios/observe.js";
+
+async function main() {
+  const args = process.argv.slice(2);
+  const platform = (args[0] || 'android').toLowerCase();
+  const deviceId = args[1];
+
+  console.log(`Starting UI Tree Test for ${platform}...`);
+  if (deviceId) console.log(`Targeting device: ${deviceId}`);
+
+  try {
+    let result;
+    
+    if (platform === 'ios') {
+        const observer = new iOSObserve();
+        result = await observer.getUITree(deviceId || 'booted');
+    } else {
+        const observer = new AndroidObserve();
+        result = await observer.getUITree(deviceId);
+    }
+
+    console.log("\nUI Tree Result Summary:");
+    console.log("-----------------------");
+    
+    if (result.error) {
+        console.error("❌ Error:", result.error);
+        process.exit(1);
+    }
+
+    console.log(`Device: ${result.device.platform} (${result.device.model || 'Unknown Model'})`);
+    console.log(`Resolution: ${result.resolution.width}x${result.resolution.height}`);
+    console.log(`Elements Found: ${result.elements.length}`);
+
+    if (result.elements.length === 0) {
+        console.warn("⚠️ Warning: No elements found. Is the screen empty or locked?");
+    } else {
+        // Print sample element to verify structure
+        const first = result.elements[0];
+        console.log("\nSample Element (First):");
+        console.log(JSON.stringify(first, null, 2));
+
+        // Check for new fields
+        if (first.center && first.depth !== undefined) {
+             console.log("\n✅ Verified 'center' and 'depth' fields exist.");
+        } else {
+             console.error("\n❌ 'center' or 'depth' fields missing!");
+             process.exit(1);
+        }
+        
+        // Check for filtering
+        const interactive = result.elements.filter(e => e.clickable).length;
+        const withText = result.elements.filter(e => e.text).length;
+        console.log(`\nStats:`);
+        console.log(`- Interactive elements: ${interactive}`);
+        console.log(`- Elements with text: ${withText}`);
+    }
+
+  } catch (error) {
+    console.error("\n❌ Test Failed:", error);
+    process.exit(1);
+  }
+}
+
+main();

package/tsconfig.json

@@ -6,7 +6,8 @@
     "rootDir": "src",
     "moduleResolution": "NodeNext",
     "strict": true,
+    "skipLibCheck": true,
     "esModuleInterop": true
   },
-  "exclude": ["smoke-test.ts"]
+  "exclude": ["smoke-test.ts", "test-ui-tree.ts"]
 }

package/src/android.ts

@@ -1,222 +0,0 @@
-import { execFile, spawn } from "child_process"
-import { StartAppResponse, GetLogsResponse, CaptureAndroidScreenResponse, TerminateAppResponse, RestartAppResponse, ResetAppDataResponse, DeviceInfo } from "./types.js"
-
-const ADB = process.env.ADB_PATH || "adb"
-
-// Helper to construct ADB args with optional device ID
-function getAdbArgs(args: string[], deviceId?: string): string[] {
-  if (deviceId) {
-    return ['-s', deviceId, ...args]
-  }
-  return args
-}
-
-function execAdb(args: string[], deviceId?: string, options: any = {}): Promise<string> {
-  const adbArgs = getAdbArgs(args, deviceId)
-  return new Promise((resolve, reject) => {
-    // Use spawn instead of execFile for better stream control and to avoid potential buffering hangs
-    const child = spawn(ADB, adbArgs, options)
-    
-    let stdout = ''
-    let stderr = ''
-
-    if (child.stdout) {
-      child.stdout.on('data', (data) => {
-        stdout += data.toString()
-      })
-    }
-
-    if (child.stderr) {
-      child.stderr.on('data', (data) => {
-        stderr += data.toString()
-      })
-    }
-
-    const timeoutMs = args.includes('logcat') ? 10000 : 2000 // Shorter timeout for metadata queries
-    const timeout = setTimeout(() => {
-      child.kill()
-      reject(new Error(`ADB command timed out after ${timeoutMs}ms: ${args.join(' ')}`))
-    }, timeoutMs)
-
-    child.on('close', (code) => {
-      clearTimeout(timeout)
-      if (code !== 0) {
-        // If there's an actual error (non-zero exit code), reject
-        reject(new Error(stderr.trim() || `Command failed with code ${code}`))
-      } else {
-        // If exit code is 0, resolve with stdout
-        resolve(stdout.trim())
-      }
-    })
-
-    child.on('error', (err) => {
-      clearTimeout(timeout)
-      reject(err)
-    })
-  })
-}
-
-function getDeviceInfo(deviceId: string, metadata: Partial<DeviceInfo> = {}): DeviceInfo {
-  return { 
-    platform: 'android', 
-    id: deviceId || 'default', 
-    osVersion: metadata.osVersion || '', 
-    model: metadata.model || '', 
-    simulator: metadata.simulator || false 
-  }
-}
-
-export async function getAndroidDeviceMetadata(appId: string, deviceId?: string): Promise<DeviceInfo> {
-  try {
-    // Run these in parallel to avoid sequential timeouts
-    const [osVersion, model, simOutput] = await Promise.all([
-      execAdb(['shell', 'getprop', 'ro.build.version.release'], deviceId).catch(() => ''),
-      execAdb(['shell', 'getprop', 'ro.product.model'], deviceId).catch(() => ''),
-      execAdb(['shell', 'getprop', 'ro.kernel.qemu'], deviceId).catch(() => '0')
-    ])
-    
-    const simulator = simOutput === '1'
-    return { platform: 'android', id: deviceId || 'default', osVersion, model, simulator }
-  } catch (e) {
-    return { platform: 'android', id: deviceId || 'default', osVersion: '', model: '', simulator: false }
-  }
-}
-
-export async function startAndroidApp(appId: string, deviceId?: string): Promise<StartAppResponse> {
-  const metadata = await getAndroidDeviceMetadata(appId, deviceId)
-  const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
-  
-  await execAdb(['shell', 'monkey', '-p', appId, '-c', 'android.intent.category.LAUNCHER', '1'], deviceId)
-  
-  return { device: deviceInfo, appStarted: true, launchTimeMs: 1000 }
-}
-
-export async function terminateAndroidApp(appId: string, deviceId?: string): Promise<TerminateAppResponse> {
-  const metadata = await getAndroidDeviceMetadata(appId, deviceId)
-  const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
-
-  await execAdb(['shell', 'am', 'force-stop', appId], deviceId)
-  
-  return { device: deviceInfo, appTerminated: true }
-}
-
-export async function restartAndroidApp(appId: string, deviceId?: string): Promise<RestartAppResponse> {
-  await terminateAndroidApp(appId, deviceId)
-  const startResult = await startAndroidApp(appId, deviceId)
-  return {
-    device: startResult.device,
-    appRestarted: startResult.appStarted,
-    launchTimeMs: startResult.launchTimeMs
-  }
-}
-
-export async function resetAndroidAppData(appId: string, deviceId?: string): Promise<ResetAppDataResponse> {
-  const metadata = await getAndroidDeviceMetadata(appId, deviceId)
-  const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
-
-  const output = await execAdb(['shell', 'pm', 'clear', appId], deviceId)
-  
-  return { device: deviceInfo, dataCleared: output === 'Success' }
-}
-
-export async function getAndroidLogs(appId?: string, lines = 200, deviceId?: string): Promise<GetLogsResponse> {
-  const metadata = await getAndroidDeviceMetadata(appId || "", deviceId)
-  const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
-
-  try {
-    // We'll skip PID lookup for now to avoid potential hangs with 'pidof' on some emulators
-    // and rely on robust string matching against the log line.
-    
-    // Get logs
-    const stdout = await execAdb(['logcat', '-d', '-t', lines.toString(), '-v', 'threadtime'], deviceId)
-    const allLogs = stdout.split('\n')
-    
-    let filteredLogs = allLogs
-    if (appId) {
-       // Filter by checking if the line contains the appId string.
-       const matchingLogs = allLogs.filter(line => line.includes(appId))
-       
-       if (matchingLogs.length > 0) {
-         filteredLogs = matchingLogs
-       } else {
-         // Fallback: if no logs match the appId, return the raw logs (last N lines)
-         // This matches the behavior of the "working" version provided by the user,
-         // ensuring they at least see system activity if the app is silent or crashing early.
-         filteredLogs = allLogs
-       }
-    }
-    
-    return { device: deviceInfo, logs: filteredLogs, logCount: filteredLogs.length }
-  } catch (e) {
-    console.error("Error fetching logs:", e)
-    return { device: deviceInfo, logs: [], logCount: 0 }
-  }
-}
-
-export async function captureAndroidScreen(deviceId?: string): Promise<CaptureAndroidScreenResponse> {
-  const metadata = await getAndroidDeviceMetadata("", deviceId)
-  const deviceInfo: DeviceInfo = getDeviceInfo(deviceId || 'default', metadata)
-
-  return new Promise((resolve, reject) => {
-    const adbArgs = getAdbArgs(['exec-out', 'screencap', '-p'], deviceId)
-    
-    // Using spawn for screencap as well to ensure consistent process handling
-    const child = spawn(ADB, adbArgs)
-    
-    const chunks: Buffer[] = []
-    let stderr = ''
-
-    child.stdout.on('data', (chunk) => {
-      chunks.push(Buffer.from(chunk))
-    })
-
-    child.stderr.on('data', (data) => {
-      stderr += data.toString()
-    })
-
-    const timeout = setTimeout(() => {
-      child.kill()
-      reject(new Error(`ADB screencap timed out after 10s`))
-    }, 10000)
-
-    child.on('close', (code) => {
-      clearTimeout(timeout)
-      if (code !== 0) {
-        reject(new Error(stderr.trim() || `Screencap failed with code ${code}`))
-        return
-      }
-
-      const screenshotBuffer = Buffer.concat(chunks)
-      const screenshotBase64 = screenshotBuffer.toString('base64')
-
-      // Get resolution
-      execAdb(['shell', 'wm', 'size'], deviceId)
-        .then(sizeStdout => {
-          let width = 0
-          let height = 0
-          const match = sizeStdout.match(/Physical size: (\d+)x(\d+)/)
-          if (match) {
-            width = parseInt(match[1], 10)
-            height = parseInt(match[2], 10)
-          }
-          resolve({
-            device: deviceInfo,
-            screenshot: screenshotBase64,
-            resolution: { width, height }
-          })
-        })
-        .catch(() => {
-           resolve({
-            device: deviceInfo,
-            screenshot: screenshotBase64,
-            resolution: { width: 0, height: 0 }
-          })
-        })
-    })
-
-    child.on('error', (err) => {
-      clearTimeout(timeout)
-      reject(err)
-    })
-  })
-}

package/src/ios.ts

@@ -1,243 +0,0 @@
-import { execFile, spawn } from "child_process"
-import { promises as fs } from "fs"
-import { pathToFileURL } from "url"
-import { StartAppResponse, GetLogsResponse, GetCrashResponse, CaptureIOSScreenshotResponse, TerminateAppResponse, RestartAppResponse, ResetAppDataResponse, DeviceInfo } from "./types.js"
-
-const XCRUN = process.env.XCRUN_PATH || "xcrun"
-
-interface IOSResult {
-  output: string
-  device: DeviceInfo
-}
-
-// Validate bundle ID to prevent any potential injection or invalid characters
-function validateBundleId(bundleId: string) {
-  if (!bundleId) return
-  // Allow alphanumeric, dots, hyphens, and underscores.
-  if (!/^[a-zA-Z0-9.\-_]+$/.test(bundleId)) {
-    throw new Error(`Invalid Bundle ID: ${bundleId}. Must contain only alphanumeric characters, dots, hyphens, or underscores.`)
-  }
-}
-
-function execCommand(args: string[], deviceId: string = "booted"): Promise<IOSResult> {
-  return new Promise((resolve, reject) => {
-    // Use spawn for better stream control and consistency with Android implementation
-    const child = spawn(XCRUN, args)
-    
-    let stdout = ''
-    let stderr = ''
-
-    if (child.stdout) {
-      child.stdout.on('data', (data) => {
-        stdout += data.toString()
-      })
-    }
-
-    if (child.stderr) {
-      child.stderr.on('data', (data) => {
-        stderr += data.toString()
-      })
-    }
-
-    const timeoutMs = args.includes('log') ? 10000 : 5000 // 10s for logs, 5s for others
-    const timeout = setTimeout(() => {
-      child.kill()
-      reject(new Error(`Command timed out after ${timeoutMs}ms: ${XCRUN} ${args.join(' ')}`))
-    }, timeoutMs)
-
-    child.on('close', (code) => {
-      clearTimeout(timeout)
-      if (code !== 0) {
-        reject(new Error(stderr.trim() || `Command failed with code ${code}`))
-      } else {
-        resolve({ output: stdout.trim(), device: { platform: "ios", id: deviceId } as DeviceInfo })
-      }
-    })
-
-    child.on('error', (err) => {
-      clearTimeout(timeout)
-      reject(err)
-    })
-  })
-}
-
-function parseRuntimeName(runtime: string): string {
-  // Example: com.apple.CoreSimulator.SimRuntime.iOS-17-0 -> iOS 17.0
-  try {
-    const parts = runtime.split('.')
-    const lastPart = parts[parts.length - 1]
-    return lastPart.replace(/-/g, ' ').replace('iOS ', 'iOS ') // Keep iOS prefix
-  } catch {
-    return runtime
-  }
-}
-
-export async function getIOSDeviceMetadata(deviceId: string = "booted"): Promise<DeviceInfo> {
-  return new Promise((resolve) => {
-    // If deviceId is provided (and not "booted"), we could try to list just that device.
-    // But listing all booted devices is usually fine to find the one we want or just one.
-    // Let's stick to listing all and filtering if needed, or just return basic info if we can't find it.
-    execFile(XCRUN, ['simctl', 'list', 'devices', 'booted', '--json'], (err, stdout) => {
-      // Default fallback
-      const fallback: DeviceInfo = {
-        platform: "ios",
-        id: deviceId,
-        osVersion: "Unknown",
-        model: "Simulator",
-        simulator: true,
-      }
-
-      if (err || !stdout) {
-        resolve(fallback)
-        return
-      }
-
-      try {
-        const data = JSON.parse(stdout)
-        const devicesMap = data.devices || {}
-        
-        // Find the device
-        for (const runtime in devicesMap) {
-          const devices = devicesMap[runtime]
-          if (Array.isArray(devices)) {
-            for (const device of devices) {
-              if (deviceId === "booted" || device.udid === deviceId) {
-                 resolve({
-                  platform: "ios",
-                  id: device.udid,
-                  osVersion: parseRuntimeName(runtime),
-                  model: device.name,
-                  simulator: true,
-                })
-                return
-              }
-            }
-          }
-        }
-        resolve(fallback)
-      } catch (error) {
-        resolve(fallback)
-      }
-    })
-  })
-}
-
-export async function startIOSApp(bundleId: string, deviceId: string = "booted"): Promise<StartAppResponse> {
-  validateBundleId(bundleId)
-  const result = await execCommand(['simctl', 'launch', deviceId, bundleId], deviceId)
-  const device = await getIOSDeviceMetadata(deviceId)
-  // Simulate launch time and appStarted for demonstration
-  return {
-    device,
-    appStarted: !!result.output,
-    launchTimeMs: 1000,
-  }
-}
-
-export async function terminateIOSApp(bundleId: string, deviceId: string = "booted"): Promise<TerminateAppResponse> {
-  validateBundleId(bundleId)
-  await execCommand(['simctl', 'terminate', deviceId, bundleId], deviceId)
-  const device = await getIOSDeviceMetadata(deviceId)
-  return {
-    device,
-    appTerminated: true
-  }
-}
-
-export async function restartIOSApp(bundleId: string, deviceId: string = "booted"): Promise<RestartAppResponse> {
-  // terminateIOSApp already validates bundleId
-  await terminateIOSApp(bundleId, deviceId)
-  const startResult = await startIOSApp(bundleId, deviceId)
-  return {
-    device: startResult.device,
-    appRestarted: startResult.appStarted,
-    launchTimeMs: startResult.launchTimeMs
-  }
-}
-
-export async function resetIOSAppData(bundleId: string, deviceId: string = "booted"): Promise<ResetAppDataResponse> {
-  validateBundleId(bundleId)
-  await terminateIOSApp(bundleId, deviceId)
-  const device = await getIOSDeviceMetadata(deviceId)
-  
-  // Get data container path
-  const containerResult = await execCommand(['simctl', 'get_app_container', deviceId, bundleId, 'data'], deviceId)
-  const dataPath = containerResult.output.trim()
-  
-  if (!dataPath) {
-    throw new Error(`Could not find data container for ${bundleId}`)
-  }
-
-  // Clear contents of Library and Documents
-  try {
-    const libraryPath = `${dataPath}/Library`
-    const documentsPath = `${dataPath}/Documents`
-    const tmpPath = `${dataPath}/tmp`
-    
-    await fs.rm(libraryPath, { recursive: true, force: true }).catch(() => {})
-    await fs.rm(documentsPath, { recursive: true, force: true }).catch(() => {})
-    await fs.rm(tmpPath, { recursive: true, force: true }).catch(() => {})
-
-    // Re-create empty directories as they are expected by apps
-    await fs.mkdir(libraryPath, { recursive: true }).catch(() => {})
-    await fs.mkdir(documentsPath, { recursive: true }).catch(() => {})
-    await fs.mkdir(tmpPath, { recursive: true }).catch(() => {})
-    
-    return {
-      device,
-      dataCleared: true
-    }
-  } catch (err) {
-    throw new Error(`Failed to clear data for ${bundleId}: ${err instanceof Error ? err.message : String(err)}`)
-  }
-}
-
-export async function getIOSLogs(appId?: string, deviceId: string = "booted"): Promise<GetLogsResponse> {
-  // If appId is provided, use predicate filtering
-  // Note: execFile passes args directly, so we don't need shell escaping for the predicate string itself,
-  // but we do need to construct the predicate correctly for log show.
-  const args = ['simctl', 'spawn', deviceId, 'log', 'show', '--style', 'syslog', '--last', '1m']
-  if (appId) {
-    validateBundleId(appId)
-    args.push('--predicate', `subsystem contains "${appId}" or process == "${appId}"`)
-  }
-  
-  const result = await execCommand(args, deviceId)
-  const device = await getIOSDeviceMetadata(deviceId)
-  const logs = result.output ? result.output.split('\n') : []
-  return {
-    device,
-    logs,
-    logCount: logs.length,
-  }
-}
-
-
-export async function captureIOSScreenshot(deviceId: string = "booted"): Promise<CaptureIOSScreenshotResponse> {
-  const device = await getIOSDeviceMetadata(deviceId)
-  const tmpFile = `/tmp/mcp-ios-screenshot-${Date.now()}.png`
-
-  try {
-    // 1. Capture screenshot to temp file
-    await execCommand(['simctl', 'io', deviceId, 'screenshot', tmpFile], deviceId)
-    
-    // 2. Read file as base64
-    const buffer = await fs.readFile(tmpFile)
-    const base64 = buffer.toString('base64')
-    
-    // 3. Clean up
-    await fs.rm(tmpFile).catch(() => {})
-
-    return {
-      device,
-      screenshot: base64,
-      // Default resolution since we can't easily parse it without extra libs
-      // Clients will read the real dimensions from the PNG header anyway
-      resolution: { width: 0, height: 0 },
-    }
-  } catch (err) {
-    // Ensure cleanup happens even on error
-    await fs.rm(tmpFile).catch(() => {})
-    throw new Error(`Failed to capture screenshot: ${err instanceof Error ? err.message : String(err)}`)
-  }
-}