mobile-debug-mcp 0.34.0 → 0.35.0

package/dist/server-core.js

@@ -2,11 +2,11 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ReadResourceRequestSchema, ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 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.34.0'
+    version: '0.35.0'
 };
 export function createServer() {
     const server = new Server(serverInfo, {

package/dist/system/android-status.js

@@ -0,0 +1,101 @@
+import { resolveAdbCmd } from '../utils/android/utils.js';
+import { makeFailure, makeToolEntry, describeAdbDiscovery } from './probes.js';
+export function buildAndroidPlatform(android, hostSupported) {
+    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 = !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, adbAvailable, adbDiscovery) {
+    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 !== null);
+    return { envFailure, adbFailure, deviceFailure, diagnosticFailures };
+}
+function androidCapabilities(adbAvailable, installAvailable, logAvailable, diagnosticFailures, deviceFailure, adbFailure, envFailure) {
+    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/dist/system/android.js

@@ -18,23 +18,9 @@ export async function checkAndroid() {
             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 = {};
-            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 state = parseDevices(out, issues);
+            devices = state.devices;
+            deviceStates = state.deviceStates;
         }
         catch (e) {
             console.debug('[get_system_status] adb devices failed: ' + String(e));
@@ -58,16 +44,7 @@ export async function checkAndroid() {
             issues.push('ANDROID_SDK_ROOT/ANDROID_HOME missing and adb not found in PATH');
         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) {
-                appInstalled = false;
-                console.debug('[get_system_status] pm check failed: ' + String(e));
-            }
+            appInstalled = probeAppInstalled(adbCmd, pkg, issues);
         }
     }
     catch (e) {
@@ -76,3 +53,36 @@ export async function checkAndroid() {
     }
     return { adbAvailable, adbVersion, devices, deviceStates, logsAvailable, envValid, appInstalled, issues };
 }
+function parseDevices(out, issues) {
+    const lines = out.split('\n').map(l => l.trim()).filter(Boolean);
+    const deviceLines = lines.filter(l => !l.startsWith('List of devices'));
+    const stateCounts = {};
+    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, pkg, issues) {
+    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) {
+        console.debug('[get_system_status] pm check failed: ' + String(e));
+        return false;
+    }
+}

package/dist/system/index.js

@@ -1,442 +1,12 @@
-import { spawnSync } from 'child_process';
-import path from 'path';
 import { checkAndroid } from './android.js';
 import { checkGradle } from './gradle.js';
 import { checkIOS } from './ios.js';
-import { resolveAdbCmd } from '../utils/android/utils.js';
-import { getIdbCmd, getXcrunCmd } from '../utils/ios/utils.js';
-import { probeIdb } from '../utils/cli/idb/idb-helper.js';
 import { detectJavaHome } from '../utils/java.js';
-function normalizeHostOs(platform) {
-    switch (platform) {
-        case 'darwin':
-            return 'macos';
-        case 'linux':
-            return 'linux';
-        case 'win32':
-            return 'windows';
-        case 'freebsd':
-        case 'openbsd':
-        case 'netbsd':
-        case 'sunos':
-            return platform;
-        default:
-            return 'unknown';
-    }
-}
-function isSupportedHost(hostOs) {
-    return hostOs === 'macos' || hostOs === 'linux' || hostOs === 'windows';
-}
-function firstVersionToken(raw) {
-    if (!raw)
-        return null;
-    const match = String(raw).match(/(\d+(?:\.\d+)+|\d+)/);
-    return match?.[1] ?? null;
-}
-function probeCommand(command, args, timeoutMs = 2000) {
-    try {
-        const result = spawnSync(command, args, { encoding: 'utf8', timeout: timeoutMs, stdio: ['ignore', 'pipe', 'pipe'] });
-        const raw = `${result.stdout || ''}${result.stderr || ''}`.trim() || null;
-        return {
-            ok: result.status === 0,
-            raw,
-            parsedVersion: firstVersionToken(raw)
-        };
-    }
-    catch {
-        return { ok: false, raw: null, parsedVersion: null };
-    }
-}
-function makeFailure(code, platform, message, opts = {}) {
-    return {
-        code,
-        platform,
-        tool: opts.tool ?? null,
-        message,
-        searchedLocations: opts.searchedLocations ?? [],
-        selectedProvider: opts.selectedProvider ?? null,
-        rawVersion: opts.rawVersion ?? null,
-        remediation: opts.remediation ?? []
-    };
-}
-function makeToolEntry(resolvedPath, discoverySource, rawVersionOutput, validationStatus) {
-    return {
-        resolvedPath,
-        discoverySource,
-        parsedVersion: firstVersionToken(rawVersionOutput),
-        rawVersionOutput,
-        validationStatus
-    };
-}
-function describeAdbDiscovery(adbCmd) {
-    const searchedLocations = ['ADB_PATH', 'ANDROID_SDK_ROOT/platform-tools/adb', 'ANDROID_HOME/platform-tools/adb', '~/Library/Android/sdk/platform-tools/adb', 'PATH'];
-    if (process.env.ADB_PATH && process.env.ADB_PATH.trim())
-        return { discoverySource: 'ADB_PATH', searchedLocations };
-    if (process.env.ANDROID_SDK_ROOT)
-        return { discoverySource: 'ANDROID_SDK_ROOT', searchedLocations };
-    if (process.env.ANDROID_HOME)
-        return { discoverySource: 'ANDROID_HOME', searchedLocations };
-    if (adbCmd.includes('Library/Android/sdk'))
-        return { discoverySource: 'HOME_SDK', searchedLocations };
-    if (adbCmd === 'adb')
-        return { discoverySource: 'PATH_OR_FALLBACK', searchedLocations };
-    return { discoverySource: 'PATH', searchedLocations };
-}
-function describeXcrunDiscovery(xcrunCmd) {
-    const searchedLocations = ['XCRUN_PATH', 'PATH'];
-    if (process.env.XCRUN_PATH && process.env.XCRUN_PATH.trim())
-        return { discoverySource: 'XCRUN_PATH', searchedLocations };
-    return { discoverySource: xcrunCmd === 'xcrun' ? 'PATH' : 'PATH', searchedLocations };
-}
-function describeIdbDiscovery(idbCmd) {
-    const searchedLocations = ['MCP_IDB_PATH', 'IDB_PATH', 'mcp.config.json', '~/.mcp/config.json', 'PATH', '/opt/homebrew/bin/idb', '/usr/local/bin/idb'];
-    if (process.env.MCP_IDB_PATH && process.env.MCP_IDB_PATH.trim())
-        return { discoverySource: 'MCP_IDB_PATH', searchedLocations };
-    if (process.env.IDB_PATH && process.env.IDB_PATH.trim())
-        return { discoverySource: 'IDB_PATH', searchedLocations };
-    return { discoverySource: idbCmd === 'idb' ? 'PATH_OR_FALLBACK' : 'PATH', searchedLocations };
-}
-function describeJavaDiscovery(javaHome) {
-    const searchedLocations = ['GRADLE_JAVA_HOME', 'JAVA_HOME', 'GRADLE_HOME', 'detectJavaHome'];
-    if (process.env.GRADLE_JAVA_HOME && process.env.GRADLE_JAVA_HOME.trim())
-        return { discoverySource: 'GRADLE_JAVA_HOME', searchedLocations };
-    if (process.env.JAVA_HOME && process.env.JAVA_HOME.trim())
-        return { discoverySource: 'JAVA_HOME', searchedLocations };
-    if (process.env.GRADLE_HOME && process.env.GRADLE_HOME.trim())
-        return { discoverySource: 'GRADLE_HOME', searchedLocations };
-    return { discoverySource: javaHome ? 'detected' : null, searchedLocations };
-}
-function resolveJavaBinaryPath(javaHome, hostOs) {
-    const javaBinary = hostOs === 'windows' ? 'java.exe' : 'java';
-    return path.join(javaHome, 'bin', javaBinary);
-}
-function buildUnsupportedHostStatus(hostOs) {
-    const failureMessage = `Host operating system '${hostOs}' is not supported.`;
-    const remediation = ['Run Mobile Debug MCP on macOS, Linux, or Windows.'];
-    const failureAndroid = makeFailure('HOST_OS_UNSUPPORTED', 'android', failureMessage, {
-        remediation
-    });
-    const failureIos = makeFailure('HOST_OS_UNSUPPORTED', 'ios', failureMessage, {
-        remediation
-    });
-    return {
-        success: false,
-        status: 'blocked',
-        adbAvailable: false,
-        adbVersion: '',
-        devices: 0,
-        deviceStates: '',
-        logsAvailable: false,
-        envValid: false,
-        issues: [failureMessage],
-        appInstalled: undefined,
-        iosAvailable: false,
-        iosDevices: 0,
-        gradleJavaHome: undefined,
-        gradleValid: false,
-        gradleFilesChecked: [],
-        gradleSuggestedFixes: [],
-        host: { os: hostOs, supported: false },
-        android: {
-            status: 'unsupported',
-            tools: {},
-            providers: {},
-            capabilities: {},
-            devices: [],
-            failures: [failureAndroid]
-        },
-        ios: {
-            status: 'unsupported',
-            tools: {},
-            providers: {},
-            capabilities: {},
-            devices: [],
-            failures: [failureIos]
-        },
-        summary: {
-            overall: 'blocked',
-            android: { ready: false, summary: `Host operating system '${hostOs}' is not supported.`, blockers: [failureMessage] },
-            ios: { ready: false, summary: `Host operating system '${hostOs}' is not supported.`, blockers: [failureMessage] },
-            gradle: { ready: false, summary: 'Gradle status unavailable on unsupported host', blockers: [], suggestedFixes: [] }
-        }
-    };
-}
-function buildAndroidPlatform(android, hostSupported) {
-    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 = !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 !== null);
-    const status = !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 deviceDiscoveryAvailable = adbAvailable;
-    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: {
-            device_discovery: {
-                availability: deviceDiscoveryAvailable,
-                selectedProvider: deviceDiscoveryAvailable ? 'adb' : null,
-                blockingFailure: deviceDiscoveryAvailable ? null : diagnosticFailures[0] ?? null
-            },
-            install_app: {
-                availability: installAvailable,
-                selectedProvider: installAvailable ? 'adb' : null,
-                blockingFailure: installAvailable ? null : deviceFailure ?? adbFailure ?? envFailure
-            },
-            launch_app: {
-                availability: installAvailable,
-                selectedProvider: installAvailable ? 'adb' : null,
-                blockingFailure: installAvailable ? null : deviceFailure ?? adbFailure ?? envFailure
-            },
-            ui_interaction: {
-                availability: installAvailable,
-                selectedProvider: installAvailable ? 'adb' : null,
-                blockingFailure: installAvailable ? null : deviceFailure ?? adbFailure ?? envFailure
-            },
-            screenshot: {
-                availability: installAvailable,
-                selectedProvider: installAvailable ? 'adb' : null,
-                blockingFailure: installAvailable ? null : deviceFailure ?? adbFailure ?? envFailure
-            },
-            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
-            }
-        },
-        devices: deviceEntries,
-        failures: diagnosticFailures
-    };
-}
-function buildIOSPlatform(ios, hostSupported, hostOs) {
-    const platformUnsupported = !hostSupported || hostOs === 'linux' || hostOs === 'windows';
-    if (platformUnsupported) {
-        return {
-            status: 'unsupported',
-            tools: {},
-            providers: {},
-            capabilities: {},
-            devices: [],
-            failures: [
-                makeFailure('PLATFORM_UNAVAILABLE', 'ios', 'iOS tooling is only supported on macOS.', {
-                    tool: null,
-                    searchedLocations: [],
-                    selectedProvider: null,
-                    rawVersion: null,
-                    remediation: ['Run Mobile Debug MCP on macOS for iOS toolchain discovery.']
-                })
-            ]
-        };
-    }
-    const xcrunCmd = getXcrunCmd();
-    const xcrunProbe = ios.iosAvailable ? probeCommand(xcrunCmd, ['--version']) : { ok: false, raw: null, parsedVersion: null };
-    const idbCmd = getIdbCmd();
-    const idbProbe = hostSupported && hostOs === 'macos' ? probeIdb(idbCmd) : { ok: false, raw: null, parsedVersion: null };
-    const idbCompanionProbe = hostSupported && hostOs === 'macos' ? probeCommand('idb_companion', ['--version']) : { ok: false, raw: null, parsedVersion: null };
-    const xcrunTool = makeToolEntry(xcrunCmd, describeXcrunDiscovery(xcrunCmd).discoverySource, xcrunProbe.raw, xcrunProbe.ok ? 'valid' : 'invalid');
-    const idbTool = makeToolEntry(idbCmd, describeIdbDiscovery(idbCmd).discoverySource, idbProbe.raw, idbProbe.ok ? 'valid' : 'invalid');
-    const idbCompanionTool = makeToolEntry('idb_companion', 'PATH', idbCompanionProbe.raw, idbCompanionProbe.ok ? 'valid' : 'invalid');
-    const lldbTool = makeToolEntry('xcrun lldb', 'xcrun', xcrunProbe.raw, xcrunProbe.ok ? 'valid' : 'invalid');
-    const simctlAvailable = !!ios.iosAvailable;
-    const idbAvailable = !!idbProbe.ok;
-    const bootedDevices = ios.iosDevices > 0
-        ? Array.from({ length: ios.iosDevices }, (_, index) => ({
-            id: `ios-simulator-${index + 1}`,
-            state: 'booted'
-        }))
-        : [];
-    const platformUnavailableFailure = !platformUnsupported && !simctlAvailable
-        ? makeFailure('PLATFORM_UNAVAILABLE', 'ios', 'iOS tooling is unavailable on this host.', {
-            tool: 'xcrun',
-            searchedLocations: describeXcrunDiscovery(xcrunCmd).searchedLocations,
-            selectedProvider: null,
-            rawVersion: xcrunProbe.raw,
-            remediation: ['Install Xcode Command Line Tools and ensure xcrun is on PATH.']
-        })
-        : null;
-    const deviceFailure = simctlAvailable && !bootedDevices.length
-        ? makeFailure('DEVICE_NOT_FOUND', 'ios', 'No iOS simulators are booted.', {
-            tool: 'simctl',
-            searchedLocations: ['xcrun simctl list devices booted --json'],
-            selectedProvider: 'simctl',
-            rawVersion: xcrunProbe.raw,
-            remediation: ['Boot a simulator in Xcode or via xcrun simctl boot.']
-        })
-        : null;
-    const selectedInstallProvider = idbAvailable ? 'idb' : simctlAvailable ? 'simctl' : null;
-    const selectedDebugProvider = simctlAvailable ? 'LLDB' : null;
-    const selectedDiscoveryProvider = idbAvailable ? 'idb' : simctlAvailable ? 'simctl' : null;
-    const status = platformUnsupported
-        ? 'unsupported'
-        : !simctlAvailable
-            ? 'unavailable'
-            : !bootedDevices.length
-                ? 'partially_ready'
-                : 'ready';
-    const iosFailure = platformUnsupported
-        ? makeFailure('PLATFORM_UNAVAILABLE', 'ios', 'iOS tooling is only supported on macOS.', {
-            tool: null,
-            searchedLocations: [],
-            selectedProvider: null,
-            rawVersion: null,
-            remediation: ['Run Mobile Debug MCP on macOS for iOS toolchain discovery.']
-        })
-        : platformUnavailableFailure ?? deviceFailure ?? null;
-    const failureList = [iosFailure].filter((value) => value !== null);
-    return {
-        status,
-        tools: {
-            xcrun: xcrunTool,
-            idb: idbTool,
-            idb_companion: idbCompanionTool,
-            lldb: lldbTool
-        },
-        providers: {
-            idb: { available: idbAvailable, selected: selectedInstallProvider === 'idb', tool: 'idb' },
-            simctl: { available: simctlAvailable, selected: selectedInstallProvider === 'simctl', tool: 'xcrun' },
-            lldb: { available: simctlAvailable, selected: selectedDebugProvider === 'LLDB', tool: 'xcrun' }
-        },
-        capabilities: {
-            device_discovery: {
-                availability: !!selectedDiscoveryProvider,
-                selectedProvider: selectedDiscoveryProvider,
-                blockingFailure: selectedDiscoveryProvider ? null : iosFailure
-            },
-            install_app: {
-                availability: !!selectedInstallProvider && bootedDevices.length > 0,
-                selectedProvider: selectedInstallProvider,
-                blockingFailure: selectedInstallProvider && bootedDevices.length > 0 ? null : deviceFailure ?? iosFailure
-            },
-            launch_app: {
-                availability: !!selectedInstallProvider && bootedDevices.length > 0,
-                selectedProvider: selectedInstallProvider,
-                blockingFailure: selectedInstallProvider && bootedDevices.length > 0 ? null : deviceFailure ?? iosFailure
-            },
-            ui_interaction: {
-                availability: !!selectedInstallProvider && bootedDevices.length > 0,
-                selectedProvider: selectedInstallProvider,
-                blockingFailure: selectedInstallProvider && bootedDevices.length > 0 ? null : deviceFailure ?? iosFailure
-            },
-            screenshot: {
-                availability: !!selectedInstallProvider && bootedDevices.length > 0,
-                selectedProvider: selectedInstallProvider,
-                blockingFailure: selectedInstallProvider && bootedDevices.length > 0 ? null : deviceFailure ?? iosFailure
-            },
-            log_capture: {
-                availability: simctlAvailable && bootedDevices.length > 0,
-                selectedProvider: simctlAvailable ? 'simctl' : null,
-                blockingFailure: simctlAvailable && bootedDevices.length > 0 ? null : deviceFailure ?? iosFailure
-            },
-            debug: {
-                availability: !!selectedDebugProvider,
-                selectedProvider: selectedDebugProvider,
-                blockingFailure: selectedDebugProvider ? null : iosFailure
-            }
-        },
-        devices: bootedDevices,
-        failures: failureList
-    };
-}
-function buildLegacySummary(androidStatus, iosStatus, gradle) {
-    const androidReady = androidStatus.status === 'ready';
-    const iosReady = iosStatus.status === 'ready';
-    const gradleReady = (gradle.issues || []).length === 0;
-    const overallStatus = (androidReady || iosReady || gradleReady)
-        ? ((androidReady && iosReady && gradleReady) ? 'ready' : 'degraded')
-        : 'blocked';
-    return {
-        overall: overallStatus,
-        android: {
-            ready: androidReady,
-            summary: androidStatus.status === 'ready'
-                ? `${androidStatus.devices.length} Android device(s) connected; log access available`
-                : androidStatus.status === 'partially_ready'
-                    ? 'Android toolchain available but device-dependent capabilities are limited'
-                    : androidStatus.status === 'unsupported'
-                        ? 'Android unsupported on this host'
-                        : 'ADB unavailable',
-            blockers: androidStatus.failures.map((failure) => failure.message)
-        },
-        ios: {
-            ready: iosReady,
-            summary: iosStatus.status === 'ready'
-                ? `${iosStatus.devices.length} iOS simulator(s) booted`
-                : iosStatus.status === 'partially_ready'
-                    ? 'iOS toolchain available but device-dependent capabilities are limited'
-                    : iosStatus.status === 'unsupported'
-                        ? 'iOS unsupported on this host'
-                        : 'xcrun unavailable',
-            blockers: iosStatus.failures.map((failure) => failure.message)
-        },
-        gradle: {
-            ready: gradleReady,
-            summary: !gradle.gradleJavaHome
-                ? 'No explicit Gradle JDK override detected'
-                : gradleReady
-                    ? `Gradle JDK configured at ${gradle.gradleJavaHome}`
-                    : `Gradle JDK override invalid: ${gradle.gradleJavaHome}`,
-            blockers: gradle.issues || [],
-            suggestedFixes: gradle.suggestedFixes || []
-        }
-    };
-}
+import { buildAndroidPlatform } from './android-status.js';
+import { buildIOSPlatform } from './ios-status.js';
+import { buildLegacySummary } from './status-summary.js';
+import { buildUnsupportedHostStatus } from './unsupported-status.js';
+import { normalizeHostOs, isSupportedHost, probeCommand, makeToolEntry, describeJavaDiscovery, resolveJavaBinaryPath } from './probes.js';
 export async function getSystemStatus() {
     const hostOs = normalizeHostOs((process.env.MOBILE_DEBUG_MCP_HOST_OS || process.platform));
     if (!isSupportedHost(hostOs)) {
@@ -459,10 +29,7 @@ export async function getSystemStatus() {
         const androidReady = androidRaw.adbAvailable && androidRaw.devices > 0 && !androidRaw.issues.some((issue) => /unauthorized|offline/i.test(issue));
         const iosReady = hostOs === 'macos' ? (iosRaw.iosAvailable && iosRaw.iosDevices > 0) : false;
         const overallStatus = success ? 'ready' : (androidReady || iosReady ? 'degraded' : 'blocked');
-        const javaHome = gradle.gradleJavaHome || (await detectJavaHome().catch(() => undefined));
-        const javaBin = javaHome ? resolveJavaBinaryPath(javaHome, hostOs) : null;
-        const javaProbe = javaBin ? probeCommand(javaBin, ['-version']) : { ok: false, raw: null, parsedVersion: null };
-        const javaTool = makeToolEntry(javaBin, describeJavaDiscovery(javaHome ?? null).discoverySource, javaProbe.raw, javaProbe.ok ? 'valid' : (javaHome ? 'invalid' : 'missing'));
+        const javaTool = await javaStatus(gradle, hostOs);
         return {
             success,
             status: overallStatus,
@@ -519,3 +86,10 @@ export async function getSystemStatus() {
         };
     }
 }
+async function javaStatus(gradle, hostOs) {
+    const javaHome = gradle.gradleJavaHome || (await detectJavaHome().catch(() => undefined));
+    const javaBin = javaHome ? resolveJavaBinaryPath(javaHome, hostOs) : null;
+    const javaProbe = javaBin ? probeCommand(javaBin, ['-version']) : { ok: false, raw: null, parsedVersion: null };
+    const javaTool = makeToolEntry(javaBin, describeJavaDiscovery(javaHome ?? null).discoverySource, javaProbe.raw, javaProbe.ok ? 'valid' : (javaHome ? 'invalid' : 'missing'));
+    return javaTool;
+}