mobile-debug-mcp 0.30.1 → 0.31.0

package/dist/manage/ios.js

@@ -257,7 +257,7 @@ export class iOSManage {
                 // Gather diagnostics for simctl failure
                 const diag = execCommandWithDiagnostics(['simctl', 'install', deviceId, toInstall], deviceId);
                 try {
-                    const child = spawn(getIdbCmd(), ['--version']);
+                    const child = spawn(getIdbCmd(), ['list-targets', '--json']);
                     const idbExists = await new Promise((resolve) => {
                         child.on('error', () => resolve(false));
                         child.on('close', (code) => resolve(code === 0));

package/dist/server/tool-definitions.js

@@ -568,11 +568,11 @@ Adjust a numeric control value with verification.
 This is the initial adjustable-control surface for slider-like controls and other controls that expose a numeric value or value_range.
 
 Inputs:
-- selector or element_id
+- exactly one of selector or element_id
 - property (defaults to "value")
 - targetValue
-- tolerance (optional)
-- maxAttempts (optional)
+- tolerance (optional; discrete default is 0, continuous default is max(step / 2, 1% of range) when omitted)
+- maxAttempts (optional; defaults to 5)
 - platform/deviceId (optional)
 
 Output Structure:
@@ -584,14 +584,14 @@ Output Structure:
 - success = true when the control converges within tolerance
 
 Verification Guidance:
-- Prefer direct target placement when value_range is available; fall back to a drag only if the direct tap does not converge
+- Prefer direct platform adjustment when the runtime exposes it; then verified increment/decrement actions; use coordinate fallback only as degraded mode
 - Use expect_state for the control value readback
-- Treat coordinate fallback as degraded mode
+- Do not use derived semantic metadata as proof of success
 
 Failure Handling:
 - ELEMENT_NOT_FOUND → re-resolve the control
 - ELEMENT_NOT_INTERACTABLE → the control cannot be adjusted through the current runtime
-- TIMEOUT → the control did not converge within bounded retries
+- CONTROL_CONVERGENCE_FAILED → the control did not converge within bounded retries or the requested value is out of range
 - UNKNOWN → capture a snapshot and stop`,
         inputSchema: {
             type: 'object',
@@ -608,12 +608,16 @@ Failure Handling:
                 element_id: { type: 'string', description: 'Optional previously resolved element identifier.' },
                 property: { type: 'string', description: 'Readable numeric state property to adjust.', default: 'value' },
                 targetValue: { type: 'number', description: 'Target numeric value.' },
-                tolerance: { type: 'number', description: 'Accepted numeric tolerance around the target value.', default: 0 },
-                maxAttempts: { type: 'number', description: 'Maximum adjustment attempts.', default: 3 },
+                tolerance: { type: 'number', description: 'Accepted numeric tolerance around the target value. Defaults are derived from the readable control domain.' },
+                maxAttempts: { type: 'number', description: 'Maximum adjustment attempts.', default: 5 },
                 platform: { type: 'string', enum: ['android', 'ios'], description: 'Optional platform override' },
                 deviceId: { type: 'string', description: 'Optional device serial/udid' }
             },
-            required: ['targetValue']
+            required: ['targetValue'],
+            oneOf: [
+                { required: ['selector'] },
+                { required: ['element_id'] }
+            ]
         }
     },
     {

package/dist/server/tool-handlers.js

@@ -231,12 +231,12 @@ async function handleAdjustControl(args) {
     const element_id = getStringArg(args, 'element_id');
     const property = getStringArg(args, 'property') ?? 'value';
     const targetValue = requireNumberArg(args, 'targetValue');
-    const tolerance = getNumberArg(args, 'tolerance') ?? 0;
-    const maxAttempts = getNumberArg(args, 'maxAttempts') ?? 3;
+    const tolerance = getNumberArg(args, 'tolerance');
+    const maxAttempts = getNumberArg(args, 'maxAttempts');
     const platform = getStringArg(args, 'platform');
     const deviceId = getStringArg(args, 'deviceId');
-    if (!selector && !element_id) {
-        throw new Error('Missing selector or element_id argument');
+    if ((!selector && !element_id) || (selector && element_id)) {
+        throw new Error('Exactly one of selector or element_id argument is required');
     }
     const res = await ToolsInteract.adjustControlHandler({
         selector: selector ?? undefined,

package/dist/server-core.js

@@ -6,7 +6,7 @@ import { handleToolCall } from './server/tool-handlers.js';
 export { wrapResponse, toolDefinitions, handleToolCall };
 export const serverInfo = {
     name: 'mobile-debug-mcp',
-    version: '0.30.1'
+    version: '0.31.0'
 };
 export function createServer() {
     const server = new Server(serverInfo, {

package/dist/system/index.js

@@ -1,68 +1,505 @@
+import { spawnSync } from 'child_process';
+import path from 'path';
 import { checkAndroid } from './android.js';
-import { checkIOS } from './ios.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: adbAvailable && android.devices > 0, selected: false, tool: 'adb' }
+        },
+        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: {
+                availability: adbAvailable && android.devices > 0,
+                selectedProvider: adbAvailable && android.devices > 0 ? 'JDWP' : null,
+                blockingFailure: adbAvailable && android.devices > 0 ? null : 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 || []
+        }
+    };
+}
 export async function getSystemStatus() {
+    const hostOs = normalizeHostOs((process.env.MOBILE_DEBUG_MCP_HOST_OS || process.platform));
+    if (!isSupportedHost(hostOs)) {
+        return buildUnsupportedHostStatus(hostOs);
+    }
     try {
-        const android = await checkAndroid();
-        const ios = await checkIOS();
-        const gradle = await checkGradle();
-        const issues = [...android.issues, ...ios.issues, ...(gradle.issues || [])];
+        const [androidRaw, gradleRaw] = await Promise.all([checkAndroid(), checkGradle()]);
+        const iosRaw = hostOs === 'macos'
+            ? await checkIOS()
+            : {
+                iosAvailable: false,
+                iosDevices: 0,
+                issues: ['iOS tooling is only supported on macOS.']
+            };
+        const androidStatus = buildAndroidPlatform(androidRaw, true);
+        const iosStatus = buildIOSPlatform(iosRaw, hostOs === 'macos', hostOs);
+        const gradle = gradleRaw;
+        const issues = [...androidRaw.issues, ...iosRaw.issues, ...(gradle.issues || [])];
         const success = issues.length === 0;
-        const androidReady = android.adbAvailable && android.devices > 0 && !android.issues.some((issue) => /unauthorized|offline/i.test(issue));
-        const iosReady = ios.iosAvailable && ios.iosDevices > 0;
-        const gradleReady = (gradle.issues || []).length === 0;
+        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 androidSummary = !android.adbAvailable
-            ? 'ADB unavailable'
-            : android.devices === 0
-                ? 'ADB available but no Android devices connected'
-                : android.logsAvailable
-                    ? `${android.devices} Android device(s) connected; log access available`
-                    : `${android.devices} Android device(s) connected; log access unavailable`;
-        const iosSummary = !ios.iosAvailable
-            ? 'xcrun unavailable'
-            : ios.iosDevices === 0
-                ? 'xcrun available but no iOS simulators booted'
-                : `${ios.iosDevices} iOS simulator(s) booted`;
-        const gradleSummary = !gradle.gradleJavaHome
-            ? 'No explicit Gradle JDK override detected'
-            : gradleReady
-                ? `Gradle JDK configured at ${gradle.gradleJavaHome}`
-                : `Gradle JDK override invalid: ${gradle.gradleJavaHome}`;
+        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 {
             success,
             status: overallStatus,
-            adbAvailable: android.adbAvailable,
-            adbVersion: android.adbVersion,
-            devices: android.devices,
-            deviceStates: android.deviceStates,
-            logsAvailable: android.logsAvailable,
-            envValid: android.envValid,
+            adbAvailable: androidRaw.adbAvailable,
+            adbVersion: androidRaw.adbVersion,
+            devices: androidRaw.devices,
+            deviceStates: androidRaw.deviceStates,
+            logsAvailable: androidRaw.logsAvailable,
+            envValid: androidRaw.envValid,
             issues,
-            appInstalled: android.appInstalled,
-            iosAvailable: ios.iosAvailable,
-            iosDevices: ios.iosDevices,
+            appInstalled: androidRaw.appInstalled,
+            iosAvailable: iosRaw.iosAvailable,
+            iosDevices: iosRaw.iosDevices,
             gradleJavaHome: gradle.gradleJavaHome,
             gradleValid: gradle.gradleValid,
             gradleFilesChecked: gradle.filesChecked,
             gradleSuggestedFixes: gradle.suggestedFixes,
-            summary: {
-                overall: overallStatus,
+            host: {
+                os: hostOs,
+                supported: true
+            },
+            android: {
+                ...androidStatus,
+                status: androidStatus.status
+            },
+            ios: {
+                ...iosStatus,
+                status: iosStatus.status
+            },
+            summary: buildLegacySummary(androidStatus, iosStatus, gradle),
+            tools: {
                 android: {
-                    ready: androidReady,
-                    summary: androidSummary,
-                    blockers: android.issues
-                },
-                ios: {
-                    ready: iosReady,
-                    summary: iosSummary,
-                    blockers: ios.issues
+                    adb: androidStatus.tools.adb,
+                    java: javaTool
                 },
+                ios: iosStatus.tools,
                 gradle: {
-                    ready: gradleReady,
-                    summary: gradleSummary,
-                    blockers: gradle.issues || [],
-                    suggestedFixes: gradle.suggestedFixes || []
+                    java: javaTool
                 }
             }
         };