mobile-debug-mcp 0.12.0 → 0.12.2

package/src/ios/manage.ts

@@ -1,44 +1,191 @@
 import { promises as fs } from "fs"
-import { spawn } from "child_process"
+import { spawn, spawnSync } 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 }> {
+  async build(projectPath: string, _variant?: string): Promise<{ artifactPath: string, output?: string } | { error: string, diagnostics?: any }> {
     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' }
+      // Look for an Xcode workspace or project at the provided path. If not present, scan subdirectories (limited depth)
+      async function findProject(root: string, maxDepth = 3): Promise<{ dir: string, workspace?: string, proj?: string } | null> {
+        try {
+          const ents = await fs.readdir(root, { withFileTypes: true }).catch(() => [])
+          for (const e of ents) {
+            // .xcworkspace and .xcodeproj are directories on disk (bundles), not regular files
+            if (e.name.endsWith('.xcworkspace')) return { dir: root, workspace: e.name }
+            if (e.name.endsWith('.xcodeproj')) return { dir: root, proj: e.name }
+          }
+        } catch {}
+
+        if (maxDepth <= 0) return null
+
+        try {
+          const ents = await fs.readdir(root, { withFileTypes: true }).catch(() => [])
+          for (const e of ents) {
+            if (e.isDirectory()) {
+              const candidate = await findProject(path.join(root, e.name), maxDepth - 1)
+              if (candidate) return candidate
+            }
+          }
+        } catch {}
+
+        return null
+      }
+
+      // Resolve projectPath to an absolute path to avoid cwd-relative resolution issues
+      const absProjectPath = path.resolve(projectPath)
+      const projectInfo = await findProject(absProjectPath, 3)
+      if (!projectInfo) return { error: 'No Xcode project or workspace found' }
+      const projectRootDir = projectInfo.dir || absProjectPath
+      const workspace = projectInfo.workspace
+      const proj = projectInfo.proj
+
+      // Determine destination: prefer explicit env var, otherwise use booted simulator UDID
+      let destinationUDID = process.env.MCP_XCODE_DESTINATION_UDID || process.env.MCP_XCODE_DESTINATION || ''
+      if (!destinationUDID) {
+        try {
+          const meta = await getIOSDeviceMetadata('booted')
+          if (meta && meta.id) destinationUDID = meta.id
+        } catch {}
+      }
+
+      // Determine xcode command early so it can be used when detecting schemes
+      const xcodeCmd = process.env.XCODEBUILD_PATH || 'xcodebuild'
+
+      // Determine available schemes by querying xcodebuild -list rather than guessing
+      async function detectScheme(xcodeCmdInner: string, workspacePath?: string, projectPathFull?: string, cwd?: string): Promise<string | null> {
+        try {
+          const args = workspacePath ? ['-list', '-workspace', workspacePath] : ['-list', '-project', projectPathFull!]
+          // Run xcodebuild directly to list schemes
+          const res = spawnSync(xcodeCmdInner, args, { cwd: cwd || projectRootDir, encoding: 'utf8', timeout: 20000 })
+          const out = res.stdout || ''
+          const schemesMatch = out.match(/Schemes:\s*\n([\s\S]*?)(?:\n\n|$)/m)
+          if (schemesMatch) {
+            const block = schemesMatch[1]
+            const schemes = block.split(/\n/).map(s => s.trim()).filter(Boolean)
+            if (schemes.length) return schemes[0]
+          }
+        } catch {}
+        return null
+      }
 
       let buildArgs: string[]
+      let chosenScheme: string | null = null
       if (workspace) {
-        const workspacePath = path.join(projectPath, workspace)
-        const scheme = workspace.replace(/\.xcworkspace$/, '')
+        const workspacePath = path.join(projectRootDir, workspace)
+        chosenScheme = await detectScheme(xcodeCmd, workspacePath, undefined, projectRootDir)
+        const scheme = chosenScheme || 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$/, '')
+        const projectPathFull = path.join(projectRootDir, proj!)
+        chosenScheme = await detectScheme(xcodeCmd, undefined, projectPathFull, projectRootDir)
+        const scheme = chosenScheme || 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}`))
+      // If we have a destination UDID, add an explicit destination to avoid xcodebuild picking an ambiguous target
+      if (destinationUDID) {
+        buildArgs.push('-destination', `platform=iOS Simulator,id=${destinationUDID}`)
+      }
+
+      // Add result bundle path for diagnostics
+      const resultsDir = path.join(projectPath, 'build-results')
+      // Remove any stale results to avoid xcodebuild complaining about existing result bundles
+      await fs.rm(resultsDir, { recursive: true, force: true }).catch(() => {})
+      await fs.mkdir(resultsDir, { recursive: true }).catch(() => {})
+      // Skip specifying -resultBundlePath to avoid platform-specific collisions; rely on stdout/stderr logs
+
+
+      const XCODEBUILD_TIMEOUT = parseInt(process.env.MCP_XCODEBUILD_TIMEOUT || '', 10) || 180000 // default 3 minutes
+      const MAX_RETRIES = parseInt(process.env.MCP_XCODEBUILD_RETRIES || '', 10) || 1
+
+      const tries = MAX_RETRIES + 1
+      let lastStdout = ''
+      let lastStderr = ''
+      let lastErr: any = null
+
+      for (let attempt = 1; attempt <= tries; attempt++) {
+        // Run xcodebuild with a watchdog
+        const res = await new Promise<{ code: number | null, stdout: string, stderr: string, killedByWatchdog?: boolean }>((resolve) => {
+          const proc = spawn(xcodeCmd, buildArgs, { cwd: projectRootDir })
+          let stdout = ''
+          let stderr = ''
+
+          proc.stdout?.on('data', d => stdout += d.toString())
+          proc.stderr?.on('data', d => stderr += d.toString())
+
+          let killed = false
+          const to = setTimeout(() => {
+            killed = true
+            try { proc.kill('SIGKILL') } catch {}
+          }, XCODEBUILD_TIMEOUT)
+
+          proc.on('close', (code) => {
+            clearTimeout(to)
+            resolve({ code, stdout, stderr, killedByWatchdog: killed })
+          })
+          proc.on('error', (err) => {
+            clearTimeout(to)
+            resolve({ code: null, stdout, stderr: String(err), killedByWatchdog: killed })
+          })
         })
-        proc.on('error', err => reject(err))
-      })
 
+        lastStdout = res.stdout
+        lastStderr = res.stderr
+
+        if (res.code === 0) {
+          // success — clear any previous error and stop retrying
+          lastErr = null
+          break
+        }
+
+        // record the failure for reporting
+        lastErr = new Error(res.stderr || `xcodebuild failed with code ${res.code}`)
+        // Attach exit code and watchdog info so diagnostics can include them
+        ;(lastErr as any).code = res.code
+        ;(lastErr as any).exitCode = res.code
+        ;(lastErr as any).killedByWatchdog = !!res.killedByWatchdog
+
+        // write logs for diagnostics (helpful whether killed or not)
+        try {
+          await fs.writeFile(path.join(resultsDir, `xcodebuild-${attempt}.stdout.log`), res.stdout).catch(() => {})
+          await fs.writeFile(path.join(resultsDir, `xcodebuild-${attempt}.stderr.log`), res.stderr).catch(() => {})
+        } catch {}
+
+        // If killed by watchdog and there are remaining attempts, continue to retry
+        if (res.killedByWatchdog && attempt < tries) {
+          continue
+        }
+
+        // no more retries or not a watchdog kill — break to report lastErr
+        if (attempt >= tries) break
+      }
+
+      if (lastErr) {
+        // Include diagnostics and result bundle path when available; provide structured info useful for agents
+        const invokedCommand = `${xcodeCmd} ${buildArgs.map(a => a.includes(' ') ? `"${a}"` : a).join(' ')}`
+        const envSnapshot = { PATH: process.env.PATH }
+        return { error: `xcodebuild failed: ${lastErr.message}. See build-results for logs.`, output: `stdout:\n${lastStdout}\nstderr:\n${lastStderr}`, diagnostics: { exitCode: (lastErr as any).code || null, invokedCommand, cwd: projectRootDir, envSnapshot } }
+      }
+
+      // Try to locate built .app. First search project tree, then DerivedData if necessary
       const built = await findAppBundle(projectPath)
-      if (!built) return { error: 'Could not find .app after build' }
-      return { artifactPath: built }
+      if (built) return { artifactPath: built }
+
+      // Fallback: search DerivedData for matching product
+      const dd = path.join(process.env.HOME || '', 'Library', 'Developer', 'Xcode', 'DerivedData')
+      try {
+        const entries = await fs.readdir(dd).catch(() => [])
+        for (const e of entries) {
+          const candidate = path.join(dd, e)
+          const found = await findAppBundle(candidate).catch(() => undefined)
+          if (found) return { artifactPath: found }
+        }
+      } catch {}
+
+      return { error: 'Could not find .app after build' }
     } catch (e) {
       return { error: e instanceof Error ? e.message : String(e) }
     }

package/src/tools/interact.ts

@@ -1,4 +1,4 @@
-import { resolveTargetDevice } from '../resolve-device.js'
+import { resolveTargetDevice } from '../utils/resolve-device.js'
 import { AndroidInteract } from '../android/interact.js'
 import { iOSInteract } from '../ios/interact.js'
 

package/src/tools/manage.ts

@@ -1,6 +1,6 @@
 import { promises as fs } from 'fs'
 import path from 'path'
-import { resolveTargetDevice, listDevices } from '../resolve-device.js'
+import { resolveTargetDevice, listDevices } from '../utils/resolve-device.js'
 import { AndroidManage } from '../android/manage.js'
 import { iOSManage } from '../ios/manage.js'
 import type { InstallAppResponse, StartAppResponse, TerminateAppResponse, RestartAppResponse, ResetAppDataResponse } from '../types.js'

package/src/tools/observe.ts

@@ -1,4 +1,4 @@
-import { resolveTargetDevice } from '../resolve-device.js'
+import { resolveTargetDevice } from '../utils/resolve-device.js'
 import { AndroidObserve } from '../android/observe.js'
 import { iOSObserve } from '../ios/observe.js'
 

package/src/utils/diagnostics.ts

@@ -34,3 +34,27 @@ export class DiagnosticError extends Error {
     this.runResult = runResult
   }
 }
+
+// Exec ADB with diagnostics — moved from src/android/diagnostics.ts
+import { spawnSync } from 'child_process'
+import { getAdbCmd } from '../android/utils.js'
+
+export function execAdbWithDiagnostics(args: string[], deviceId?: string) {
+  const adbArgs = deviceId ? ['-s', deviceId, ...args] : args
+  const timeout = 120000
+  const res = spawnSync(getAdbCmd(), adbArgs, { encoding: 'utf8', timeout })
+  const runResult: RunResult = {
+    exitCode: typeof res.status === 'number' ? res.status : null,
+    stdout: res.stdout || '',
+    stderr: res.stderr || '',
+    envSnapshot: makeEnvSnapshot(['PATH','ADB_PATH','HOME','JAVA_HOME']),
+    command: getAdbCmd(),
+    args: adbArgs,
+    suggestedFixes: []
+  }
+  if (res.status !== 0) {
+    if ((runResult.stderr || '').includes('device not found')) runResult.suggestedFixes!.push('Ensure device is connected and adb is authorized (adb devices)')
+    if ((runResult.stderr || '').includes('No such file or directory')) runResult.suggestedFixes!.push('Verify ADB_PATH or that adb is installed')
+  }
+  return { runResult }
+}

package/src/{resolve-device.ts → utils/resolve-device.ts}

@@ -1,6 +1,6 @@
-import { DeviceInfo } from "./types.js"
-import { listAndroidDevices } from "./android/utils.js"
-import { listIOSDevices } from "./ios/utils.js"
+import { DeviceInfo } from "../types.js"
+import { listAndroidDevices } from "../android/utils.js"
+import { listIOSDevices } from "../ios/utils.js"
 
 export interface ResolveOptions {
   platform: "android" | "ios"
@@ -11,7 +11,6 @@ export interface ResolveOptions {
 
 function parseNumericVersion(v: string): number {
   if (!v) return 0
-  // extract first number groups like 17.0 -> 17.0 or Android 12 -> 12
   const m = v.match(/(\d+)(?:[\.\-](\d+))?/) 
   if (!m) return 0
   const major = parseInt(m[1], 10) || 0
@@ -23,7 +22,6 @@ export async function listDevices(platform?: "android" | "ios", appId?: string):
   if (!platform || platform === "android") {
     const android = await listAndroidDevices(appId)
     if (platform === "android") return android
-    // if no platform specified, merge with ios below
     const ios = await listIOSDevices(appId)
     return [...android, ...ios]
   }
@@ -42,11 +40,9 @@ export async function resolveTargetDevice(opts: ResolveOptions): Promise<DeviceI
 
   let candidates = devices.slice()
 
-  // Apply prefer filter
   if (prefer === "physical") candidates = candidates.filter(d => !d.simulator)
   if (prefer === "emulator") candidates = candidates.filter(d => d.simulator)
 
-  // If appId provided, prefer devices with appInstalled
   if (appId) {
     const installed = candidates.filter(d => (d as any).appInstalled)
     if (installed.length > 0) candidates = installed
@@ -55,21 +51,17 @@ export async function resolveTargetDevice(opts: ResolveOptions): Promise<DeviceI
   if (candidates.length === 1) return candidates[0]
 
   if (candidates.length > 1) {
-    // Prefer physical over emulator unless prefer=emulator
     if (!prefer) {
       const physical = candidates.filter(d => !d.simulator)
       if (physical.length === 1) return physical[0]
       if (physical.length > 1) candidates = physical
     }
 
-    // Pick highest OS version
     candidates.sort((a, b) => parseNumericVersion(b.osVersion) - parseNumericVersion(a.osVersion))
-    // If top is unique (numeric differs), return it
     if (candidates.length > 1 && parseNumericVersion(candidates[0].osVersion) > parseNumericVersion(candidates[1].osVersion)) {
       return candidates[0]
     }
 
-    // Ambiguous: throw an error with candidate list so caller (agent) can present choices
     const list = candidates.map(d => ({ id: d.id, platform: d.platform, osVersion: d.osVersion, model: d.model, simulator: d.simulator, appInstalled: (d as any).appInstalled }))
     const err = new Error(`Multiple matching devices found: ${JSON.stringify(list, null, 2)}`)
     ;(err as any).devices = list

package/scripts/check-idb.js

@@ -1,83 +0,0 @@
-#!/usr/bin/env node
-import { execSync, spawnSync } from 'child_process';
-import { main as installMain } from './install-idb';
-function which(cmd) {
-    try {
-        // Prefer POSIX `command -v` which can resolve shell builtins. Use spawnSync
-        // to avoid shell interpolation and injection risks. Fall back to `which`.
-        const res = spawnSync('command', ['-v', cmd], { stdio: ['ignore', 'pipe', 'ignore'] });
-        if (res && res.status === 0 && res.stdout) return res.stdout.toString().trim();
-        return execSync(`which ${cmd}`, { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
-    }
-    catch {
-        return null;
-    }
-}
-function print(...args) {
-    console.log(...args);
-}
-async function runInstaller() {
-    try {
-        // prefer invoking the TS script via npx/tsx to ensure environment
-        const runner = which('npx') ? 'npx' : which('tsx') ? 'tsx' : null;
-        if (runner) {
-            const args = runner === 'npx' ? ['tsx', './scripts/install-idb.ts'] : ['./scripts/install-idb.ts'];
-            const res = spawnSync(runner, args, { stdio: 'inherit' });
-            return typeof res.status === 'number' ? res.status === 0 : false;
-        }
-        // fallback: attempt to import and run the installer directly (may rely on ts-node/tsx)
-        try {
-            // call the exported main; it returns a promise
-            await installMain();
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    catch (e) {
-        console.error('Failed to run installer:', e instanceof Error ? e.message : String(e));
-        return false;
-    }
-}
-(async () => {
-    try {
-        print('PATH=', process.env.PATH);
-        const idb = process.env.IDB_PATH || which('idb');
-        print('which idb:', idb);
-        if (idb) {
-            try {
-                print('idb --version:', execSync('idb --version', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim());
-            }
-            catch (e) {
-                print('idb --version: (failed)', e instanceof Error ? e.message : String(e));
-            }
-            const companion = which('idb_companion');
-            print('which idb_companion:', companion);
-            if (companion)
-                try {
-                    print('idb_companion --version:', execSync('idb_companion --version', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim());
-                }
-                catch (e) {
-                    print('idb_companion --version: (failed)', e instanceof Error ? e.message : String(e));
-                }
-            process.exit(0);
-        }
-        print('idb not found');
-        const auto = process.env.MCP_AUTO_INSTALL_IDB === 'true';
-        if (auto) {
-            print('MCP_AUTO_INSTALL_IDB=true, attempting installer...');
-            const ok = await runInstaller();
-            if (ok)
-                process.exit(0);
-            print('Installer failed or did not produce idb');
-            process.exit(2);
-        }
-        print('Set MCP_AUTO_INSTALL_IDB=true to attempt automatic installation (CI-friendly).');
-        process.exit(2);
-    }
-    catch (e) {
-        console.error('idb healthcheck failed:', e instanceof Error ? e.message : String(e));
-        process.exit(2);
-    }
-})();

package/src/android/diagnostics.ts

@@ -1,23 +0,0 @@
-import { spawnSync } from 'child_process'
-import { getAdbCmd } from './utils.js'
-import { RunResult, makeEnvSnapshot } from '../utils/diagnostics.js'
-
-export function execAdbWithDiagnostics(args: string[], deviceId?: string) {
-  const adbArgs = deviceId ? ['-s', deviceId, ...args] : args
-  const timeout = 120000
-  const res = spawnSync(getAdbCmd(), adbArgs, { encoding: 'utf8', timeout }) as any
-  const runResult: RunResult = {
-    exitCode: typeof res.status === 'number' ? res.status : null,
-    stdout: res.stdout || '',
-    stderr: res.stderr || '',
-    envSnapshot: makeEnvSnapshot(['PATH','ADB_PATH','HOME','JAVA_HOME']),
-    command: getAdbCmd(),
-    args: adbArgs,
-    suggestedFixes: []
-  }
-  if (res.status !== 0) {
-    if ((runResult.stderr || '').includes('device not found')) runResult.suggestedFixes!.push('Ensure device is connected and adb is authorized (adb devices)')
-    if ((runResult.stderr || '').includes('No such file or directory')) runResult.suggestedFixes!.push('Verify ADB_PATH or that adb is installed')
-  }
-  return { runResult }
-}