mobile-debug-mcp 0.10.0 → 0.12.0

package/src/ios/manage.ts

@@ -0,0 +1,164 @@
+import { promises as fs } from "fs"
+import { spawn } from "child_process"
+import { StartAppResponse, TerminateAppResponse, RestartAppResponse, ResetAppDataResponse, InstallAppResponse } from "../types.js"
+import { execCommand, execCommandWithDiagnostics, getIOSDeviceMetadata, validateBundleId, getIdbCmd, findAppBundle } from "./utils.js"
+import path from "path"
+
+export class iOSManage {
+  async build(projectPath: string, _variant?: string): Promise<{ artifactPath: string, output?: string } | { error: string }> {
+    void _variant
+    try {
+      const files = await fs.readdir(projectPath).catch(() => [])
+      const workspace = files.find(f => f.endsWith('.xcworkspace'))
+      const proj = files.find(f => f.endsWith('.xcodeproj'))
+      if (!workspace && !proj) return { error: 'No Xcode project or workspace found' }
+
+      let buildArgs: string[]
+      if (workspace) {
+        const workspacePath = path.join(projectPath, workspace)
+        const scheme = workspace.replace(/\.xcworkspace$/, '')
+        buildArgs = ['-workspace', workspacePath, '-scheme', scheme, '-configuration', 'Debug', '-sdk', 'iphonesimulator', 'build']
+      } else {
+        const projectPathFull = path.join(projectPath, proj!)
+        const scheme = proj!.replace(/\.xcodeproj$/, '')
+        buildArgs = ['-project', projectPathFull, '-scheme', scheme, '-configuration', 'Debug', '-sdk', 'iphonesimulator', 'build']
+      }
+
+      await new Promise<void>((resolve, reject) => {
+        const xcodeCmd = process.env.XCODEBUILD_PATH || 'xcodebuild'
+        const proc = spawn(xcodeCmd, buildArgs, { cwd: projectPath })
+        let stderr = ''
+        proc.stderr?.on('data', d => stderr += d.toString())
+        proc.on('close', code => {
+          if (code === 0) resolve()
+          else reject(new Error(stderr || `xcodebuild failed with code ${code}`))
+        })
+        proc.on('error', err => reject(err))
+      })
+
+      const built = await findAppBundle(projectPath)
+      if (!built) return { error: 'Could not find .app after build' }
+      return { artifactPath: built }
+    } catch (e) {
+      return { error: e instanceof Error ? e.message : String(e) }
+    }
+  }
+
+  async installApp(appPath: string, deviceId: string = "booted"): Promise<InstallAppResponse> {
+    const device = await getIOSDeviceMetadata(deviceId)
+
+    try {
+      let toInstall = appPath
+
+      const stat = await fs.stat(appPath).catch(() => null)
+      if (stat && stat.isDirectory()) {
+        if (appPath.endsWith('.app')) {
+          toInstall = appPath
+        } else {
+          const found = await findAppBundle(appPath)
+          if (found) {
+            toInstall = found
+          } else {
+            // Reuse the existing build() implementation to avoid duplicating the xcodebuild logic
+            const buildRes = await this.build(appPath)
+            if ((buildRes as any).error) throw new Error((buildRes as any).error)
+            toInstall = (buildRes as any).artifactPath
+          }
+        }
+      }
+
+      try {
+          const res = await execCommand(['simctl', 'install', deviceId, toInstall], deviceId)
+          return { device, installed: true, output: res.output }
+        } catch (e) {
+          // Gather diagnostics for simctl failure
+          const diag = execCommandWithDiagnostics(['simctl', 'install', deviceId, toInstall], deviceId)
+          try {
+            const child = spawn(getIdbCmd(), ['--version'])
+            const idbExists = await new Promise<boolean>((resolve) => {
+              child.on('error', () => resolve(false));
+              child.on('close', (code) => resolve(code === 0));
+            });
+            if (idbExists) {
+              // attempt idb install via spawn but include diagnostics
+              await new Promise<void>((resolve, reject) => {
+                const proc = spawn(getIdbCmd(), ['install', toInstall, '--udid', device.id]);
+                let stderr = '';
+                proc.stderr.on('data', d => stderr += d.toString());
+                proc.on('close', code => {
+                  if (code === 0) resolve();
+                  else reject(new Error(stderr || `idb install failed with code ${code}`));
+                });
+                proc.on('error', err => reject(err));
+              });
+              return { device, installed: true }
+            }
+          } catch {}
+          return { device, installed: false, error: e instanceof Error ? e.message : String(e), diagnostics: diag }
+        }
+    } catch (e) {
+      return { device, installed: false, error: e instanceof Error ? e.message : String(e) }
+    }
+  }
+
+  async startApp(bundleId: string, deviceId: string = "booted"): Promise<StartAppResponse> {
+    validateBundleId(bundleId)
+    try {
+      const result = await execCommand(['simctl', 'launch', deviceId, bundleId], deviceId)
+      const device = await getIOSDeviceMetadata(deviceId)
+      return { device, appStarted: !!result.output, launchTimeMs: 1000 }
+    } catch (e:any) {
+      const diag = execCommandWithDiagnostics(['simctl', 'launch', deviceId, bundleId], deviceId)
+      const device = await getIOSDeviceMetadata(deviceId)
+      return { device, appStarted: false, launchTimeMs: 0, error: e instanceof Error ? e.message : String(e), diagnostics: diag } as any
+    }
+  }
+
+  async terminateApp(bundleId: string, deviceId: string = "booted"): Promise<TerminateAppResponse> {
+    validateBundleId(bundleId)
+    try {
+      await execCommand(['simctl', 'terminate', deviceId, bundleId], deviceId)
+      const device = await getIOSDeviceMetadata(deviceId)
+      return { device, appTerminated: true }
+    } catch (e:any) {
+      const diag = execCommandWithDiagnostics(['simctl', 'terminate', deviceId, bundleId], deviceId)
+      const device = await getIOSDeviceMetadata(deviceId)
+      return { device, appTerminated: false, error: e instanceof Error ? e.message : String(e), diagnostics: diag } as any
+    }
+  }
+
+  async restartApp(bundleId: string, deviceId: string = "booted"): Promise<RestartAppResponse> {
+    await this.terminateApp(bundleId, deviceId)
+    const startResult = await this.startApp(bundleId, deviceId)
+    return { device: startResult.device, appRestarted: startResult.appStarted, launchTimeMs: startResult.launchTimeMs }
+  }
+
+  async resetAppData(bundleId: string, deviceId: string = "booted"): Promise<ResetAppDataResponse> {
+    validateBundleId(bundleId)
+    await this.terminateApp(bundleId, deviceId)
+    const device = await getIOSDeviceMetadata(deviceId)
+    try {
+      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}`)
+
+      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(() => {})
+        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 (e) {
+        throw new Error(`Failed to clear data for ${bundleId}: ${e instanceof Error ? e.message : String(e)}`)
+      }
+    } catch (e:any) {
+      const diag = execCommandWithDiagnostics(['simctl', 'get_app_container', deviceId, bundleId, 'data'], deviceId)
+      return { device, dataCleared: false, error: e instanceof Error ? e.message : String(e), diagnostics: diag } as any
+    }
+  }
+}

package/src/ios/observe.ts

@@ -1,7 +1,10 @@
 import { spawn } from "child_process"
 import { promises as fs } from "fs"
 import { GetLogsResponse, CaptureIOSScreenshotResponse, GetUITreeResponse, UIElement, DeviceInfo } from "../types.js"
-import { execCommand, getIOSDeviceMetadata, validateBundleId, IDB } from "./utils.js"
+import { execCommand, getIOSDeviceMetadata, validateBundleId, getIdbCmd, getXcrunCmd, isIDBInstalled } from "./utils.js"
+import { createWriteStream, promises as fsPromises } from 'fs'
+import path from 'path'
+import { parseLogLine } from '../android/utils.js'
 
 // --- Helper Functions Specific to Observe ---
 
@@ -22,6 +25,17 @@ interface IDBElement {
 
 function parseIDBFrame(frame: any): [number, number, number, number] {
   if (!frame) return [0, 0, 0, 0];
+  // Handle string frames like "{{0, 0}, {402, 874}}"
+  if (typeof frame === 'string') {
+    const nums = frame.match(/-?\d+(?:\.\d+)?/g);
+    if (!nums || nums.length < 4) return [0, 0, 0, 0];
+    const x = Number(nums[0]);
+    const y = Number(nums[1]);
+    const w = Number(nums[2]);
+    const h = Number(nums[3]);
+    return [Math.round(x), Math.round(y), Math.round(x + w), Math.round(y + h)];
+  }
+
   const x = Number(frame.x || 0);
   const y = Number(frame.y || 0);
   const w = Number(frame.width || frame.w || 0);
@@ -99,14 +113,18 @@ function traverseIDBNode(node: IDBElement, elements: UIElement[], parentIndex: n
   return currentIndex;
 }
 
-// Check if IDB is installed
-async function isIDBInstalled(): Promise<boolean> {
-  return new Promise((resolve) => {
-    // Check if 'idb' is in path by trying to run it
-    const child = spawn(IDB, ['--version']);
-    child.on('error', () => resolve(false));
-    child.on('close', (code) => resolve(code === 0));
-  });
+
+
+// iOS live log stream support (moved from ios/utils to observe)
+const iosActiveLogStreams: Map<string, { proc: ReturnType<typeof import('child_process').spawn>, file: string }> = new Map()
+
+// Test helpers
+export function _setIOSActiveLogStream(sessionId: string, file: string) {
+  iosActiveLogStreams.set(sessionId, { proc: {} as any, file })
+}
+
+export function _clearIOSActiveLogStream(sessionId: string) {
+  iosActiveLogStreams.delete(sessionId)
 }
 
 export class iOSObserve {
@@ -192,13 +210,13 @@ export class iOSObserve {
          // Stabilization delay
          await delay(300 + (attempts * 100));
 
-         const args = ['ui', 'describe', '--json'];
+         const args = ['ui', 'describe-all', '--json'];
          if (targetUdid) {
             args.push('--udid', targetUdid);
          }
 
          const output = await new Promise<string>((resolve, reject) => {
-             const child = spawn(IDB, args);
+             const child = spawn(getIdbCmd(), args);
              let stdout = '';
              let stderr = '';
 
@@ -237,9 +255,14 @@ export class iOSObserve {
 
     try {
         const elements: UIElement[] = [];
-        const root = jsonContent;
-        
-        traverseIDBNode(root, elements);
+        // idb describe-all returns either a root object or an array of root nodes
+        if (Array.isArray(jsonContent)) {
+          for (const node of jsonContent) {
+            traverseIDBNode(node, elements);
+          }
+        } else {
+          traverseIDBNode(jsonContent, elements);
+        }
 
         // Infer resolution from root element if possible (usually the Window/Application frame)
         let width = 0;
@@ -266,4 +289,97 @@ export class iOSObserve {
          };
     }
   }
+
+  // --- Log stream methods ---
+  async startLogStream(bundleId: string, deviceId: string = 'booted', sessionId: string = 'default') : Promise<{ success: boolean; stream_started?: boolean; error?: string }> {
+    try {
+      const predicate = `process == "${bundleId}" or subsystem contains "${bundleId}"`
+
+      if (iosActiveLogStreams.has(sessionId)) {
+        try { iosActiveLogStreams.get(sessionId)!.proc.kill() } catch {}
+        iosActiveLogStreams.delete(sessionId)
+      }
+
+      const args = ['simctl', 'spawn', deviceId, 'log', 'stream', '--style', 'syslog', '--predicate', predicate]
+      const proc = spawn(getXcrunCmd(), args)
+
+      // Prepare output file
+      const tmpDir = process.env.TMPDIR || '/tmp'
+      const file = path.join(tmpDir, `mobile-debug-ios-log-${sessionId}.ndjson`)
+      const stream = createWriteStream(file, { flags: 'a' })
+
+      proc.stdout.on('data', (chunk) => {
+        const text = chunk.toString()
+        const lines = text.split(/\r?\n/).filter(Boolean)
+        for (const l of lines) {
+          const entry = parseLogLine(l)
+          stream.write(JSON.stringify(entry) + '\n')
+        }
+      })
+
+      proc.stderr.on('data', (chunk) => {
+        const text = chunk.toString()
+        const lines = text.split(/\r?\n/).filter(Boolean)
+        for (const l of lines) {
+          const entry = { timestamp: '', level: 'E', tag: 'xcrun', message: l }
+          stream.write(JSON.stringify(entry) + '\n')
+        }
+      })
+
+      proc.on('close', () => {
+        stream.end()
+        iosActiveLogStreams.delete(sessionId)
+      })
+
+      iosActiveLogStreams.set(sessionId, { proc, file })
+      return { success: true, stream_started: true }
+    } catch {
+      return { success: false, error: 'log_stream_start_failed' }
+    }
+  }
+
+  async stopLogStream(sessionId: string = 'default'): Promise<{ success: boolean }> {
+    const entry = iosActiveLogStreams.get(sessionId)
+    if (!entry) return { success: true }
+    try { entry.proc.kill() } catch {}
+    iosActiveLogStreams.delete(sessionId)
+    return { success: true }
+  }
+
+  async readLogStream(sessionId: string = 'default', limit: number = 100, since?: string): Promise<{ entries: any[], crash_summary?: { crash_detected: boolean, exception?: string, sample?: string } }> {
+    const entry = iosActiveLogStreams.get(sessionId)
+    if (!entry) return { entries: [] }
+    try {
+      const data = await fsPromises.readFile(entry.file, 'utf8').catch(() => '')
+      if (!data) return { entries: [], crash_summary: { crash_detected: false } }
+      const lines = data.split(/\r?\n/).filter(Boolean)
+      const parsed = lines.map(l => {
+        try {
+          return JSON.parse(l)
+        } catch {
+          return { message: l, _iso: null, crash: false }
+        }
+      })
+
+      let filtered = parsed
+      if (since) {
+        let sinceMs: number | null = null
+        if (/^\d+$/.test(since)) sinceMs = Number(since)
+        else {
+          const sDate = new Date(since)
+          if (!isNaN(sDate.getTime())) sinceMs = sDate.getTime()
+        }
+        if (sinceMs !== null) {
+          filtered = parsed.filter(p => p._iso && (new Date(p._iso).getTime() >= sinceMs))
+        }
+      }
+
+      const entries = filtered.slice(-Math.max(0, limit))
+      const crashEntry = entries.find(e => e.crash)
+      const crash_summary = crashEntry ? { crash_detected: true, exception: crashEntry.exception, sample: crashEntry.message } : { crash_detected: false }
+      return { entries, crash_summary }
+    } catch {
+      return { entries: [], crash_summary: { crash_detected: false } }
+    }
+  }
 }

package/src/ios/utils.ts

@@ -1,8 +1,76 @@
-import { execFile, spawn } from "child_process"
+import { execFile, spawn, execSync, spawnSync } from "child_process"
 import { DeviceInfo } from "../types.js"
+import { promises as fsPromises } from 'fs'
+import path from 'path'
+import { makeEnvSnapshot } from '../utils/diagnostics.js'
+
+export function getXcrunCmd() { return process.env.XCRUN_PATH || 'xcrun' }
+
+export function getConfiguredIdbPath(): string | undefined {
+  if (process.env.MCP_IDB_PATH) return process.env.MCP_IDB_PATH
+  if (process.env.IDB_PATH) return process.env.IDB_PATH
+  const cfgPaths = [
+    process.env.MCP_CONFIG_PATH || (process.env.HOME ? `${process.env.HOME}/.mcp/config.json` : ''),
+    `${process.cwd()}/mcp.config.json`
+  ]
+  try {
+    const fs = require('fs')
+    for (const p of cfgPaths) {
+      if (!p) continue
+      try {
+        if (fs.existsSync(p)) {
+          const raw = fs.readFileSync(p, 'utf8')
+          const json = JSON.parse(raw)
+          if (json) {
+            if (json.idbPath) return json.idbPath
+            if (json.IDB_PATH) return json.IDB_PATH
+          }
+        }
+      } catch {}
+    }
+  } catch {}
+  return undefined
+}
 
-export const XCRUN = process.env.XCRUN_PATH || "xcrun"
-export const IDB = "idb"
+export function getIdbCmd() {
+  const cfg = getConfiguredIdbPath()
+  if (cfg) return cfg
+  if (process.env.IDB_PATH) return process.env.IDB_PATH
+  try {
+    const p = execSync('which idb', { stdio: ['ignore','pipe','ignore'] }).toString().trim()
+    if (p) return p
+  } catch {}
+  try {
+    const p2 = execSync('command -v idb', { stdio: ['ignore','pipe','ignore'] }).toString().trim()
+    if (p2) return p2
+  } catch {}
+  // check common user locations
+  const common = [
+    `${process.env.HOME}/Library/Python/3.9/bin/idb`,
+    `${process.env.HOME}/Library/Python/3.10/bin/idb`,
+    '/opt/homebrew/bin/idb',
+    '/usr/local/bin/idb',
+  ]
+  for (const c of common) {
+    try { execSync(`test -x ${c}`, { stdio: ['ignore','pipe','ignore'] }); return c } catch {}
+  }
+  return 'idb'
+}
+
+export async function isIDBInstalled(): Promise<boolean> {
+  const cmd = getIdbCmd()
+  try {
+    execSync(`command -v ${cmd}`, { stdio: ['ignore','pipe','ignore'] })
+    return true
+  } catch {
+    try {
+      execSync(`${cmd} list-targets --json`, { stdio: ['ignore','pipe','ignore'], timeout: 2000 })
+      return true
+    } catch {
+      return false
+    }
+  }
+}
 
 export interface IOSResult {
   output: string
@@ -21,7 +89,7 @@ export function validateBundleId(bundleId: string) {
 export 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)
+    const child = spawn(getXcrunCmd(), args)
     
     let stdout = ''
     let stderr = ''
@@ -38,10 +106,12 @@ export function execCommand(args: string[], deviceId: string = "booted"): Promis
       })
     }
 
-    const timeoutMs = args.includes('log') ? 10000 : 5000 // 10s for logs, 5s for others
+    const DEFAULT_XCRUN_LOG_TIMEOUT = parseInt(process.env.MCP_XCRUN_LOG_TIMEOUT || '', 10) || 30000 // env (ms) or default 30s
+  const DEFAULT_XCRUN_CMD_TIMEOUT = parseInt(process.env.MCP_XCRUN_TIMEOUT || '', 10) || 60000 // env (ms) or default 60s
+  const timeoutMs = args.includes('log') ? DEFAULT_XCRUN_LOG_TIMEOUT : DEFAULT_XCRUN_CMD_TIMEOUT // choose appropriate timeout
     const timeout = setTimeout(() => {
       child.kill()
-      reject(new Error(`Command timed out after ${timeoutMs}ms: ${XCRUN} ${args.join(' ')}`))
+      reject(new Error(`Command timed out after ${timeoutMs}ms: ${getXcrunCmd()} ${args.join(' ')}`))
     }, timeoutMs)
 
     child.on('close', (code) => {
@@ -60,6 +130,39 @@ export function execCommand(args: string[], deviceId: string = "booted"): Promis
   })
 }
 
+export function execCommandWithDiagnostics(args: string[], deviceId: string = "booted") {
+  // Run synchronously to capture stdout/stderr and exitCode reliably for diagnostics
+  const DEFAULT_XCRUN_LOG_TIMEOUT = parseInt(process.env.MCP_XCRUN_LOG_TIMEOUT || '', 10) || 30000
+  const DEFAULT_XCRUN_CMD_TIMEOUT = parseInt(process.env.MCP_XCRUN_TIMEOUT || '', 10) || 60000
+  const timeoutMs = args.includes('log') ? DEFAULT_XCRUN_LOG_TIMEOUT : DEFAULT_XCRUN_CMD_TIMEOUT
+  const res = spawnSync(getXcrunCmd(), args, { encoding: 'utf8', timeout: timeoutMs }) as any
+  const runResult = {
+    exitCode: typeof res.status === 'number' ? res.status : null,
+    stdout: res.stdout || '',
+    stderr: res.stderr || '',
+    envSnapshot: makeEnvSnapshot(['PATH','IDB_PATH','JAVA_HOME','HOME']),
+    command: getXcrunCmd(),
+    args,
+    deviceId
+  }
+
+  if (res.status !== 0) {
+    // include suggested fixes for common errors
+    const suggested: string[] = []
+    if ((runResult.stderr || '').includes('xcodebuild: error')) {
+      suggested.push('Ensure the project/workspace path is correct and xcodebuild is installed and accessible.')
+    }
+    if ((runResult.stderr || '').includes('No such file or directory') || (runResult.stderr || '').includes('not found')) {
+      suggested.push('Check that Xcode Command Line Tools are installed and XCRUN_PATH is set if using non-standard location.')
+    }
+
+    // Return diagnostics object
+    return { runResult: { ...runResult, suggestedFixes: suggested } }
+  }
+
+  return { runResult: { ...runResult, suggestedFixes: [] } }
+}
+
 function parseRuntimeName(runtime: string): string {
   // Example: com.apple.CoreSimulator.SimRuntime.iOS-17-0 -> iOS 17.0
   try {
@@ -82,13 +185,22 @@ function parseRuntimeName(runtime: string): string {
   }
 }
 
+export async function findAppBundle(dir: string): Promise<string | undefined> {
+  const entries = await fsPromises.readdir(dir, { withFileTypes: true }).catch(() => [])
+  for (const e of entries) {
+    const full = path.join(dir, e.name)
+    if (e.isDirectory()) {
+      if (full.endsWith('.app')) return full
+      const found = await findAppBundle(full)
+      if (found) return found
+    }
+  }
+  return undefined
+}
 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
+    // If deviceId is provided (and not "booted"), attempt to find that device among booted simulators.
+    execFile(getXcrunCmd(), ['simctl', 'list', 'devices', 'booted', '--json'], (err, stdout) => {
       const fallback: DeviceInfo = {
         platform: "ios",
         id: deviceId,
@@ -105,14 +217,13 @@ export async function getIOSDeviceMetadata(deviceId: string = "booted"): Promise
       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({
+                resolve({
                   platform: "ios",
                   id: device.udid,
                   osVersion: parseRuntimeName(runtime),
@@ -124,6 +235,7 @@ export async function getIOSDeviceMetadata(deviceId: string = "booted"): Promise
             }
           }
         }
+
         resolve(fallback)
       } catch {
         resolve(fallback)
@@ -134,7 +246,7 @@ export async function getIOSDeviceMetadata(deviceId: string = "booted"): Promise
 
 export async function listIOSDevices(appId?: string): Promise<DeviceInfo[]> {
   return new Promise((resolve) => {
-    execFile(XCRUN, ['simctl', 'list', 'devices', '--json'], (err, stdout) => {
+    execFile(getXcrunCmd(), ['simctl', 'list', 'devices', '--json'], (err, stdout) => {
       if (err || !stdout) return resolve([])
       try {
         const data = JSON.parse(stdout)
@@ -175,116 +287,3 @@ export async function listIOSDevices(appId?: string): Promise<DeviceInfo[]> {
     })
   })
 }
-
-// --- iOS live log stream support ---
-import { createWriteStream, promises as fsPromises } from 'fs'
-import path from 'path'
-import { parseLogLine } from '../android/utils.js'
-
-const iosActiveLogStreams: Map<string, { proc: ReturnType<typeof import('child_process').spawn>, file: string }> = new Map()
-
-// Test helpers
-export function _setIOSActiveLogStream(sessionId: string, file: string) {
-  iosActiveLogStreams.set(sessionId, { proc: {} as any, file })
-}
-
-export function _clearIOSActiveLogStream(sessionId: string) {
-  iosActiveLogStreams.delete(sessionId)
-}
-
-export async function startIOSLogStream(bundleId: string, deviceId: string = 'booted', sessionId: string = 'default') : Promise<{ success: boolean; stream_started?: boolean; error?: string }> {
-  try {
-    // Build predicate to filter by process or subsystem
-    const predicate = `process == "${bundleId}" or subsystem contains "${bundleId}"`
-
-    // Prevent multiple streams per session
-    if (iosActiveLogStreams.has(sessionId)) {
-      try { iosActiveLogStreams.get(sessionId)!.proc.kill() } catch {}
-      iosActiveLogStreams.delete(sessionId)
-    }
-
-    // Start simctl log stream: xcrun simctl spawn <device> log stream --style syslog --predicate '<predicate>'
-    const args = ['simctl', 'spawn', deviceId, 'log', 'stream', '--style', 'syslog', '--predicate', predicate]
-    const proc = spawn(XCRUN, args)
-
-    // Prepare output file
-    const tmpDir = process.env.TMPDIR || '/tmp'
-    const file = path.join(tmpDir, `mobile-debug-ios-log-${sessionId}.ndjson`)
-    const stream = createWriteStream(file, { flags: 'a' })
-
-    proc.stdout.on('data', (chunk) => {
-      const text = chunk.toString()
-      const lines = text.split(/\r?\n/).filter(Boolean)
-      for (const l of lines) {
-        // Try to parse with shared parser; parser may be optimized for Android but extracts exceptions and message
-        const entry = parseLogLine(l)
-        stream.write(JSON.stringify(entry) + '\n')
-      }
-    })
-
-    proc.stderr.on('data', (chunk) => {
-      const text = chunk.toString()
-      const lines = text.split(/\r?\n/).filter(Boolean)
-      for (const l of lines) {
-        const entry = { timestamp: '', level: 'E', tag: 'xcrun', message: l }
-        stream.write(JSON.stringify(entry) + '\n')
-      }
-    })
-
-    proc.on('close', () => {
-      stream.end()
-      iosActiveLogStreams.delete(sessionId)
-    })
-
-    iosActiveLogStreams.set(sessionId, { proc, file })
-    return { success: true, stream_started: true }
-  } catch {
-    return { success: false, error: 'log_stream_start_failed' }
-  }
-}
-
-export async function stopIOSLogStream(sessionId: string = 'default'): Promise<{ success: boolean }> {
-  const entry = iosActiveLogStreams.get(sessionId)
-  if (!entry) return { success: true }
-  try { entry.proc.kill() } catch {}
-  iosActiveLogStreams.delete(sessionId)
-  return { success: true }
-}
-
-export async function readIOSLogStreamLines(sessionId: string = 'default', limit: number = 100, since?: string): Promise<{ entries: any[], crash_summary?: { crash_detected: boolean, exception?: string, sample?: string } }> {
-  const entry = iosActiveLogStreams.get(sessionId)
-  if (!entry) return { entries: [] }
-  try {
-    const data = await fsPromises.readFile(entry.file, 'utf8').catch(() => '')
-    if (!data) return { entries: [], crash_summary: { crash_detected: false } }
-    const lines = data.split(/\r?\n/).filter(Boolean)
-    const parsed = lines.map(l => {
-      try {
-        return JSON.parse(l)
-      } catch {
-        return { message: l, _iso: null, crash: false }
-      }
-    })
-
-    // Minimal since filtering if provided
-    let filtered = parsed
-    if (since) {
-      let sinceMs: number | null = null
-      if (/^\d+$/.test(since)) sinceMs = Number(since)
-      else {
-        const sDate = new Date(since)
-        if (!isNaN(sDate.getTime())) sinceMs = sDate.getTime()
-      }
-      if (sinceMs !== null) {
-        filtered = parsed.filter(p => p._iso && (new Date(p._iso).getTime() >= sinceMs))
-      }
-    }
-
-    const entries = filtered.slice(-Math.max(0, limit))
-    const crashEntry = entries.find(e => e.crash)
-    const crash_summary = crashEntry ? { crash_detected: true, exception: crashEntry.exception, sample: crashEntry.message } : { crash_detected: false }
-    return { entries, crash_summary }
-  } catch {
-    return { entries: [], crash_summary: { crash_detected: false } }
-  }
-}