mobile-debug-mcp 0.33.0 → 0.35.0

package/src/server-core.ts

@@ -10,13 +10,13 @@ import {
 
 import { wrapResponse } from './server/common.js'
 import { toolDefinitions } from './server/tool-definitions.js'
-import { handleToolCall } from './server/tool-handlers.js'
+import { handleToolCall } from './server/handlers/tool-handlers.js'
 
 export { wrapResponse, toolDefinitions, handleToolCall }
 
 export const serverInfo = {
   name: 'mobile-debug-mcp',
-  version: '0.33.0'
+  version: '0.35.0'
 }
 
 export function createServer() {
@@ -46,9 +46,9 @@ export function createServer() {
     tools: toolDefinitions
   }))
 
-  server.setRequestHandler(CallToolRequestSchema, async (request: SchemaOutput<typeof CallToolRequestSchema>) => {
+  server.setRequestHandler(CallToolRequestSchema, async (request: SchemaOutput<typeof CallToolRequestSchema>, extra) => {
     const { name, arguments: args } = request.params
-    return handleToolCall(name, args as Record<string, unknown>)
+    return handleToolCall(name, args as Record<string, unknown>, extra.signal)
   })
 
   return server

package/src/server.ts

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { debuggerSessions } from './debugger/sessions.js'
+import { systemTraces } from './observe/system-trace.js'
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { createServer } from './server-core.js'
 import { getSystemStatus } from './system/index.js'
@@ -13,8 +15,30 @@ if (process.env.MOBILE_DEBUG_MCP_STARTUP_HEALTHCHECK === '1') {
 
 const transport = new StdioServerTransport()
 
+let shuttingDown = false
+async function shutdown() {
+  if (shuttingDown) return
+  shuttingDown = true
+  const deadline = setTimeout(() => { console.error('System trace shutdown cleanup timed out; owned device captures remain duration-bounded.'); process.exit(1) }, 10000)
+  let exitCode = 0
+  try {
+    const [remaining, debuggers] = await Promise.all([systemTraces.shutdown(), debuggerSessions.shutdown()])
+    if (debuggers.length) { exitCode = 1; console.error('Debugger shutdown cleanup incomplete', debuggers.map(s => s.cleanup)) }
+    if (remaining.length) {
+      exitCode = 1
+      console.error('System trace shutdown cleanup incomplete:', remaining.map(s => ({ trace_id: s.trace_id, device: s.device, cleanup: s.cleanup })))
+    }
+    await server.close()
+  } catch { exitCode = 1; console.error('Server shutdown cleanup failed.') }
+  finally { clearTimeout(deadline); process.exit(exitCode) }
+}
+server.onclose = () => { void shutdown() }
+process.stdin.on('end', () => { void shutdown() })
+process.on('SIGINT', () => { void shutdown() })
+process.on('SIGTERM', () => { void shutdown() })
+
 async function main() {
-  await (server as any).connect(transport)
+  await server.connect(transport)
 }
 
 main().catch((error) => {

package/src/system/android-status.ts

@@ -0,0 +1,124 @@
+import { checkAndroid } from './android.js'
+import { resolveAdbCmd } from '../utils/android/utils.js'
+import type { PlatformStatus, DiagnosticFailure, PlatformEntry } from './model.js'
+import { makeFailure, makeToolEntry, describeAdbDiscovery } from './probes.js'
+
+export function buildAndroidPlatform(android: Awaited<ReturnType<typeof checkAndroid>>, hostSupported: boolean): PlatformEntry {
+  const resolvedAdbCmd = resolveAdbCmd()
+  const adbDiscovery = describeAdbDiscovery(resolvedAdbCmd)
+  const adbTool = makeToolEntry(
+    resolvedAdbCmd,
+    adbDiscovery.discoverySource,
+    android.adbVersion || null,
+    android.adbAvailable ? 'valid' : 'invalid'
+  )
+
+  const adbAvailable = !!android.adbAvailable
+  const deviceIssues = android.issues.filter((issue) => /unauthorized|offline|No Android devices connected/i.test(issue))
+  const { envFailure, adbFailure, deviceFailure, diagnosticFailures } = androidFailures(android, adbAvailable, adbDiscovery)
+  const status: PlatformStatus = !hostSupported
+    ? 'unsupported'
+    : !adbAvailable
+      ? 'unavailable'
+      : (android.devices === 0 || deviceIssues.length > 0 || !android.logsAvailable || !android.envValid)
+        ? 'partially_ready'
+        : 'ready'
+
+  const deviceEntries = android.devices > 0
+    ? Array.from({ length: android.devices }, (_, index) => ({
+      id: `android-device-${index + 1}`,
+      state: deviceIssues.length > 0 ? 'degraded' : 'connected'
+    }))
+    : []
+
+  const installAvailable = adbAvailable && android.devices > 0 && deviceIssues.length === 0
+  const logAvailable = adbAvailable && android.logsAvailable
+
+  return {
+    status,
+    tools: {
+      adb: adbTool
+    },
+    providers: {
+      adb: { available: adbAvailable, selected: true, tool: 'adb' },
+      jdwp: { available: false, selected: false, tool: 'adb', probeRequired: 'get_debugger_capabilities' }
+    },
+    capabilities: androidCapabilities(adbAvailable, installAvailable, logAvailable, diagnosticFailures, deviceFailure, adbFailure, envFailure),
+    devices: deviceEntries,
+    failures: diagnosticFailures
+  }
+}
+
+function androidFailures(android: Awaited<ReturnType<typeof checkAndroid>>, adbAvailable: boolean, adbDiscovery: ReturnType<typeof describeAdbDiscovery>) {
+  const envFailure = !android.envValid
+    ? makeFailure('TOOL_VALIDATION_FAILED', 'android', 'Android environment prerequisites are incomplete.', {
+      tool: 'adb',
+      searchedLocations: ['ANDROID_SDK_ROOT', 'ANDROID_HOME', 'PATH'],
+      selectedProvider: 'adb',
+      rawVersion: android.adbVersion || null,
+      remediation: ['Set ANDROID_SDK_ROOT or ANDROID_HOME, or ensure adb is on PATH.']
+    })
+    : null
+
+  const adbFailure = !adbAvailable
+    ? makeFailure(
+      process.env.ADB_PATH && process.env.ADB_PATH.trim() ? 'TOOL_NOT_EXECUTABLE' : 'TOOL_NOT_FOUND',
+      'android',
+      'Android adb could not be resolved or executed.',
+      {
+        tool: 'adb',
+        searchedLocations: adbDiscovery.searchedLocations,
+        selectedProvider: null,
+        rawVersion: android.adbVersion || null,
+        remediation: [
+          'Install Android platform-tools.',
+          'Set ADB_PATH or ANDROID_SDK_ROOT/ANDROID_HOME if adb is installed in a non-standard location.'
+        ]
+      }
+    )
+    : null
+
+  const deviceFailure = adbAvailable && android.devices === 0
+    ? makeFailure('DEVICE_NOT_FOUND', 'android', 'No Android devices or emulators are connected.', {
+      tool: 'adb',
+      searchedLocations: ['adb devices -l'],
+      selectedProvider: 'adb',
+      rawVersion: android.adbVersion || null,
+      remediation: ['Start an emulator or connect a device, then re-run adb devices.']
+    })
+    : null
+
+  const diagnosticFailures = [adbFailure, envFailure, deviceFailure].filter((value): value is DiagnosticFailure => value !== null)
+
+  return { envFailure, adbFailure, deviceFailure, diagnosticFailures }
+}
+
+function androidCapabilities(adbAvailable: boolean, installAvailable: boolean, logAvailable: boolean, diagnosticFailures: DiagnosticFailure[], deviceFailure: DiagnosticFailure | null, adbFailure: DiagnosticFailure | null, envFailure: DiagnosticFailure | null): PlatformEntry['capabilities'] {
+  const applicationCapability = {
+    availability: installAvailable,
+    selectedProvider: installAvailable ? 'adb' : null,
+    blockingFailure: installAvailable ? null : deviceFailure ?? adbFailure ?? envFailure
+  }
+  return {
+    device_discovery: {
+      availability: adbAvailable,
+      selectedProvider: adbAvailable ? 'adb' : null,
+      blockingFailure: adbAvailable ? null : diagnosticFailures[0] ?? null
+    },
+    install_app: { ...applicationCapability },
+    launch_app: { ...applicationCapability },
+    ui_interaction: { ...applicationCapability },
+    screenshot: { ...applicationCapability },
+    log_capture: {
+      availability: logAvailable,
+      selectedProvider: logAvailable ? 'adb' : null,
+      blockingFailure: logAvailable ? null : adbFailure ?? envFailure
+    },
+    debug: {
+      probeRequired: 'get_debugger_capabilities',
+      availability: false,
+      selectedProvider: null,
+      blockingFailure: deviceFailure ?? adbFailure ?? envFailure
+    }
+  }
+}

package/src/system/android.ts

@@ -19,26 +19,15 @@ export async function checkAndroid() {
     if (!adbAvailable) issues.push('ADB not available')
 
     try {
-      const out = execSync(`${adbCmd} devices -l`, { encoding: 'utf8', timeout: 1500, stdio: ['ignore','pipe','ignore'] }).toString()
-      const lines = out.split('\n').map(l => l.trim()).filter(Boolean)
-      const deviceLines = lines.filter(l => !l.startsWith('List of devices'))
-      const stateCounts: Record<string, number> = {}
-      for (const l of deviceLines) {
-        const parts = l.split(/\s+/)
-        const state = parts[1] || ''
-        stateCounts[state] = (stateCounts[state] || 0) + 1
-      }
-      devices = deviceLines.length
-      const parts = Object.entries(stateCounts).map(([k,v]) => `${v} ${k}`)
-      deviceStates = parts.join(', ')
-      if (devices === 0) issues.push('No Android devices connected')
-      if (stateCounts['unauthorized']) issues.push(`${stateCounts['unauthorized']} device(s) unauthorized`)
-      if (stateCounts['offline']) issues.push(`${stateCounts['offline']} device(s) offline`)
+      const out = execSync(`${adbCmd} devices -l`, { encoding: 'utf8', timeout: 1500, stdio: ['ignore', 'pipe', 'ignore'] }).toString()
+      const state = parseDevices(out, issues)
+      devices = state.devices; deviceStates = state.deviceStates
+
     } catch (e: unknown) { console.debug('[get_system_status] adb devices failed: ' + String(e)); issues.push('Failed to list Android devices') }
 
     if (adbAvailable && devices > 0) {
       try {
-        const lo = execSync(`${adbCmd} logcat -d -t 1`, { encoding: 'utf8', timeout: 1500, stdio: ['ignore','pipe','ignore'] }).toString()
+        const lo = execSync(`${adbCmd} logcat -d -t 1`, { encoding: 'utf8', timeout: 1500, stdio: ['ignore', 'pipe', 'ignore'] }).toString()
         logsAvailable = !!lo
         if (!logsAvailable) issues.push('Log access failed')
       } catch (e: unknown) { logsAvailable = false; console.debug('[get_system_status] logcat check failed: ' + String(e)) }
@@ -50,13 +39,36 @@ export async function checkAndroid() {
 
     const pkg = process.env.MCP_TARGET_PACKAGE || process.env.MCP_TARGET_APP_ID
     if (pkg && adbAvailable && devices > 0) {
-      try {
-        const pm = execSync(`${adbCmd} shell pm path ${pkg}`, { encoding: 'utf8', timeout: 1500, stdio: ['ignore','pipe','ignore'] }).toString()
-        appInstalled = (pm || '').includes('package:')
-        if (!appInstalled) issues.push(`App ${pkg} not installed on devices`)
-      } catch (e: unknown) { appInstalled = false; console.debug('[get_system_status] pm check failed: ' + String(e)) }
+      appInstalled = probeAppInstalled(adbCmd, pkg, issues)
     }
   } catch (e: unknown) { console.debug('[get_system_status] adb availability check failed: ' + String(e)); issues.push('ADB check failed') }
 
   return { adbAvailable, adbVersion, devices, deviceStates, logsAvailable, envValid, appInstalled, issues }
 }
+
+function parseDevices(out: string, issues: string[]) {
+  const lines = out.split('\n').map(l => l.trim()).filter(Boolean)
+  const deviceLines = lines.filter(l => !l.startsWith('List of devices'))
+  const stateCounts: Record<string, number> = {}
+  for (const l of deviceLines) {
+    const parts = l.split(/\s+/)
+    const state = parts[1] || ''
+    stateCounts[state] = (stateCounts[state] || 0) + 1
+  }
+  const devices = deviceLines.length
+  const parts = Object.entries(stateCounts).map(([k, v]) => `${v} ${k}`)
+  const deviceStates = parts.join(', ')
+  if (devices === 0) issues.push('No Android devices connected')
+  if (stateCounts['unauthorized']) issues.push(`${stateCounts['unauthorized']} device(s) unauthorized`)
+  if (stateCounts['offline']) issues.push(`${stateCounts['offline']} device(s) offline`)
+  return { devices, deviceStates }
+}
+
+function probeAppInstalled(adbCmd: string, pkg: string, issues: string[]) {
+  try {
+    const pm = execSync(`${adbCmd} shell pm path ${pkg}`, { encoding: 'utf8', timeout: 1500, stdio: ['ignore', 'pipe', 'ignore'] }).toString()
+    const appInstalled = (pm || '').includes('package:')
+    if (!appInstalled) issues.push(`App ${pkg} not installed on devices`)
+    return appInstalled
+  } catch (e: unknown) { console.debug('[get_system_status] pm check failed: ' + String(e)); return false }
+}