mobile-debug-mcp 0.9.0 → 0.11.0

package/dist/tools/observe.js

@@ -0,0 +1,80 @@
+import { resolveTargetDevice } from '../resolve-device.js';
+import { AndroidObserve } from '../android/observe.js';
+import { iOSObserve } from '../ios/observe.js';
+export class ToolsObserve {
+    static async getUITreeHandler({ platform, deviceId }) {
+        if (platform === 'android') {
+            const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+            return await new AndroidObserve().getUITree(resolved.id);
+        }
+        else {
+            const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
+            return await new iOSObserve().getUITree(resolved.id);
+        }
+    }
+    static async getCurrentScreenHandler({ deviceId }) {
+        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+        return await new AndroidObserve().getCurrentScreen(resolved.id);
+    }
+    static async getLogsHandler({ platform, appId, deviceId, lines }) {
+        if (platform === 'android') {
+            const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
+            const response = await new AndroidObserve().getLogs(appId, lines ?? 200, resolved.id);
+            const logs = Array.isArray(response.logs) ? response.logs : [];
+            const crashLines = logs.filter(line => line.includes('FATAL EXCEPTION'));
+            return { device: response.device, logs, crashLines };
+        }
+        else {
+            const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
+            const resp = await new iOSObserve().getLogs(appId, resolved.id);
+            const logs = Array.isArray(resp.logs) ? resp.logs : [];
+            const crashLines = logs.filter(l => l.includes('FATAL EXCEPTION'));
+            return { device: resp.device, logs, crashLines };
+        }
+    }
+    static async startLogStreamHandler({ platform, packageName, level, sessionId, deviceId }) {
+        const effectivePlatform = platform || 'android';
+        const sid = sessionId || 'default';
+        if (effectivePlatform === 'android') {
+            const resolved = await resolveTargetDevice({ platform: 'android', appId: packageName, deviceId });
+            // Delegate to AndroidObserve's log stream methods
+            return await new AndroidObserve().startLogStream(packageName, level || 'error', resolved.id, sid);
+        }
+        else {
+            const resolved = await resolveTargetDevice({ platform: 'ios', appId: packageName, deviceId });
+            // Delegate to iOSObserve for starting log streams
+            return await new iOSObserve().startLogStream(packageName, resolved.id, sid);
+        }
+    }
+    static async readLogStreamHandler({ platform, sessionId, limit, since }) {
+        const effectivePlatform = platform || 'android';
+        const sid = sessionId || 'default';
+        if (effectivePlatform === 'android') {
+            return await new AndroidObserve().readLogStream(sid, limit ?? 100, since);
+        }
+        else {
+            return await new iOSObserve().readLogStream(sid, limit ?? 100, since);
+        }
+    }
+    static async stopLogStreamHandler({ platform, sessionId }) {
+        const effectivePlatform = platform || 'android';
+        const sid = sessionId || 'default';
+        if (effectivePlatform === 'android') {
+            return await new AndroidObserve().stopLogStream(sid);
+        }
+        else {
+            return await new iOSObserve().stopLogStream(sid);
+        }
+    }
+    static async captureScreenshotHandler({ platform, deviceId }) {
+        const effectivePlatform = platform || 'android';
+        if (effectivePlatform === 'android') {
+            const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+            return await new AndroidObserve().captureScreen(resolved.id);
+        }
+        else {
+            const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
+            return await new iOSObserve().captureScreenshot(resolved.id);
+        }
+    }
+}

package/dist/tools/run.js

@@ -0,0 +1,180 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { resolveTargetDevice, listDevices } from '../resolve-device.js';
+import { AndroidManage } from '../android/manage.js';
+import { iOSManage } from '../ios/manage.js';
+export class ToolsRun {
+    static async buildAppHandler({ platform, projectPath, variant }) {
+        // delegate to platform-specific build implementations
+        const chosen = platform || 'android';
+        if (chosen === 'android') {
+            const android = new AndroidManage();
+            const artifact = await android.build(projectPath, variant);
+            return artifact;
+        }
+        else {
+            const ios = new iOSManage();
+            const artifact = await ios.build(projectPath, variant);
+            return artifact;
+        }
+    }
+    static async installAppHandler({ platform, appPath, deviceId }) {
+        let chosenPlatform = platform;
+        try {
+            const stat = await fs.stat(appPath).catch(() => null);
+            if (stat && stat.isDirectory()) {
+                // If the directory itself looks like an .app bundle, treat as iOS
+                if (appPath.endsWith('.app')) {
+                    chosenPlatform = 'ios';
+                }
+                else {
+                    const files = (await fs.readdir(appPath).catch(() => []));
+                    if (files.some(f => f.endsWith('.xcodeproj') || f.endsWith('.xcworkspace'))) {
+                        chosenPlatform = 'ios';
+                    }
+                    else if (files.includes('gradlew') || files.includes('build.gradle') || files.includes('settings.gradle') || (files.includes('app') && (await fs.stat(path.join(appPath, 'app')).catch(() => null)))) {
+                        chosenPlatform = 'android';
+                    }
+                    else {
+                        chosenPlatform = 'android';
+                    }
+                }
+            }
+            else if (typeof appPath === 'string') {
+                const ext = path.extname(appPath).toLowerCase();
+                if (ext === '.apk')
+                    chosenPlatform = 'android';
+                else if (ext === '.ipa' || ext === '.app')
+                    chosenPlatform = 'ios';
+                else
+                    chosenPlatform = 'android';
+            }
+        }
+        catch {
+            chosenPlatform = 'android';
+        }
+        if (chosenPlatform === 'android') {
+            const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+            const androidRun = new AndroidManage();
+            const result = await androidRun.installApp(appPath, resolved.id);
+            return result;
+        }
+        else {
+            const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
+            const iosRun = new iOSManage();
+            const result = await iosRun.installApp(appPath, resolved.id);
+            return result;
+        }
+    }
+    static async startAppHandler({ platform, appId, deviceId }) {
+        if (platform === 'android') {
+            const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
+            return await new AndroidManage().startApp(appId, resolved.id);
+        }
+        else {
+            const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
+            return await new iOSManage().startApp(appId, resolved.id);
+        }
+    }
+    static async terminateAppHandler({ platform, appId, deviceId }) {
+        if (platform === 'android') {
+            const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
+            return await new AndroidManage().terminateApp(appId, resolved.id);
+        }
+        else {
+            const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
+            return await new iOSManage().terminateApp(appId, resolved.id);
+        }
+    }
+    static async restartAppHandler({ platform, appId, deviceId }) {
+        if (platform === 'android') {
+            const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
+            return await new AndroidManage().restartApp(appId, resolved.id);
+        }
+        else {
+            const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
+            return await new iOSManage().restartApp(appId, resolved.id);
+        }
+    }
+    static async resetAppDataHandler({ platform, appId, deviceId }) {
+        if (platform === 'android') {
+            const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
+            return await new AndroidManage().resetAppData(appId, resolved.id);
+        }
+        else {
+            const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
+            return await new iOSManage().resetAppData(appId, resolved.id);
+        }
+    }
+    static async buildAndInstallHandler({ platform, projectPath, deviceId, timeout }) {
+        const events = [];
+        const pushEvent = (obj) => events.push(JSON.stringify(obj));
+        const effectiveTimeout = timeout ?? 180000; // reserved for future streaming/timeouts
+        void effectiveTimeout;
+        // determine platform if not provided by inspecting path
+        let chosenPlatform = platform;
+        try {
+            const stat = await fs.stat(projectPath).catch(() => null);
+            if (!chosenPlatform) {
+                if (stat && stat.isDirectory()) {
+                    const files = (await fs.readdir(projectPath).catch(() => []));
+                    if (files.some(f => f.endsWith('.xcodeproj') || f.endsWith('.xcworkspace')))
+                        chosenPlatform = 'ios';
+                    else
+                        chosenPlatform = 'android';
+                }
+                else {
+                    const ext = path.extname(projectPath).toLowerCase();
+                    if (ext === '.apk')
+                        chosenPlatform = 'android';
+                    else if (ext === '.ipa' || ext === '.app')
+                        chosenPlatform = 'ios';
+                    else
+                        chosenPlatform = 'android';
+                }
+            }
+        }
+        catch {
+            chosenPlatform = chosenPlatform || 'android';
+        }
+        pushEvent({ type: 'build', status: 'started', platform: chosenPlatform });
+        let buildRes;
+        try {
+            buildRes = await ToolsRun.buildAppHandler({ platform: chosenPlatform, projectPath });
+            if (buildRes && buildRes.error) {
+                pushEvent({ type: 'build', status: 'failed', error: buildRes.error });
+                return { ndjson: events.join('\n') + '\n', result: { success: false, error: buildRes.error } };
+            }
+            pushEvent({ type: 'build', status: 'finished', artifactPath: buildRes.artifactPath });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            pushEvent({ type: 'build', status: 'failed', error: msg });
+            return { ndjson: events.join('\n') + '\n', result: { success: false, error: msg } };
+        }
+        // Install phase
+        const artifact = buildRes.artifactPath || projectPath;
+        pushEvent({ type: 'install', status: 'started', artifactPath: artifact, deviceId });
+        let installRes;
+        try {
+            installRes = await ToolsRun.installAppHandler({ platform: chosenPlatform, appPath: artifact, deviceId });
+            if (installRes && installRes.installed === true) {
+                pushEvent({ type: 'install', status: 'finished', artifactPath: artifact, device: installRes.device });
+                return { ndjson: events.join('\n') + '\n', result: { success: true, artifactPath: artifact, device: installRes.device, output: installRes.output } };
+            }
+            else {
+                pushEvent({ type: 'install', status: 'failed', error: installRes.error || 'unknown' });
+                return { ndjson: events.join('\n') + '\n', result: { success: false, error: installRes.error || 'install failed' } };
+            }
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            pushEvent({ type: 'install', status: 'failed', error: msg });
+            return { ndjson: events.join('\n') + '\n', result: { success: false, error: msg } };
+        }
+    }
+    static async listDevicesHandler({ platform, appId }) {
+        const devices = await listDevices(platform, appId);
+        return { devices };
+    }
+}

package/dist/utils/index.js

@@ -0,0 +1 @@
+export { detectJavaHome } from './java.js';

package/dist/utils/java.js

@@ -0,0 +1,76 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import path from 'path';
+export async function detectJavaHome() {
+    try {
+        // If JAVA_HOME is set, validate it's Java 17
+        if (process.env.JAVA_HOME) {
+            try {
+                const javaBin = path.join(process.env.JAVA_HOME, 'bin', 'java');
+                const v = execSync(`"${javaBin}" -version`, { stdio: ['ignore', 'pipe', 'pipe'] }).toString();
+                if (/\b17\b/.test(v) || /17\./.test(v))
+                    return process.env.JAVA_HOME;
+                console.debug('[java.detect] Existing JAVA_HOME does not appear to be Java 17, will search for JDK17');
+            }
+            catch {
+                console.debug('[java.detect] Failed to validate existing JAVA_HOME, searching for JDK17');
+            }
+        }
+        // macOS explicit path
+        const explicit = '/Library/Java/JavaVirtualMachines/jdk-17.jdk/Contents/Home';
+        if (existsSync(explicit))
+            return explicit;
+        // Android Studio JBR candidates
+        const jbrCandidates = [
+            '/Applications/Android Studio.app/Contents/jbr',
+            '/Applications/Android Studio Preview.app/Contents/jbr',
+            '/Applications/Android Studio Preview 2022.3.app/Contents/jbr',
+            '/Applications/Android Studio Preview 2023.1.app/Contents/jbr'
+        ];
+        for (const p of jbrCandidates) {
+            const javaBin = path.join(p, 'bin', 'java');
+            if (existsSync(javaBin)) {
+                try {
+                    const v = execSync(`"${javaBin}" -version`, { stdio: ['ignore', 'pipe', 'pipe'] }).toString();
+                    if (/\b17\b/.test(v) || /17\./.test(v))
+                        return p;
+                }
+                catch { }
+            }
+        }
+        // macOS /usr/libexec/java_home
+        try {
+            const out = execSync('/usr/libexec/java_home -v 17', { stdio: ['ignore', 'pipe', 'pipe'] }).toString().trim();
+            if (out)
+                return out;
+        }
+        catch { }
+        // macOS common JDK locations
+        try {
+            const homes = execSync('ls -1 /Library/Java/JavaVirtualMachines || true', { stdio: ['ignore', 'pipe', 'inherit'] }).toString().split(/\r?\n/).filter(Boolean);
+            for (const h of homes) {
+                if (h.toLowerCase().includes('17') || h.toLowerCase().includes('jdk-17')) {
+                    const candidate = `/Library/Java/JavaVirtualMachines/${h}/Contents/Home`;
+                    return candidate;
+                }
+            }
+        }
+        catch { }
+        // Linux locations
+        const linuxCandidates = [
+            '/usr/lib/jvm/java-17-openjdk-amd64',
+            '/usr/lib/jvm/java-17-openjdk',
+            '/usr/lib/jvm/zulu17',
+            '/usr/lib/jvm/temurin-17-jdk'
+        ];
+        for (const p of linuxCandidates) {
+            try {
+                if (existsSync(p))
+                    return p;
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return undefined;
+}

package/docs/CHANGELOG.md

@@ -2,14 +2,33 @@
 
 All notable changes to the **Mobile Debug MCP** project will be documented in this file.
 
-## [0.9.0] - 2026-03-14
+## [0.11.0]
+- Tools refactor - broke functions into 3 distinct class types; interact (for UI manipulation), manage (for build, installing etc) and observe (observing the app whilst running)
+- Add convenience method to build and install
+
+## [0.10.0]
+
+### Added / Changed
+- Tools refactor: consolidated handlers into ToolsInteract and ToolsObserve classes to centralise tool wiring and simplify platform delegation.
+- install_app now builds project directories (Gradle/xcodebuild) and supports streamed installs with robust fallbacks (adb push + pm install).
+- Added log streaming utilities and improved log parsing/crash detection heuristics.
+- CI: added lint and unit tests for handler parity; updated README links to docs and changelog.
+- Docs: Created docs/TOOLS.md with comprehensive tool definitions and examples.
+
+
+## [0.9.0] 
 
 ### Added / Changed
-- install_app now builds apps when given a project directory and then installs the produced artifact (Android: Gradle wrapper assembleDebug; iOS: xcodebuild where applicable).
-- Auto-detects and prefers JDK 17 (Android Studio JBR or system JDK). Any JAVA_HOME overrides are scoped to the spawned build process, avoiding global system changes.
-- Respects ADB_PATH and falls back to PATH if unset. Set ADB_PATH to an explicit adb binary to avoid PATH discovery issues.
-- Increased default adb timeout to 120s for installs; timeout can be configured via MCP_ADB_TIMEOUT or ADB_TIMEOUT environment variables.
-- Improved logging and error messages for build/install steps. Unit and integration tests updated and converted to TypeScript.
+- install_app now builds apps when given a project directory and then installs the produced artifact (Android: Gradle wrapper assembleDebug; iOS: xcodebuild where applicable). When a workspace (.xcworkspace) is present, the iOS build uses `-workspace` instead of `-project` to support CocoaPods and multi-project setups.
+- Build orchestration uses a scoped JAVA_HOME (detectJavaHome) and prefers JDK 17 when available; Gradle invocations avoid mutating global env and pass java home via `-Dorg.gradle.java.home`.
+- Streaming ADB support: added `spawnAdb()` (streams stdout/stderr and returns exit code) alongside `execAdb()` (returns buffered stdout). This enables live install output and robust fallbacks.
+- Resilient install flow: streamed `adb install` is attempted first; on failure MCP falls back to `adb push` + `pm install -r` to improve reliability on devices that don't support streamed install or when install times out.
+- Centralised timeout logic: extracted `getAdbTimeout(args, customTimeout)` to standardise timeout selection (precedence: custom timeout > MCP_ADB_TIMEOUT/ADB_TIMEOUT env > per-command defaults — install: 120s, logcat: 10s, uiautomator dump: 20s).
+- Improved types: `execAdb` / `spawnAdb` now accept `SpawnOptionsWithTimeout` (typed extension of Node's SpawnOptions with an optional timeout property).
+- Linting and CI: added ESLint (unused-imports plugin), added `npm run lint` / `npm run lint:fix` scripts, and updated CI to run lint in the unit job. ESLint config converted to the flat `eslint.config.js` format.
+- Tests: unit tests updated to exercise real build/install flows using fake `adb` and `gradlew` wrappers; added detectJavaHome smoke tests. Integration workflows remain manual and require device/emulator access.
+- Misc: improved logging, more informative error messages, and several internal cleanups (removed redundant try/catch, consolidated helper functions).
+
 
 ## [0.8.0]
 

package/eslint.config.cjs

@@ -0,0 +1,36 @@
+module.exports = [
+  // Files/directories to ignore
+  {
+    ignores: [
+      'dist/',
+      'node_modules/',
+      '.git/',
+      '.vscode/',
+      'coverage/',
+      '.env'
+    ]
+  },
+  // Apply rules to JS/TS source and tests
+  {
+    files: ['src/**/*.ts', 'test/**/*.ts', 'src/**/*.js', 'test/**/*.js'],
+    languageOptions: {
+      parser: require.resolve('@typescript-eslint/parser'),
+      parserOptions: {
+        ecmaVersion: 2020,
+        sourceType: 'module',
+        project: './tsconfig.json'
+      }
+    },
+    plugins: {
+      '@typescript-eslint': require('@typescript-eslint/eslint-plugin'),
+      'unused-imports': require('eslint-plugin-unused-imports')
+    },
+    rules: {
+      // Use plugin to error on unused imports and provide autofix where possible
+      'unused-imports/no-unused-imports': 'error',
+      'unused-imports/no-unused-vars': ['error', { vars: 'all', args: 'after-used', ignoreRestSiblings: true }],
+      // Disable the default TS rule to avoid duplicate warnings
+      '@typescript-eslint/no-unused-vars': 'off'
+    }
+  }
+]

package/eslint.config.js

@@ -0,0 +1,60 @@
+import tsParser from '@typescript-eslint/parser'
+import tsPlugin from '@typescript-eslint/eslint-plugin'
+import unusedImports from 'eslint-plugin-unused-imports'
+
+export default [
+  // Files/directories to ignore
+  {
+    ignores: [
+      'dist/',
+      'node_modules/',
+      '.git/',
+      '.vscode/',
+      'coverage/',
+      '.env'
+    ]
+  },
+  // Apply rules to JS/TS source
+  {
+    files: ['src/**/*.ts', 'src/**/*.js'],
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        ecmaVersion: 2020,
+        sourceType: 'module',
+        project: './tsconfig.json'
+      }
+    },
+    plugins: {
+      '@typescript-eslint': tsPlugin,
+      'unused-imports': unusedImports
+    },
+    rules: {
+      // Use plugin to error on unused imports and provide autofix where possible
+      'unused-imports/no-unused-imports': 'error',
+      'unused-imports/no-unused-vars': ['error', { vars: 'all', args: 'after-used', ignoreRestSiblings: true }],
+      // Disable the default TS rule to avoid duplicate warnings
+      '@typescript-eslint/no-unused-vars': 'off'
+    }
+  },
+  // Apply lighter rules to test files (no project reference to avoid TS project parsing)
+  {
+    files: ['test/**/*.ts', 'test/**/*.js'],
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        ecmaVersion: 2020,
+        sourceType: 'module'
+      }
+    },
+    plugins: {
+      '@typescript-eslint': tsPlugin,
+      'unused-imports': unusedImports
+    },
+    rules: {
+      'unused-imports/no-unused-imports': 'error',
+      'unused-imports/no-unused-vars': ['error', { vars: 'all', args: 'after-used', ignoreRestSiblings: true }],
+      '@typescript-eslint/no-unused-vars': 'off'
+    }
+  }
+]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobile-debug-mcp",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "MCP server for mobile app debugging (Android + iOS), with focus on security and reliability",
   "type": "module",
   "bin": {
@@ -12,7 +12,9 @@
     "prepare": "npm run build",
     "test:unit": "tsx test/unit/index.ts",
     "test:integration": "tsx test/integration/index.ts",
-    "test": "npm run test:unit && npm run test:integration"
+    "test": "npm run test:unit && npm run test:integration",
+    "lint": "eslint --ext .ts,.js src test --quiet",
+    "lint:fix": "eslint --ext .ts,.js src test --fix"
   },
   "engines": {
     "node": ">=18"
@@ -24,6 +26,10 @@
   },
   "devDependencies": {
     "@types/node": "^25.4.0",
+    "@typescript-eslint/eslint-plugin": "^8.57.0",
+    "@typescript-eslint/parser": "^8.57.0",
+    "eslint": "^9.39.4",
+    "eslint-plugin-unused-imports": "^4.4.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   }

package/src/android/interact.ts

@@ -1,10 +1,6 @@
-import { StartAppResponse, TerminateAppResponse, RestartAppResponse, ResetAppDataResponse, WaitForElementResponse, TapResponse, SwipeResponse, TypeTextResponse, PressBackResponse } from "../types.js"
-import { execAdb, getAndroidDeviceMetadata, getDeviceInfo, detectJavaHome } from "./utils.js"
+import { WaitForElementResponse, TapResponse, SwipeResponse, TypeTextResponse, PressBackResponse } from "../types.js"
+import { execAdb, getAndroidDeviceMetadata, getDeviceInfo } from "./utils.js"
 import { AndroidObserve } from "./observe.js"
-import { promises as fs } from "fs"
-import { spawn, execSync } from "child_process"
-import path from "path"
-import { existsSync } from "fs"
 
 
 export class AndroidInteract {
@@ -92,134 +88,4 @@ export class AndroidInteract {
     }
   }
 
-  async installApp(apkPath: string, deviceId?: string): Promise<import("../types.js").InstallAppResponse> {
-    const metadata = await getAndroidDeviceMetadata("", deviceId)
-    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
-
-    // Helper to recursively find first APK under a directory
-    async function findApk(dir: string): Promise<string | undefined> {
-      const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => [])
-      for (const e of entries) {
-        const full = path.join(dir, e.name)
-        if (e.isDirectory()) {
-          const found = await findApk(full)
-          if (found) return found
-        } else if (e.isFile() && full.endsWith('.apk')) {
-          return full
-        }
-      }
-      return undefined
-    }
-
-    try {
-      let apkToInstall = apkPath
-
-      // If a directory is provided, attempt to build via Gradle
-      const stat = await fs.stat(apkPath).catch(() => null)
-      if (stat && stat.isDirectory()) {
-        const gradlewPath = path.join(apkPath, 'gradlew')
-        const gradleCmd = existsSync(gradlewPath) ? './gradlew' : 'gradle'
-
-        await new Promise<void>(async (resolve, reject) => {
-          // Auto-detect and set JAVA_HOME (prefer JDK 17) so builds don't require manual environment setup
-          const detectedJavaHome = await detectJavaHome().catch(() => undefined)
-          const env = Object.assign({}, process.env)
-          if (detectedJavaHome) {
-            // Override existing JAVA_HOME if detection found a preferably compatible JDK (e.g., JDK 17).
-            if (env.JAVA_HOME !== detectedJavaHome) {
-              env.JAVA_HOME = detectedJavaHome
-              // Also ensure the JDK bin is on PATH so tools like jlink/javac are resolved from the detected JDK
-              env.PATH = `${path.join(detectedJavaHome, 'bin')}${path.delimiter}${env.PATH || ''}`
-              console.debug('[android] Overriding JAVA_HOME with detected path:', detectedJavaHome)
-            }
-          }
-
-          // Sanitize environment so user shell init scripts are less likely to override our JAVA_HOME.
-          try {
-            // Remove obvious shell profile hints; avoid touching SDKMAN symlinks or on-disk state.
-            delete env.SHELL
-          } catch (e) {}
-
-          // If we detected a compatible JDK, instruct Gradle to use it and avoid daemon reuse
-          // Prepare gradle invocation
-          const gradleArgs = ['assembleDebug']
-          if (detectedJavaHome) {
-            gradleArgs.push(`-Dorg.gradle.java.home=${detectedJavaHome}`)
-            gradleArgs.push('--no-daemon')
-            env.GRADLE_JAVA_HOME = detectedJavaHome
-          }
-
-          // Prefer invoking the wrapper directly without a shell to avoid user profile shims (sdkman) re-setting JAVA_HOME
-          const wrapperPath = path.join(apkPath, 'gradlew')
-          const useWrapper = existsSync(wrapperPath)
-          const execCmd = useWrapper ? wrapperPath : gradleCmd
-          const spawnOpts: any = { cwd: apkPath, env }
-          // When using wrapper, ensure it's executable and invoke directly (no shell)
-          if (useWrapper) {
-            // Ensure the wrapper is executable; swallow errors from chmod (best-effort).
-            await fs.chmod(wrapperPath, 0o755).catch(() => {})
-            spawnOpts.shell = false
-          } else {
-            // if using system 'gradle' allow shell to resolve platform PATH
-            spawnOpts.shell = true
-          }
-
-          const proc = spawn(execCmd, gradleArgs, spawnOpts)
-          let stderr = ''
-          proc.stderr?.on('data', d => stderr += d.toString())
-          proc.on('close', code => {
-            if (code === 0) resolve()
-            else reject(new Error(stderr || `Gradle build failed with code ${code}`))
-          })
-          proc.on('error', err => reject(err))
-        })
-
-        const built = await findApk(apkPath)
-        if (!built) throw new Error('Could not locate built APK after running Gradle')
-        apkToInstall = built
-      }
-
-      const output = await execAdb(['install', '-r', apkToInstall], deviceId)
-      return { device: deviceInfo, installed: true, output }
-    } catch (e) {
-      return { device: deviceInfo, installed: false, error: e instanceof Error ? e.message : String(e) }
-    }
-  }
-
-  async startApp(appId: string, deviceId?: string): Promise<StartAppResponse> {
-    const metadata = await getAndroidDeviceMetadata(appId, deviceId)
-    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
-    
-    await execAdb(['shell', 'monkey', '-p', appId, '-c', 'android.intent.category.LAUNCHER', '1'], deviceId)
-    
-    return { device: deviceInfo, appStarted: true, launchTimeMs: 1000 }
-  }
-
-  async terminateApp(appId: string, deviceId?: string): Promise<TerminateAppResponse> {
-    const metadata = await getAndroidDeviceMetadata(appId, deviceId)
-    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
-
-    await execAdb(['shell', 'am', 'force-stop', appId], deviceId)
-    
-    return { device: deviceInfo, appTerminated: true }
-  }
-
-  async restartApp(appId: string, deviceId?: string): Promise<RestartAppResponse> {
-    await this.terminateApp(appId, deviceId)
-    const startResult = await this.startApp(appId, deviceId)
-    return {
-      device: startResult.device,
-      appRestarted: startResult.appStarted,
-      launchTimeMs: startResult.launchTimeMs
-    }
-  }
-
-  async resetAppData(appId: string, deviceId?: string): Promise<ResetAppDataResponse> {
-    const metadata = await getAndroidDeviceMetadata(appId, deviceId)
-    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
-
-    const output = await execAdb(['shell', 'pm', 'clear', appId], deviceId)
-    
-    return { device: deviceInfo, dataCleared: output === 'Success' }
-  }
 }