mobile-debug-mcp 0.20.0 → 0.20.1

package/README.md

@@ -2,7 +2,10 @@
 
 A minimal, secure MCP server for AI-assisted mobile development. Build, install, and inspect Android/iOS apps from an MCP-compatible client.
 
-> **Note:** iOS support is limited currently, Please use with caution and report any issues.
+> **Note:**
+> * iOS only tested on simulator.
+> * Flutter iOS projects not fetching logs
+> * React native not tested
 
 ## Requirements
 
@@ -28,10 +31,9 @@ You will need to add ADB_PATH for Android and XCRUN_PATH and IDB_PATH for iOS.
 
 ## Usage
 
-Example: 
-After a crash tell the agent the following:
-
-I have a crash on the app, can you diagnose it, fix and validate using the mcp tools available
+Examples: 
+* I have a crash on the app, can you diagnose it, fix and validate using the mcp tools available
+* Add a button, hook into the repository and confirm API request successful
 
 ## Docs
 

package/dist/manage/android.js

@@ -64,10 +64,13 @@ export class AndroidManage {
                 const spawnOpts = { cwd: apkPath, env };
                 if (useWrapper) {
                     await fs.chmod(wrapperPath, 0o755).catch(() => { });
+                    // Run wrapper directly to avoid shell splitting of args
+                    spawnOpts.shell = false;
+                }
+                else {
+                    // Execute gradle directly without a shell so paths with spaces are preserved
                     spawnOpts.shell = false;
                 }
-                else
-                    spawnOpts.shell = true;
                 const proc = spawn(execCmd, gradleArgs, spawnOpts);
                 let stderr = '';
                 await new Promise((resolve, reject) => {

package/dist/system/gradle.js

@@ -0,0 +1,101 @@
+import { readFileSync, existsSync } from 'fs';
+import path from 'path';
+import os from 'os';
+function readPropertiesFile(p) {
+    try {
+        const txt = readFileSync(p, { encoding: 'utf8' });
+        const lines = String(txt).split(/\r?\n/);
+        const out = {};
+        for (const l of lines) {
+            const trimmed = l.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const idx = trimmed.indexOf('=');
+            if (idx === -1)
+                continue;
+            const k = trimmed.substring(0, idx).trim();
+            const v = trimmed.substring(idx + 1).trim();
+            out[k] = v;
+        }
+        return out;
+    }
+    catch (e) {
+        return {};
+    }
+}
+function javaBinExists(p) {
+    if (!p)
+        return false;
+    try {
+        const javaPath = path.join(p, 'bin', 'java');
+        if (existsSync(javaPath))
+            return true;
+        const alt = path.join(p, 'Contents', 'Home', 'bin', 'java');
+        if (existsSync(alt))
+            return true;
+        return false;
+    }
+    catch (e) {
+        return false;
+    }
+}
+export async function checkGradle() {
+    const issues = [];
+    const filesChecked = [];
+    const suggestedFixes = [];
+    let gradleJavaHome;
+    // 1) explicit env
+    if (process.env.GRADLE_JAVA_HOME) {
+        gradleJavaHome = process.env.GRADLE_JAVA_HOME;
+        if (!javaBinExists(gradleJavaHome)) {
+            issues.push(`GRADLE_JAVA_HOME is set to '${gradleJavaHome}' but no java binary was found there`);
+            suggestedFixes.push('Unset GRADLE_JAVA_HOME or point it to a valid JDK (e.g., /Library/Java/JavaVirtualMachines/jdk-17.jdk/Contents/Home)');
+        }
+    }
+    // 2) user gradle.properties
+    const gradleUserHome = process.env.GRADLE_USER_HOME || path.join(os.homedir(), '.gradle');
+    const userProps = path.join(gradleUserHome, 'gradle.properties');
+    filesChecked.push(userProps);
+    try {
+        const props = readPropertiesFile(userProps);
+        if (props['org.gradle.java.home']) {
+            const p = props['org.gradle.java.home'];
+            gradleJavaHome = gradleJavaHome || p;
+            if (!javaBinExists(p)) {
+                issues.push(`org.gradle.java.home in ${userProps} points to '${p}' which does not look like a valid JDK`);
+                suggestedFixes.push(`Edit ${userProps} to remove or correct org.gradle.java.home`);
+            }
+        }
+    }
+    catch (e) { /* ignore */ }
+    // 3) system gradle.properties
+    const systemProps = '/etc/gradle/gradle.properties';
+    filesChecked.push(systemProps);
+    try {
+        const props = readPropertiesFile(systemProps);
+        if (props['org.gradle.java.home']) {
+            const p = props['org.gradle.java.home'];
+            gradleJavaHome = gradleJavaHome || p;
+            if (!javaBinExists(p)) {
+                issues.push(`org.gradle.java.home in ${systemProps} points to '${p}' which does not look like a valid JDK`);
+                suggestedFixes.push(`Edit ${systemProps} to remove or correct org.gradle.java.home`);
+            }
+        }
+    }
+    catch (e) { /* ignore */ }
+    // 4) GRADLE_HOME fallback
+    if (!gradleJavaHome && process.env.GRADLE_HOME) {
+        filesChecked.push(process.env.GRADLE_HOME);
+        if (javaBinExists(process.env.GRADLE_HOME)) {
+            gradleJavaHome = process.env.GRADLE_HOME;
+        }
+    }
+    const gradleValid = !!gradleJavaHome && javaBinExists(gradleJavaHome);
+    if (!gradleJavaHome) {
+        // no explicit gradle java home detected — not an issue
+    }
+    else if (!gradleValid) {
+        issues.push(`Detected org.gradle.java.home = '${gradleJavaHome}' but it is invalid`);
+    }
+    return { gradleJavaHome, gradleValid, filesChecked, issues, suggestedFixes };
+}

package/dist/system/index.js

@@ -1,10 +1,12 @@
 import { checkAndroid } from './android.js';
 import { checkIOS } from './ios.js';
+import { checkGradle } from './gradle.js';
 export async function getSystemStatus() {
     try {
         const android = await checkAndroid();
         const ios = await checkIOS();
-        const issues = [...android.issues, ...ios.issues];
+        const gradle = await checkGradle();
+        const issues = [...android.issues, ...ios.issues, ...(gradle.issues || [])];
         const success = issues.length === 0;
         return {
             success,
@@ -17,7 +19,11 @@ export async function getSystemStatus() {
             issues,
             appInstalled: android.appInstalled,
             iosAvailable: ios.iosAvailable,
-            iosDevices: ios.iosDevices
+            iosDevices: ios.iosDevices,
+            gradleJavaHome: gradle.gradleJavaHome,
+            gradleValid: gradle.gradleValid,
+            gradleFilesChecked: gradle.filesChecked,
+            gradleSuggestedFixes: gradle.suggestedFixes
         };
     }
     catch (e) {

package/dist/utils/android/utils.js

@@ -3,6 +3,7 @@ import path from 'path';
 import { detectJavaHome } from '../java.js';
 import { execCmd } from '../exec.js';
 import { spawnSync } from 'child_process';
+import { checkGradle } from '../../system/gradle.js';
 function findInPath(cmd) {
     try {
         // prefer command -v for POSIX
@@ -76,6 +77,14 @@ export async function prepareGradle(projectPath) {
         gradleArgs.push('-Dorg.gradle.caching=false');
     }
     const detectedJavaHome = await detectJavaHome().catch(() => undefined);
+    // Check for problematic org.gradle.java.home entries (env or properties) and avoid passing invalid values to Gradle
+    let gradleCheck;
+    try {
+        gradleCheck = await checkGradle();
+    }
+    catch (e) {
+        gradleCheck = { gradleJavaHome: undefined, gradleValid: false, filesChecked: [], issues: [] };
+    }
     const env = Object.assign({}, process.env);
     // Ensure child processes can find Android platform-tools (adb, etc.) by
     // prepending the platform-tools directory to PATH for spawned processes.
@@ -90,6 +99,7 @@ export async function prepareGradle(projectPath) {
         console.debug(`[prepareGradle] error resolving adbPath: ${String(e)}`);
     }
     const pathParts = [];
+    // Prefer a detected (validated) Java home from the system/IDE
     if (detectedJavaHome) {
         if (env.JAVA_HOME !== detectedJavaHome) {
             env.JAVA_HOME = detectedJavaHome;
@@ -100,6 +110,26 @@ export async function prepareGradle(projectPath) {
         gradleArgs.push('--no-daemon');
         env.GRADLE_JAVA_HOME = detectedJavaHome;
     }
+    else if (gradleCheck && gradleCheck.gradleJavaHome) {
+        // There's an org.gradle.java.home configured somewhere (env or gradle.properties)
+        if (gradleCheck.gradleValid) {
+            const p = gradleCheck.gradleJavaHome;
+            const javaBin = path.join(p, 'bin');
+            if (!env.PATH || !env.PATH.includes(javaBin))
+                pathParts.push(javaBin);
+            gradleArgs.push(`-Dorg.gradle.java.home=${p}`);
+            gradleArgs.push('--no-daemon');
+            env.GRADLE_JAVA_HOME = p;
+        }
+        else {
+            // Invalid gradle java home detected: avoid passing it to Gradle and remove from spawn env
+            console.debug(`[prepareGradle] Invalid org.gradle.java.home detected (${gradleCheck.gradleJavaHome}); removing from spawn env to avoid Gradle error.`);
+            try {
+                delete env.GRADLE_JAVA_HOME;
+            }
+            catch (e) { }
+        }
+    }
     if (platformToolsDir) {
         // Prepend platform-tools so gradle and child tools find adb without modifying global env
         if (!env.PATH || !env.PATH.includes(platformToolsDir)) {
@@ -138,10 +168,12 @@ export async function prepareGradle(projectPath) {
         catch (e) {
             console.debug('[prepareGradle] chmod failed for gradlew:', String(e));
         }
+        // Execute the wrapper directly without a shell to avoid shell tokenization of args (spaces in paths)
         spawnOpts.shell = false;
     }
     else {
-        spawnOpts.shell = true;
+        // Prefer executing gradle directly without invoking a shell to preserve argument boundaries
+        spawnOpts.shell = false;
     }
     return { execCmd, gradleArgs, spawnOpts };
 }

package/docs/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 All notable changes to the **Mobile Debug MCP** project will be documented in this file.
 
+## [0.20.1]
+- Fixes gradle home issue for android
+
 ## [0.20.0]
 - Added `get_system_status` tool and refactored system health checks into `src/system`.
   - Provides a fast environment healthcheck (ADB availability/version, connected devices, log access, Android env vars, and basic iOS xcrun/simulator checks).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobile-debug-mcp",
-  "version": "0.20.0",
+  "version": "0.20.1",
   "description": "MCP server for mobile app debugging (Android + iOS), with focus on security and reliability",
   "type": "module",
   "bin": {

package/src/manage/android.ts

@@ -64,8 +64,12 @@ export class AndroidManage {
         const spawnOpts: any = { cwd: apkPath, env }
         if (useWrapper) {
           await fs.chmod(wrapperPath, 0o755).catch(() => {})
+          // Run wrapper directly to avoid shell splitting of args
           spawnOpts.shell = false
-        } else spawnOpts.shell = true
+        } else {
+          // Execute gradle directly without a shell so paths with spaces are preserved
+          spawnOpts.shell = false
+        }
 
         const proc = spawn(execCmd, gradleArgs, spawnOpts)
         let stderr = ''

package/src/system/gradle.ts

@@ -0,0 +1,98 @@
+import { readFileSync, existsSync } from 'fs'
+import path from 'path'
+import os from 'os'
+
+function readPropertiesFile(p: string): Record<string,string> {
+  try {
+    const txt = readFileSync(p, { encoding: 'utf8' })
+    const lines = String(txt).split(/\r?\n/)
+    const out: Record<string,string> = {}
+    for (const l of lines) {
+      const trimmed = l.trim()
+      if (!trimmed || trimmed.startsWith('#')) continue
+      const idx = trimmed.indexOf('=')
+      if (idx === -1) continue
+      const k = trimmed.substring(0, idx).trim()
+      const v = trimmed.substring(idx+1).trim()
+      out[k] = v
+    }
+    return out
+  } catch (e: unknown) {
+    return {}
+  }
+}
+
+function javaBinExists(p?: string): boolean {
+  if (!p) return false
+  try {
+    const javaPath = path.join(p, 'bin', 'java')
+    if (existsSync(javaPath)) return true
+    const alt = path.join(p, 'Contents', 'Home', 'bin', 'java')
+    if (existsSync(alt)) return true
+    return false
+  } catch (e: unknown) { return false }
+}
+
+export async function checkGradle(): Promise<{ gradleJavaHome?: string; gradleValid: boolean; filesChecked: string[]; issues: string[]; suggestedFixes?: string[] }> {
+  const issues: string[] = []
+  const filesChecked: string[] = []
+  const suggestedFixes: string[] = []
+  let gradleJavaHome: string | undefined
+
+  // 1) explicit env
+  if (process.env.GRADLE_JAVA_HOME) {
+    gradleJavaHome = process.env.GRADLE_JAVA_HOME
+    if (!javaBinExists(gradleJavaHome)) {
+      issues.push(`GRADLE_JAVA_HOME is set to '${gradleJavaHome}' but no java binary was found there`)
+      suggestedFixes.push('Unset GRADLE_JAVA_HOME or point it to a valid JDK (e.g., /Library/Java/JavaVirtualMachines/jdk-17.jdk/Contents/Home)')
+    }
+  }
+
+  // 2) user gradle.properties
+  const gradleUserHome = process.env.GRADLE_USER_HOME || path.join(os.homedir(), '.gradle')
+  const userProps = path.join(gradleUserHome, 'gradle.properties')
+  filesChecked.push(userProps)
+  try {
+    const props = readPropertiesFile(userProps)
+    if (props['org.gradle.java.home']) {
+      const p = props['org.gradle.java.home']
+      gradleJavaHome = gradleJavaHome || p
+      if (!javaBinExists(p)) {
+        issues.push(`org.gradle.java.home in ${userProps} points to '${p}' which does not look like a valid JDK`)
+        suggestedFixes.push(`Edit ${userProps} to remove or correct org.gradle.java.home`)
+      }
+    }
+  } catch (e: unknown) { /* ignore */ }
+
+  // 3) system gradle.properties
+  const systemProps = '/etc/gradle/gradle.properties'
+  filesChecked.push(systemProps)
+  try {
+    const props = readPropertiesFile(systemProps)
+    if (props['org.gradle.java.home']) {
+      const p = props['org.gradle.java.home']
+      gradleJavaHome = gradleJavaHome || p
+      if (!javaBinExists(p)) {
+        issues.push(`org.gradle.java.home in ${systemProps} points to '${p}' which does not look like a valid JDK`)
+        suggestedFixes.push(`Edit ${systemProps} to remove or correct org.gradle.java.home`)
+      }
+    }
+  } catch (e: unknown) { /* ignore */ }
+
+  // 4) GRADLE_HOME fallback
+  if (!gradleJavaHome && process.env.GRADLE_HOME) {
+    filesChecked.push(process.env.GRADLE_HOME)
+    if (javaBinExists(process.env.GRADLE_HOME)) {
+      gradleJavaHome = process.env.GRADLE_HOME
+    }
+  }
+
+  const gradleValid = !!gradleJavaHome && javaBinExists(gradleJavaHome)
+  if (!gradleJavaHome) {
+    // no explicit gradle java home detected — not an issue
+  } else if (!gradleValid) {
+    issues.push(`Detected org.gradle.java.home = '${gradleJavaHome}' but it is invalid`)
+  }
+
+  return { gradleJavaHome, gradleValid, filesChecked, issues, suggestedFixes }
+}

package/src/system/index.ts

@@ -1,11 +1,13 @@
 import { checkAndroid } from './android.js'
 import { checkIOS } from './ios.js'
+import { checkGradle } from './gradle.js'
 
 export async function getSystemStatus() {
   try {
     const android = await checkAndroid()
     const ios = await checkIOS()
-    const issues = [...android.issues, ...ios.issues]
+    const gradle = await checkGradle()
+    const issues = [...android.issues, ...ios.issues, ...(gradle.issues || [])]
 
     const success = issues.length === 0
     return {
@@ -19,7 +21,11 @@ export async function getSystemStatus() {
       issues,
       appInstalled: android.appInstalled,
       iosAvailable: ios.iosAvailable,
-      iosDevices: ios.iosDevices
+      iosDevices: ios.iosDevices,
+      gradleJavaHome: gradle.gradleJavaHome,
+      gradleValid: gradle.gradleValid,
+      gradleFilesChecked: gradle.filesChecked,
+      gradleSuggestedFixes: gradle.suggestedFixes
     }
   } catch (e: unknown) {
     return { success: false, issues: ['Internal error: ' + (e instanceof Error ? e.message : String(e))] }

package/src/utils/android/utils.ts

@@ -4,6 +4,7 @@ import path from 'path'
 import { detectJavaHome } from '../java.js'
 import { execCmd } from '../exec.js'
 import { spawnSync } from 'child_process'
+import { checkGradle } from '../../system/gradle.js'
 
 function findInPath(cmd: string): string | null {
   try {
@@ -73,6 +74,14 @@ export async function prepareGradle(projectPath: string): Promise<{ execCmd: str
   }
 
   const detectedJavaHome = await detectJavaHome().catch(() => undefined)
+  // Check for problematic org.gradle.java.home entries (env or properties) and avoid passing invalid values to Gradle
+  let gradleCheck
+  try {
+    gradleCheck = await checkGradle()
+  } catch (e: unknown) {
+    gradleCheck = { gradleJavaHome: undefined, gradleValid: false, filesChecked: [], issues: [] }
+  }
+
   const env = Object.assign({}, process.env)
 
   // Ensure child processes can find Android platform-tools (adb, etc.) by
@@ -86,6 +95,7 @@ export async function prepareGradle(projectPath: string): Promise<{ execCmd: str
   } catch (e: unknown) { console.debug(`[prepareGradle] error resolving adbPath: ${String(e)}`) }
 
   const pathParts: string[] = []
+  // Prefer a detected (validated) Java home from the system/IDE
   if (detectedJavaHome) {
     if (env.JAVA_HOME !== detectedJavaHome) {
       env.JAVA_HOME = detectedJavaHome
@@ -95,6 +105,20 @@ export async function prepareGradle(projectPath: string): Promise<{ execCmd: str
     gradleArgs.push(`-Dorg.gradle.java.home=${detectedJavaHome}`)
     gradleArgs.push('--no-daemon')
     env.GRADLE_JAVA_HOME = detectedJavaHome
+  } else if (gradleCheck && gradleCheck.gradleJavaHome) {
+    // There's an org.gradle.java.home configured somewhere (env or gradle.properties)
+    if (gradleCheck.gradleValid) {
+      const p = gradleCheck.gradleJavaHome as string
+      const javaBin = path.join(p, 'bin')
+      if (!env.PATH || !env.PATH.includes(javaBin)) pathParts.push(javaBin)
+      gradleArgs.push(`-Dorg.gradle.java.home=${p}`)
+      gradleArgs.push('--no-daemon')
+      env.GRADLE_JAVA_HOME = p
+    } else {
+      // Invalid gradle java home detected: avoid passing it to Gradle and remove from spawn env
+      console.debug(`[prepareGradle] Invalid org.gradle.java.home detected (${gradleCheck.gradleJavaHome}); removing from spawn env to avoid Gradle error.`)
+      try { delete env.GRADLE_JAVA_HOME } catch (e: unknown) { }
+    }
   }
 
   if (platformToolsDir) {
@@ -126,9 +150,11 @@ export async function prepareGradle(projectPath: string): Promise<{ execCmd: str
   const spawnOpts: any = { cwd: projectPath, env }
   if (useWrapper) {
     try { await fsPromises.chmod(gradlewPath, 0o755) } catch (e: unknown) { console.debug('[prepareGradle] chmod failed for gradlew:', String(e)) }
+    // Execute the wrapper directly without a shell to avoid shell tokenization of args (spaces in paths)
     spawnOpts.shell = false
   } else {
-    spawnOpts.shell = true
+    // Prefer executing gradle directly without invoking a shell to preserve argument boundaries
+    spawnOpts.shell = false
   }
 
   return { execCmd, gradleArgs, spawnOpts }