mobile-debug-mcp 0.33.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.33.0'
+    version: '0.35.0'
 };
 export function createServer() {
     const server = new Server(serverInfo, {
@@ -27,9 +27,9 @@ export function createServer() {
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: toolDefinitions
     }));
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
         const { name, arguments: args } = request.params;
-        return handleToolCall(name, args);
+        return handleToolCall(name, args, extra.signal);
     });
     return server;
 }

package/dist/server.js

@@ -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';
@@ -9,6 +11,38 @@ if (process.env.MOBILE_DEBUG_MCP_STARTUP_HEALTHCHECK === '1') {
     }).catch((e) => console.warn('[startup] healthcheck failed:', e instanceof Error ? e.message : String(e)));
 }
 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.connect(transport);
 }

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;
+    }
+}