mobile-debug-mcp 0.10.0 → 0.12.0

package/src/android/utils.ts

@@ -1,9 +1,47 @@
 import { spawn } from 'child_process'
-import { DeviceInfo } from "../types.js"
-import { createWriteStream, promises as fsPromises } from 'fs'
+import { DeviceInfo, UIElement } from "../types.js"
+import { promises as fsPromises, existsSync } from 'fs'
 import path from 'path'
+import { detectJavaHome } from '../utils/java.js'
 
-export const ADB = process.env.ADB_PATH || 'adb'
+export function getAdbCmd() { return process.env.ADB_PATH || 'adb' }
+
+/**
+ * Prepare Gradle execution options for building an Android project.
+ * Returns execCmd (wrapper or gradle), base gradleArgs array, and spawn options including env.
+ */
+export async function prepareGradle(projectPath: string): Promise<{ execCmd: string, gradleArgs: string[], spawnOpts: any }> {
+  const gradlewPath = path.join(projectPath, 'gradlew')
+  const gradleCmd = existsSync(gradlewPath) ? './gradlew' : 'gradle'
+  const execCmd = existsSync(gradlewPath) ? gradlewPath : gradleCmd
+
+  const gradleArgs: string[] = ['assembleDebug']
+
+  const detectedJavaHome = await detectJavaHome().catch(() => undefined)
+  const env = Object.assign({}, process.env)
+  if (detectedJavaHome) {
+    if (env.JAVA_HOME !== detectedJavaHome) {
+      env.JAVA_HOME = detectedJavaHome
+      env.PATH = `${path.join(detectedJavaHome, 'bin')}${path.delimiter}${env.PATH || ''}`
+    }
+    gradleArgs.push(`-Dorg.gradle.java.home=${detectedJavaHome}`)
+    gradleArgs.push('--no-daemon')
+    env.GRADLE_JAVA_HOME = detectedJavaHome
+  }
+
+  try { delete env.SHELL } catch {}
+
+  const useWrapper = existsSync(gradlewPath)
+  const spawnOpts: any = { cwd: projectPath, env }
+  if (useWrapper) {
+    try { await fsPromises.chmod(gradlewPath, 0o755) } catch {}
+    spawnOpts.shell = false
+  } else {
+    spawnOpts.shell = true
+  }
+
+  return { execCmd, gradleArgs, spawnOpts }
+}
 
 
 // Helper to construct ADB args with optional device ID
@@ -40,7 +78,7 @@ export function execAdb(args: string[], deviceId?: string, options: SpawnOptions
     const { timeout: customTimeout, ...spawnOptions } = options;
     
     // Use spawn instead of execFile for better stream control and to avoid potential buffering hangs
-    const child = spawn(ADB, adbArgs, spawnOptions)
+    const child = spawn(getAdbCmd(), adbArgs, spawnOptions)
     
     let stdout = ''
     let stderr = ''
@@ -88,7 +126,7 @@ export function spawnAdb(args: string[], deviceId?: string, options: SpawnOption
   const adbArgs = getAdbArgs(args, deviceId)
   return new Promise((resolve, reject) => {
     const { timeout: customTimeout, ...spawnOptions } = options
-    const child = spawn(ADB, adbArgs, spawnOptions)
+    const child = spawn(getAdbCmd(), adbArgs, spawnOptions)
 
     let stdout = ''
     let stderr = ''
@@ -161,6 +199,21 @@ export async function getAndroidDeviceMetadata(appId: string, deviceId?: string)
   }
 }
 
+export async function findApk(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()) {
+      const found = await findApk(full)
+      if (found) return found
+    } else if (e.isFile() && full.endsWith('.apk')) {
+      return full
+    }
+  }
+  return undefined
+}
+
+
 export async function listAndroidDevices(appId?: string): Promise<DeviceInfo[]> {
   try {
     const devicesOutput = await execAdb(['devices', '-l'])
@@ -198,22 +251,101 @@ export async function listAndroidDevices(appId?: string): Promise<DeviceInfo[]>
   }
 }
 
-// Log stream management (one stream per session)
+// UI helper utilities shared by observe/interact
+export const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
 
-const activeLogStreams: Map<string, { proc: { kill: () => void } | ReturnType<typeof import('child_process').spawn>, file: string }> = new Map()
+export function parseBounds(bounds: string): [number, number, number, number] {
+  const match = bounds.match(/\[(\d+),(\d+)\]\[(\d+),(\d+)\]/);
+  if (match) {
+    return [parseInt(match[1]), parseInt(match[2]), parseInt(match[3]), parseInt(match[4])];
+  }
+  return [0, 0, 0, 0];
+}
+
+export function getCenter(bounds: [number, number, number, number]): [number, number] {
+  const [x1, y1, x2, y2] = bounds;
+  return [Math.floor((x1 + x2) / 2), Math.floor((y1 + y2) / 2)];
+}
 
-// Test helper to register a pre-existing NDJSON file as the active stream for a session (used by unit tests)
-export function _setActiveLogStream(sessionId: string, file: string) {
-  activeLogStreams.set(sessionId, { proc: { kill: () => {} }, file })
+export async function getScreenResolution(deviceId?: string): Promise<{ width: number; height: number }> {
+  try {
+    const output = await execAdb(['shell', 'wm', 'size'], deviceId);
+    const match = output.match(/Physical size: (\d+)x(\d+)/);
+    if (match) {
+      return { width: parseInt(match[1]), height: parseInt(match[2]) };
+    }
+  } catch {
+    // ignore
+  }
+  return { width: 0, height: 0 };
 }
 
-export function _clearActiveLogStream(sessionId: string) {
-  activeLogStreams.delete(sessionId)
+export function traverseNode(node: any, elements: UIElement[], parentIndex: number = -1, depth: number = 0): number {
+  if (!node) return -1;
+
+  let currentIndex = -1;
+
+  if (node['@_class']) {
+    const text = node['@_text'] || null;
+    const contentDescription = node['@_content-desc'] || null;
+    const clickable = node['@_clickable'] === 'true';
+    const bounds = parseBounds(node['@_bounds'] || '[0,0][0,0]');
+
+    const isUseful = clickable || (text && text.length > 0) || (contentDescription && contentDescription.length > 0);
+
+    if (isUseful) {
+      const element: UIElement = {
+        text,
+        contentDescription,
+        type: node['@_class'] || 'unknown',
+        resourceId: node['@_resource-id'] || null,
+        clickable,
+        enabled: node['@_enabled'] === 'true',
+        visible: true,
+        bounds,
+        center: getCenter(bounds),
+        depth
+      };
+
+      if (parentIndex !== -1) {
+        element.parentId = parentIndex;
+      }
+
+      elements.push(element);
+      currentIndex = elements.length - 1;
+    }
+  }
+
+  const nextParentIndex = currentIndex !== -1 ? currentIndex : parentIndex;
+  const nextDepth = currentIndex !== -1 ? depth + 1 : depth;
+
+  const childrenIndices: number[] = [];
+
+  if (node.node) {
+    if (Array.isArray(node.node)) {
+      node.node.forEach((child: any) => {
+        const childIndex = traverseNode(child, elements, nextParentIndex, nextDepth);
+        if (childIndex !== -1) childrenIndices.push(childIndex);
+      });
+    } else {
+      const childIndex = traverseNode(node.node, elements, nextParentIndex, nextDepth);
+      if (childIndex !== -1) childrenIndices.push(childIndex);
+    }
+  }
+
+  if (currentIndex !== -1 && childrenIndices.length > 0) {
+    elements[currentIndex].children = childrenIndices;
+  }
+
+  return currentIndex;
 }
 
+// Log stream management (one stream per session)
+
+// (Legacy active stream map removed from utils during refactor; Observe modules manage their own active streams.)
+
 // Robust log line parser supporting multiple logcat formats
-export function parseLogLine(line: string) {
-  // Collapse internal newlines so multiline stack traces are parseable as a single entry
+export function parseLogLine(line: string) {  // Collapse internal newlines so multiline stack traces are parseable as a single entry
   const rawLine = line
   const normalizedLine = rawLine.replace(/\r?\n/g, ' ')
   const entry: any = { timestamp: '', level: '', tag: '', message: rawLine, _iso: null, crash: false }
@@ -313,139 +445,5 @@ export function parseLogLine(line: string) {
   return entry
 }
 
-export async function startAndroidLogStream(packageName: string, level: 'error' | 'warn' | 'info' | 'debug' = 'error', deviceId?: string, sessionId: string = 'default'): Promise<{ success: boolean; stream_started?: boolean; error?: string }> {
-  try {
-    // Determine PID
-    const pidOutput = await execAdb(['shell', 'pidof', packageName], deviceId).catch(() => '')
-    const pid = (pidOutput || '').trim()
-    if (!pid) {
-      return { success: false, error: 'app_not_running' }
-    }
-
-    // Map level to logcat filter
-    const levelMap: Record<string, string> = { error: '*:E', warn: '*:W', info: '*:I', debug: '*:D' }
-    const filter = levelMap[level] || levelMap['error']
-
-    // Prevent multiple streams per session
-    if (activeLogStreams.has(sessionId)) {
-      // stop existing
-      try { activeLogStreams.get(sessionId)!.proc.kill() } catch {}
-      activeLogStreams.delete(sessionId)
-    }
-
-    // Start logcat process
-    const args = ['logcat', `--pid=${pid}`, filter]
-    const proc = spawn(ADB, args)
-
-    // Prepare output file
-    const tmpDir = process.env.TMPDIR || '/tmp'
-    const file = path.join(tmpDir, `mobile-debug-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) => {
-      // write stderr lines as message with level 'E'
-      const text = chunk.toString()
-      const lines = text.split(/\r?\n/).filter(Boolean)
-      for (const l of lines) {
-        const entry = { timestamp: '', level: 'E', tag: 'adb', message: l }
-        stream.write(JSON.stringify(entry) + '\n')
-      }
-    })
-
-    proc.on('close', () => {
-      stream.end()
-      activeLogStreams.delete(sessionId)
-    })
-
-    activeLogStreams.set(sessionId, { proc, file })
-
-    return { success: true, stream_started: true }
-  } catch {
-    return { success: false, error: 'log_stream_start_failed' }
-  }
-}
-
-export async function stopAndroidLogStream(sessionId: string = 'default'): Promise<{ success: boolean }> {
-  const entry = activeLogStreams.get(sessionId)
-  if (!entry) return { success: true }
-  try {
-    entry.proc.kill()
-  } catch {}
-  activeLogStreams.delete(sessionId)
-  return { success: true }
-}
-
-export async function readLogStreamLines(sessionId: string = 'default', limit: number = 100, since?: string): Promise<{ entries: any[], crash_summary?: { crash_detected: boolean, exception?: string, sample?: string } }> {
-  const entry = activeLogStreams.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)
-
-    // Parse NDJSON lines into objects. Prefer fields written by parseLogLine. For backward compatibility, if _iso or crash are missing, enrich minimally here (avoid duplicating full parse logic).
-    const parsed = lines.map(l => {
-      try {
-        const obj: any = JSON.parse(l)
-        // Ensure _iso: if missing, try to derive using Date()
-        if (typeof obj._iso === 'undefined') {
-          let iso: string | null = null
-          if (obj.timestamp) {
-            const d = new Date(obj.timestamp)
-            if (!isNaN(d.getTime())) iso = d.toISOString()
-          }
-          obj._iso = iso
-        }
-        // Ensure crash flag: if missing, run minimal heuristic
-        if (typeof obj.crash === 'undefined') {
-          const msg = (obj.message || '').toString()
-          const exMatch = msg.match(/\b([A-Za-z0-9_$.]+Exception)\b/)
-          if (/FATAL EXCEPTION/i.test(msg) || exMatch) {
-            obj.crash = true
-            if (exMatch) obj.exception = exMatch[1]
-          } else {
-            obj.crash = false
-          }
-        }
-        return obj
-      } catch {
-        return { message: l, _iso: null, crash: false }
-      }
-    })
-
-    // Filter by since if provided (accept ISO or epoch ms)
-    let filtered = parsed
-    if (since) {
-      let sinceMs: number | null = null
-      // If numeric string
-      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))
-      }
-    }
-
-    // Return the last `limit` entries (most recent)
-    const entries = filtered.slice(-Math.max(0, limit))
-
-    // Crash summary
-    const crashEntry = entries.find(e => e.crash)
-    const crash_summary = crashEntry ? { crash_detected: true, exception: crashEntry.exception, sample: crashEntry.message } : { crash_detected: false }
+// Legacy readLogStreamLines shim removed. Use AndroidObserve.readLogStream(sessionId, limit, since) instead.
 
-    return { entries, crash_summary }
-  } catch {
-    return { entries: [], crash_summary: { crash_detected: false } }
-  }
-}

package/src/ios/interact.ts

@@ -1,9 +1,7 @@
-import { promises as fs } from "fs"
 import { spawn } from "child_process"
-import { StartAppResponse, TerminateAppResponse, RestartAppResponse, ResetAppDataResponse, WaitForElementResponse, TapResponse } from "../types.js"
-import { execCommand, getIOSDeviceMetadata, validateBundleId, IDB } from "./utils.js"
+import { WaitForElementResponse, TapResponse } from "../types.js"
+import { getIOSDeviceMetadata, getIdbCmd, isIDBInstalled } from "./utils.js"
 import { iOSObserve } from "./observe.js"
-import path from "path"
 
 export class iOSInteract {
   private observe = new iOSObserve();
@@ -41,12 +39,8 @@ export class iOSInteract {
   async tap(x: number, y: number, deviceId: string = "booted"): Promise<TapResponse> {
     const device = await getIOSDeviceMetadata(deviceId)
     
-    // Check for idb
-    const child = spawn(IDB, ['--version']);
-    const idbExists = await new Promise<boolean>((resolve) => {
-      child.on('error', () => resolve(false));
-      child.on('close', (code) => resolve(code === 0));
-    });
+    // Use shared helper to detect idb
+    const idbExists = await isIDBInstalled();
 
     if (!idbExists) {
         return {
@@ -66,7 +60,7 @@ export class iOSInteract {
       }
 
       await new Promise<void>((resolve, reject) => {
-        const proc = spawn(IDB, args);
+        const proc = spawn(getIdbCmd(), args);
         let stderr = '';
         proc.stderr.on('data', d => stderr += d.toString());
         proc.on('close', code => {
@@ -81,174 +75,4 @@ export class iOSInteract {
       return { device, success: false, x, y, error: e instanceof Error ? e.message : String(e) };
     }
   }
-
-  async installApp(appPath: string, deviceId: string = "booted"): Promise<import("../types.js").InstallAppResponse> {
-    const device = await getIOSDeviceMetadata(deviceId)
-
-    // Helper to find .app bundles under a directory
-    async function findAppBundle(dir: string): Promise<string | undefined> {
-      const entries = await fs.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
-    }
-
-    try {
-      let toInstall = appPath
-
-      const stat = await fs.stat(appPath).catch(() => null)
-      if (stat && stat.isDirectory()) {
-        // If directory already contains a .app, use it
-        const found = await findAppBundle(appPath)
-        if (found) {
-          toInstall = found
-        } else {
-          // Attempt to locate an Xcode project and build for simulator
-          const files = await fs.readdir(appPath).catch(() => [])
-          // Prefer workspace when present (CocoaPods / multi-project setups)
-          const workspace = files.find(f => f.endsWith('.xcworkspace'))
-          const proj = files.find(f => f.endsWith('.xcodeproj'))
-          if (!workspace && !proj) throw new Error('No .app bundle, .xcworkspace or .xcodeproj found in directory')
-
-          let buildArgs: string[]
-          let scheme: string
-          if (workspace) {
-            const workspacePath = path.join(appPath, workspace)
-            scheme = workspace.replace(/\.xcworkspace$/, '')
-            buildArgs = ['-workspace', workspacePath, '-scheme', scheme, '-configuration', 'Debug', '-sdk', 'iphonesimulator', 'build', '-quiet']
-          } else {
-            const projectPath = path.join(appPath, proj!)
-            scheme = proj!.replace(/\.xcodeproj$/, '')
-            buildArgs = ['-project', projectPath, '-scheme', scheme, '-configuration', 'Debug', '-sdk', 'iphonesimulator', 'build', '-quiet']
-          }
-
-          await new Promise<void>((resolve, reject) => {
-            const proc = spawn('xcodebuild', buildArgs, { cwd: appPath })
-            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(appPath)
-          if (!built) throw new Error('Could not locate built .app after xcodebuild')
-          toInstall = built
-        }
-      }
-
-      // Try simulator install first
-      try {
-        const res = await execCommand(['simctl', 'install', deviceId, toInstall], deviceId)
-        return { device, installed: true, output: res.output }
-      } catch (e) {
-        // If simctl fails and idb is available, try idb install for physical devices
-        try {
-          const child = spawn(IDB, ['--version'])
-          const idbExists = await new Promise<boolean>((resolve) => {
-            child.on('error', () => resolve(false));
-            child.on('close', (code) => resolve(code === 0));
-          });
-          if (idbExists) {
-            // Use idb to install (works for physical devices and simulators)
-            await new Promise<void>((resolve, reject) => {
-              const proc = spawn(IDB, ['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 {
-          // fallthrough
-        }
-
-        return { device, installed: false, error: e instanceof Error ? e.message : String(e) }
-      }
-    } 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)
-    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,
-    }
-  }
-
-  async terminateApp(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
-    }
-  }
-
-  async restartApp(bundleId: string, deviceId: string = "booted"): Promise<RestartAppResponse> {
-    // terminateApp already validates bundleId
-    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)
-    
-    // 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 (e) {
-      throw new Error(`Failed to clear data for ${bundleId}: ${e instanceof Error ? e.message : String(e)}`)
-    }
-  }
 }