mobile-debug-mcp 0.10.0 → 0.12.0

package/dist/tools/interact.js

@@ -1,89 +1,39 @@
-import { promises as fs } from 'fs';
-import path from 'path';
 import { resolveTargetDevice } from '../resolve-device.js';
 import { AndroidInteract } from '../android/interact.js';
 import { iOSInteract } from '../ios/interact.js';
 export class ToolsInteract {
-    static async installAppHandler({ platform, appPath, deviceId }) {
-        let chosenPlatform = platform;
-        try {
-            const stat = await fs.stat(appPath).catch(() => null);
-            if (stat && stat.isDirectory()) {
-                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') {
+    static async waitForElementHandler({ platform, text, timeout, deviceId }) {
+        const effectiveTimeout = timeout ?? 10000;
+        if (platform === 'android') {
             const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
-            const androidInteract = new AndroidInteract();
-            const result = await androidInteract.installApp(appPath, resolved.id);
-            return result;
+            return await new AndroidInteract().waitForElement(text, effectiveTimeout, resolved.id);
         }
         else {
             const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
-            const iosInteract = new iOSInteract();
-            const result = await iosInteract.installApp(appPath, resolved.id);
-            return result;
+            return await new iOSInteract().waitForElement(text, effectiveTimeout, resolved.id);
         }
     }
-    static async startAppHandler({ platform, appId, deviceId }) {
-        if (platform === 'android') {
-            const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
-            return await new AndroidInteract().startApp(appId, resolved.id);
+    static async tapHandler({ platform, x, y, deviceId }) {
+        const effectivePlatform = platform || 'android';
+        if (effectivePlatform === 'android') {
+            const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+            return await new AndroidInteract().tap(x, y, resolved.id);
         }
         else {
-            const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
-            return await new iOSInteract().startApp(appId, resolved.id);
+            const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
+            return await new iOSInteract().tap(x, y, resolved.id);
         }
     }
-    static async terminateAppHandler({ platform, appId, deviceId }) {
-        if (platform === 'android') {
-            const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
-            return await new AndroidInteract().terminateApp(appId, resolved.id);
-        }
-        else {
-            const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
-            return await new iOSInteract().terminateApp(appId, resolved.id);
-        }
+    static async swipeHandler({ x1, y1, x2, y2, duration, deviceId }) {
+        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+        return await new AndroidInteract().swipe(x1, y1, x2, y2, duration, resolved.id);
     }
-    static async restartAppHandler({ platform, appId, deviceId }) {
-        if (platform === 'android') {
-            const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
-            return await new AndroidInteract().restartApp(appId, resolved.id);
-        }
-        else {
-            const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
-            return await new iOSInteract().restartApp(appId, resolved.id);
-        }
+    static async typeTextHandler({ text, deviceId }) {
+        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+        return await new AndroidInteract().typeText(text, resolved.id);
     }
-    static async resetAppDataHandler({ platform, appId, deviceId }) {
-        if (platform === 'android') {
-            const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
-            return await new AndroidInteract().resetAppData(appId, resolved.id);
-        }
-        else {
-            const resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
-            return await new iOSInteract().resetAppData(appId, resolved.id);
-        }
+    static async pressBackHandler({ deviceId }) {
+        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
+        return await new AndroidInteract().pressBack(resolved.id);
     }
 }

package/dist/tools/manage.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 ToolsManage {
+    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 ToolsManage.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 ToolsManage.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/tools/observe.js

@@ -1,9 +1,21 @@
-import { resolveTargetDevice, listDevices } from '../resolve-device.js';
+import { resolveTargetDevice } from '../resolve-device.js';
 import { AndroidObserve } from '../android/observe.js';
 import { iOSObserve } from '../ios/observe.js';
-import { AndroidInteract } from '../android/interact.js';
-import { iOSInteract } from '../ios/interact.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 });
@@ -25,93 +37,35 @@ export class ToolsObserve {
         const sid = sessionId || 'default';
         if (effectivePlatform === 'android') {
             const resolved = await resolveTargetDevice({ platform: 'android', appId: packageName, deviceId });
-            // AndroidObserve uses utils for log stream control; delegate to android/utils functions where appropriate
-            const { startAndroidLogStream } = await import('../android/utils.js');
-            return await startAndroidLogStream(packageName, level || 'error', resolved.id, sid);
+            // 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 });
-            // iOSObserve implements startIOSLogStream via ios/utils; use its helper
-            const { startIOSLogStream } = await import('../ios/utils.js');
-            return await startIOSLogStream(packageName, resolved.id, sid);
+            // 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') {
-            const { readLogStreamLines } = await import('../android/utils.js');
-            return await readLogStreamLines(sid, limit ?? 100, since);
+            return await new AndroidObserve().readLogStream(sid, limit ?? 100, since);
         }
         else {
-            const { readIOSLogStreamLines } = await import('../ios/utils.js');
-            return await readIOSLogStreamLines(sid, limit ?? 100, since);
+            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') {
-            const { stopAndroidLogStream } = await import('../android/utils.js');
-            return await stopAndroidLogStream(sid);
-        }
-        else {
-            const { stopIOSLogStream } = await import('../ios/utils.js');
-            return await stopIOSLogStream(sid);
-        }
-    }
-    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 waitForElementHandler({ platform, text, timeout, deviceId }) {
-        const effectiveTimeout = timeout ?? 10000;
-        if (platform === 'android') {
-            const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
-            return await new AndroidInteract().waitForElement(text, effectiveTimeout, resolved.id);
-        }
-        else {
-            const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
-            return await new iOSInteract().waitForElement(text, effectiveTimeout, resolved.id);
-        }
-    }
-    static async tapHandler({ platform, x, y, deviceId }) {
-        const effectivePlatform = platform || 'android';
-        if (effectivePlatform === 'android') {
-            const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
-            return await new AndroidInteract().tap(x, y, resolved.id);
+            return await new AndroidObserve().stopLogStream(sid);
         }
         else {
-            const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
-            return await new iOSInteract().tap(x, y, resolved.id);
+            return await new iOSObserve().stopLogStream(sid);
         }
     }
-    static async swipeHandler({ x1, y1, x2, y2, duration, deviceId }) {
-        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
-        return await new AndroidInteract().swipe(x1, y1, x2, y2, duration, resolved.id);
-    }
-    static async typeTextHandler({ text, deviceId }) {
-        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
-        return await new AndroidInteract().typeText(text, resolved.id);
-    }
-    static async pressBackHandler({ deviceId }) {
-        const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
-        return await new AndroidInteract().pressBack(resolved.id);
-    }
-    static async listDevicesHandler({ platform, appId }) {
-        const devices = await listDevices(platform, appId);
-        return { devices };
-    }
     static async captureScreenshotHandler({ platform, deviceId }) {
         const effectivePlatform = platform || 'android';
         if (effectivePlatform === 'android') {

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/diagnostics.js

@@ -0,0 +1,25 @@
+export function makeEnvSnapshot(keys) {
+    const snap = {};
+    for (const k of keys)
+        snap[k] = process.env[k];
+    return snap;
+}
+export function wrapExecResult(command, args, res) {
+    return {
+        exitCode: res.status,
+        stdout: res.stdout ? (typeof res.stdout === 'string' ? res.stdout : res.stdout.toString()) : '',
+        stderr: res.stderr ? (typeof res.stderr === 'string' ? res.stderr : res.stderr.toString()) : '',
+        envSnapshot: makeEnvSnapshot(['PATH', 'IDB_PATH', 'JAVA_HOME', 'HOME']),
+        command,
+        args,
+        suggestedFixes: []
+    };
+}
+export class DiagnosticError extends Error {
+    runResult;
+    constructor(message, runResult) {
+        super(message);
+        this.name = 'DiagnosticError';
+        this.runResult = runResult;
+    }
+}

package/docs/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to the **Mobile Debug MCP** project will be documented in this file.
 
+## [0.12.0]
+- Add iOS idb integration: config-driven idb path resolution (MCP_IDB_PATH / MCP config / IDB_PATH), robust idb detection and parsing of `ui describe-all` output.
+- Add reusable helpers: `isIDBInstalled()` and `getIdbCmd()` to centralise idb resolution and diagnostics.
+- Ensure install_app can build binaries (xcodebuild / Gradle) before installing so agents can autonomously build, install and validate fixes.
+- Add idb integration test (UI-tree + tap) and reorganise device-dependent tests under `test/device`.
+- Gate device tests behind RUN_DEVICE_TESTS (device tests won't run in default CI); added `test:device` runner and updated npm scripts.
+- Linting & tooling fixes: ESLint adjustments (ignore generated scripts), ESM entry fix for install-idb.ts, and various lint cleanups.
+- Added `test/device/README.md` with device-test run instructions.
+
+
+## [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