mobile-debug-mcp 0.10.0 → 0.12.0

package/dist/ios/interact.js

@@ -1,8 +1,6 @@
-import { promises as fs } from "fs";
 import { spawn } from "child_process";
-import { execCommand, getIOSDeviceMetadata, validateBundleId, IDB } from "./utils.js";
+import { getIOSDeviceMetadata, getIdbCmd, isIDBInstalled } from "./utils.js";
 import { iOSObserve } from "./observe.js";
-import path from "path";
 export class iOSInteract {
     observe = new iOSObserve();
     async waitForElement(text, timeout, deviceId = "booted") {
@@ -33,12 +31,8 @@ export class iOSInteract {
     }
     async tap(x, y, deviceId = "booted") {
         const device = await getIOSDeviceMetadata(deviceId);
-        // Check for idb
-        const child = spawn(IDB, ['--version']);
-        const idbExists = await new Promise((resolve) => {
-            child.on('error', () => resolve(false));
-            child.on('close', (code) => resolve(code === 0));
-        });
+        // Use shared helper to detect idb
+        const idbExists = await isIDBInstalled();
         if (!idbExists) {
             return {
                 device,
@@ -55,7 +49,7 @@ export class iOSInteract {
                 args.push('--udid', targetUdid);
             }
             await new Promise((resolve, reject) => {
-                const proc = spawn(IDB, args);
+                const proc = spawn(getIdbCmd(), args);
                 let stderr = '';
                 proc.stderr.on('data', d => stderr += d.toString());
                 proc.on('close', code => {
@@ -72,169 +66,4 @@ export class iOSInteract {
             return { device, success: false, x, y, error: e instanceof Error ? e.message : String(e) };
         }
     }
-    async installApp(appPath, deviceId = "booted") {
-        const device = await getIOSDeviceMetadata(deviceId);
-        // Helper to find .app bundles under a directory
-        async function findAppBundle(dir) {
-            const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
-            for (const e of entries) {
-                const full = path.join(dir, e.name);
-                if (e.isDirectory()) {
-                    if (full.endsWith('.app'))
-                        return full;
-                    const found = await findAppBundle(full);
-                    if (found)
-                        return found;
-                }
-            }
-            return undefined;
-        }
-        try {
-            let toInstall = appPath;
-            const stat = await fs.stat(appPath).catch(() => null);
-            if (stat && stat.isDirectory()) {
-                // If directory already contains a .app, use it
-                const found = await findAppBundle(appPath);
-                if (found) {
-                    toInstall = found;
-                }
-                else {
-                    // Attempt to locate an Xcode project and build for simulator
-                    const files = await fs.readdir(appPath).catch(() => []);
-                    // Prefer workspace when present (CocoaPods / multi-project setups)
-                    const workspace = files.find(f => f.endsWith('.xcworkspace'));
-                    const proj = files.find(f => f.endsWith('.xcodeproj'));
-                    if (!workspace && !proj)
-                        throw new Error('No .app bundle, .xcworkspace or .xcodeproj found in directory');
-                    let buildArgs;
-                    let scheme;
-                    if (workspace) {
-                        const workspacePath = path.join(appPath, workspace);
-                        scheme = workspace.replace(/\.xcworkspace$/, '');
-                        buildArgs = ['-workspace', workspacePath, '-scheme', scheme, '-configuration', 'Debug', '-sdk', 'iphonesimulator', 'build', '-quiet'];
-                    }
-                    else {
-                        const projectPath = path.join(appPath, proj);
-                        scheme = proj.replace(/\.xcodeproj$/, '');
-                        buildArgs = ['-project', projectPath, '-scheme', scheme, '-configuration', 'Debug', '-sdk', 'iphonesimulator', 'build', '-quiet'];
-                    }
-                    await new Promise((resolve, reject) => {
-                        const proc = spawn('xcodebuild', buildArgs, { cwd: appPath });
-                        let stderr = '';
-                        proc.stderr?.on('data', d => stderr += d.toString());
-                        proc.on('close', code => {
-                            if (code === 0)
-                                resolve();
-                            else
-                                reject(new Error(stderr || `xcodebuild failed with code ${code}`));
-                        });
-                        proc.on('error', err => reject(err));
-                    });
-                    const built = await findAppBundle(appPath);
-                    if (!built)
-                        throw new Error('Could not locate built .app after xcodebuild');
-                    toInstall = built;
-                }
-            }
-            // Try simulator install first
-            try {
-                const res = await execCommand(['simctl', 'install', deviceId, toInstall], deviceId);
-                return { device, installed: true, output: res.output };
-            }
-            catch (e) {
-                // If simctl fails and idb is available, try idb install for physical devices
-                try {
-                    const child = spawn(IDB, ['--version']);
-                    const idbExists = await new Promise((resolve) => {
-                        child.on('error', () => resolve(false));
-                        child.on('close', (code) => resolve(code === 0));
-                    });
-                    if (idbExists) {
-                        // Use idb to install (works for physical devices and simulators)
-                        await new Promise((resolve, reject) => {
-                            const proc = spawn(IDB, ['install', toInstall, '--udid', device.id]);
-                            let stderr = '';
-                            proc.stderr.on('data', d => stderr += d.toString());
-                            proc.on('close', code => {
-                                if (code === 0)
-                                    resolve();
-                                else
-                                    reject(new Error(stderr || `idb install failed with code ${code}`));
-                            });
-                            proc.on('error', err => reject(err));
-                        });
-                        return { device, installed: true };
-                    }
-                }
-                catch {
-                    // fallthrough
-                }
-                return { device, installed: false, error: e instanceof Error ? e.message : String(e) };
-            }
-        }
-        catch (e) {
-            return { device, installed: false, error: e instanceof Error ? e.message : String(e) };
-        }
-    }
-    async startApp(bundleId, deviceId = "booted") {
-        validateBundleId(bundleId);
-        const result = await execCommand(['simctl', 'launch', deviceId, bundleId], deviceId);
-        const device = await getIOSDeviceMetadata(deviceId);
-        // Simulate launch time and appStarted for demonstration
-        return {
-            device,
-            appStarted: !!result.output,
-            launchTimeMs: 1000,
-        };
-    }
-    async terminateApp(bundleId, deviceId = "booted") {
-        validateBundleId(bundleId);
-        await execCommand(['simctl', 'terminate', deviceId, bundleId], deviceId);
-        const device = await getIOSDeviceMetadata(deviceId);
-        return {
-            device,
-            appTerminated: true
-        };
-    }
-    async restartApp(bundleId, deviceId = "booted") {
-        // terminateApp already validates bundleId
-        await this.terminateApp(bundleId, deviceId);
-        const startResult = await this.startApp(bundleId, deviceId);
-        return {
-            device: startResult.device,
-            appRestarted: startResult.appStarted,
-            launchTimeMs: startResult.launchTimeMs
-        };
-    }
-    async resetAppData(bundleId, deviceId = "booted") {
-        validateBundleId(bundleId);
-        await this.terminateApp(bundleId, deviceId);
-        const device = await getIOSDeviceMetadata(deviceId);
-        // Get data container path
-        const containerResult = await execCommand(['simctl', 'get_app_container', deviceId, bundleId, 'data'], deviceId);
-        const dataPath = containerResult.output.trim();
-        if (!dataPath) {
-            throw new Error(`Could not find data container for ${bundleId}`);
-        }
-        // Clear contents of Library and Documents
-        try {
-            const libraryPath = `${dataPath}/Library`;
-            const documentsPath = `${dataPath}/Documents`;
-            const tmpPath = `${dataPath}/tmp`;
-            await fs.rm(libraryPath, { recursive: true, force: true }).catch(() => { });
-            await fs.rm(documentsPath, { recursive: true, force: true }).catch(() => { });
-            await fs.rm(tmpPath, { recursive: true, force: true }).catch(() => { });
-            // Re-create empty directories as they are expected by apps
-            await fs.mkdir(libraryPath, { recursive: true }).catch(() => { });
-            await fs.mkdir(documentsPath, { recursive: true }).catch(() => { });
-            await fs.mkdir(tmpPath, { recursive: true }).catch(() => { });
-            return {
-                device,
-                dataCleared: true
-            };
-        }
-        catch (e) {
-            throw new Error(`Failed to clear data for ${bundleId}: ${e instanceof Error ? e.message : String(e)}`);
-        }
-    }
 }

package/dist/ios/manage.js

@@ -0,0 +1,169 @@
+import { promises as fs } from "fs";
+import { spawn } from "child_process";
+import { execCommand, execCommandWithDiagnostics, getIOSDeviceMetadata, validateBundleId, getIdbCmd, findAppBundle } from "./utils.js";
+import path from "path";
+export class iOSManage {
+    async build(projectPath, _variant) {
+        void _variant;
+        try {
+            const files = await fs.readdir(projectPath).catch(() => []);
+            const workspace = files.find(f => f.endsWith('.xcworkspace'));
+            const proj = files.find(f => f.endsWith('.xcodeproj'));
+            if (!workspace && !proj)
+                return { error: 'No Xcode project or workspace found' };
+            let buildArgs;
+            if (workspace) {
+                const workspacePath = path.join(projectPath, workspace);
+                const scheme = workspace.replace(/\.xcworkspace$/, '');
+                buildArgs = ['-workspace', workspacePath, '-scheme', scheme, '-configuration', 'Debug', '-sdk', 'iphonesimulator', 'build'];
+            }
+            else {
+                const projectPathFull = path.join(projectPath, proj);
+                const scheme = proj.replace(/\.xcodeproj$/, '');
+                buildArgs = ['-project', projectPathFull, '-scheme', scheme, '-configuration', 'Debug', '-sdk', 'iphonesimulator', 'build'];
+            }
+            await new Promise((resolve, reject) => {
+                const xcodeCmd = process.env.XCODEBUILD_PATH || 'xcodebuild';
+                const proc = spawn(xcodeCmd, buildArgs, { cwd: projectPath });
+                let stderr = '';
+                proc.stderr?.on('data', d => stderr += d.toString());
+                proc.on('close', code => {
+                    if (code === 0)
+                        resolve();
+                    else
+                        reject(new Error(stderr || `xcodebuild failed with code ${code}`));
+                });
+                proc.on('error', err => reject(err));
+            });
+            const built = await findAppBundle(projectPath);
+            if (!built)
+                return { error: 'Could not find .app after build' };
+            return { artifactPath: built };
+        }
+        catch (e) {
+            return { error: e instanceof Error ? e.message : String(e) };
+        }
+    }
+    async installApp(appPath, deviceId = "booted") {
+        const device = await getIOSDeviceMetadata(deviceId);
+        try {
+            let toInstall = appPath;
+            const stat = await fs.stat(appPath).catch(() => null);
+            if (stat && stat.isDirectory()) {
+                if (appPath.endsWith('.app')) {
+                    toInstall = appPath;
+                }
+                else {
+                    const found = await findAppBundle(appPath);
+                    if (found) {
+                        toInstall = found;
+                    }
+                    else {
+                        // Reuse the existing build() implementation to avoid duplicating the xcodebuild logic
+                        const buildRes = await this.build(appPath);
+                        if (buildRes.error)
+                            throw new Error(buildRes.error);
+                        toInstall = buildRes.artifactPath;
+                    }
+                }
+            }
+            try {
+                const res = await execCommand(['simctl', 'install', deviceId, toInstall], deviceId);
+                return { device, installed: true, output: res.output };
+            }
+            catch (e) {
+                // Gather diagnostics for simctl failure
+                const diag = execCommandWithDiagnostics(['simctl', 'install', deviceId, toInstall], deviceId);
+                try {
+                    const child = spawn(getIdbCmd(), ['--version']);
+                    const idbExists = await new Promise((resolve) => {
+                        child.on('error', () => resolve(false));
+                        child.on('close', (code) => resolve(code === 0));
+                    });
+                    if (idbExists) {
+                        // attempt idb install via spawn but include diagnostics
+                        await new Promise((resolve, reject) => {
+                            const proc = spawn(getIdbCmd(), ['install', toInstall, '--udid', device.id]);
+                            let stderr = '';
+                            proc.stderr.on('data', d => stderr += d.toString());
+                            proc.on('close', code => {
+                                if (code === 0)
+                                    resolve();
+                                else
+                                    reject(new Error(stderr || `idb install failed with code ${code}`));
+                            });
+                            proc.on('error', err => reject(err));
+                        });
+                        return { device, installed: true };
+                    }
+                }
+                catch { }
+                return { device, installed: false, error: e instanceof Error ? e.message : String(e), diagnostics: diag };
+            }
+        }
+        catch (e) {
+            return { device, installed: false, error: e instanceof Error ? e.message : String(e) };
+        }
+    }
+    async startApp(bundleId, deviceId = "booted") {
+        validateBundleId(bundleId);
+        try {
+            const result = await execCommand(['simctl', 'launch', deviceId, bundleId], deviceId);
+            const device = await getIOSDeviceMetadata(deviceId);
+            return { device, appStarted: !!result.output, launchTimeMs: 1000 };
+        }
+        catch (e) {
+            const diag = execCommandWithDiagnostics(['simctl', 'launch', deviceId, bundleId], deviceId);
+            const device = await getIOSDeviceMetadata(deviceId);
+            return { device, appStarted: false, launchTimeMs: 0, error: e instanceof Error ? e.message : String(e), diagnostics: diag };
+        }
+    }
+    async terminateApp(bundleId, deviceId = "booted") {
+        validateBundleId(bundleId);
+        try {
+            await execCommand(['simctl', 'terminate', deviceId, bundleId], deviceId);
+            const device = await getIOSDeviceMetadata(deviceId);
+            return { device, appTerminated: true };
+        }
+        catch (e) {
+            const diag = execCommandWithDiagnostics(['simctl', 'terminate', deviceId, bundleId], deviceId);
+            const device = await getIOSDeviceMetadata(deviceId);
+            return { device, appTerminated: false, error: e instanceof Error ? e.message : String(e), diagnostics: diag };
+        }
+    }
+    async restartApp(bundleId, deviceId = "booted") {
+        await this.terminateApp(bundleId, deviceId);
+        const startResult = await this.startApp(bundleId, deviceId);
+        return { device: startResult.device, appRestarted: startResult.appStarted, launchTimeMs: startResult.launchTimeMs };
+    }
+    async resetAppData(bundleId, deviceId = "booted") {
+        validateBundleId(bundleId);
+        await this.terminateApp(bundleId, deviceId);
+        const device = await getIOSDeviceMetadata(deviceId);
+        try {
+            const containerResult = await execCommand(['simctl', 'get_app_container', deviceId, bundleId, 'data'], deviceId);
+            const dataPath = containerResult.output.trim();
+            if (!dataPath)
+                throw new Error(`Could not find data container for ${bundleId}`);
+            try {
+                const libraryPath = `${dataPath}/Library`;
+                const documentsPath = `${dataPath}/Documents`;
+                const tmpPath = `${dataPath}/tmp`;
+                await fs.rm(libraryPath, { recursive: true, force: true }).catch(() => { });
+                await fs.rm(documentsPath, { recursive: true, force: true }).catch(() => { });
+                await fs.rm(tmpPath, { recursive: true, force: true }).catch(() => { });
+                await fs.mkdir(libraryPath, { recursive: true }).catch(() => { });
+                await fs.mkdir(documentsPath, { recursive: true }).catch(() => { });
+                await fs.mkdir(tmpPath, { recursive: true }).catch(() => { });
+                return { device, dataCleared: true };
+            }
+            catch (e) {
+                throw new Error(`Failed to clear data for ${bundleId}: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        catch (e) {
+            const diag = execCommandWithDiagnostics(['simctl', 'get_app_container', deviceId, bundleId, 'data'], deviceId);
+            return { device, dataCleared: false, error: e instanceof Error ? e.message : String(e), diagnostics: diag };
+        }
+    }
+}

package/dist/ios/observe.js

@@ -1,11 +1,25 @@
 import { spawn } from "child_process";
 import { promises as fs } from "fs";
-import { execCommand, getIOSDeviceMetadata, validateBundleId, IDB } from "./utils.js";
+import { execCommand, getIOSDeviceMetadata, validateBundleId, getIdbCmd, getXcrunCmd, isIDBInstalled } from "./utils.js";
+import { createWriteStream, promises as fsPromises } from 'fs';
+import path from 'path';
+import { parseLogLine } from '../android/utils.js';
 // --- Helper Functions Specific to Observe ---
 const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 function parseIDBFrame(frame) {
     if (!frame)
         return [0, 0, 0, 0];
+    // Handle string frames like "{{0, 0}, {402, 874}}"
+    if (typeof frame === 'string') {
+        const nums = frame.match(/-?\d+(?:\.\d+)?/g);
+        if (!nums || nums.length < 4)
+            return [0, 0, 0, 0];
+        const x = Number(nums[0]);
+        const y = Number(nums[1]);
+        const w = Number(nums[2]);
+        const h = Number(nums[3]);
+        return [Math.round(x), Math.round(y), Math.round(x + w), Math.round(y + h)];
+    }
     const x = Number(frame.x || 0);
     const y = Number(frame.y || 0);
     const w = Number(frame.width || frame.w || 0);
@@ -69,14 +83,14 @@ function traverseIDBNode(node, elements, parentIndex = -1, depth = 0) {
     }
     return currentIndex;
 }
-// Check if IDB is installed
-async function isIDBInstalled() {
-    return new Promise((resolve) => {
-        // Check if 'idb' is in path by trying to run it
-        const child = spawn(IDB, ['--version']);
-        child.on('error', () => resolve(false));
-        child.on('close', (code) => resolve(code === 0));
-    });
+// iOS live log stream support (moved from ios/utils to observe)
+const iosActiveLogStreams = new Map();
+// Test helpers
+export function _setIOSActiveLogStream(sessionId, file) {
+    iosActiveLogStreams.set(sessionId, { proc: {}, file });
+}
+export function _clearIOSActiveLogStream(sessionId) {
+    iosActiveLogStreams.delete(sessionId);
 }
 export class iOSObserve {
     async getDeviceMetadata(deviceId = "booted") {
@@ -149,12 +163,12 @@ export class iOSObserve {
             try {
                 // Stabilization delay
                 await delay(300 + (attempts * 100));
-                const args = ['ui', 'describe', '--json'];
+                const args = ['ui', 'describe-all', '--json'];
                 if (targetUdid) {
                     args.push('--udid', targetUdid);
                 }
                 const output = await new Promise((resolve, reject) => {
-                    const child = spawn(IDB, args);
+                    const child = spawn(getIdbCmd(), args);
                     let stdout = '';
                     let stderr = '';
                     child.stdout.on('data', (data) => stdout += data.toString());
@@ -189,8 +203,15 @@ export class iOSObserve {
         }
         try {
             const elements = [];
-            const root = jsonContent;
-            traverseIDBNode(root, elements);
+            // idb describe-all returns either a root object or an array of root nodes
+            if (Array.isArray(jsonContent)) {
+                for (const node of jsonContent) {
+                    traverseIDBNode(node, elements);
+                }
+            }
+            else {
+                traverseIDBNode(jsonContent, elements);
+            }
             // Infer resolution from root element if possible (usually the Window/Application frame)
             let width = 0;
             let height = 0;
@@ -216,4 +237,99 @@ export class iOSObserve {
             };
         }
     }
+    // --- Log stream methods ---
+    async startLogStream(bundleId, deviceId = 'booted', sessionId = 'default') {
+        try {
+            const predicate = `process == "${bundleId}" or subsystem contains "${bundleId}"`;
+            if (iosActiveLogStreams.has(sessionId)) {
+                try {
+                    iosActiveLogStreams.get(sessionId).proc.kill();
+                }
+                catch { }
+                iosActiveLogStreams.delete(sessionId);
+            }
+            const args = ['simctl', 'spawn', deviceId, 'log', 'stream', '--style', 'syslog', '--predicate', predicate];
+            const proc = spawn(getXcrunCmd(), args);
+            // Prepare output file
+            const tmpDir = process.env.TMPDIR || '/tmp';
+            const file = path.join(tmpDir, `mobile-debug-ios-log-${sessionId}.ndjson`);
+            const stream = createWriteStream(file, { flags: 'a' });
+            proc.stdout.on('data', (chunk) => {
+                const text = chunk.toString();
+                const lines = text.split(/\r?\n/).filter(Boolean);
+                for (const l of lines) {
+                    const entry = parseLogLine(l);
+                    stream.write(JSON.stringify(entry) + '\n');
+                }
+            });
+            proc.stderr.on('data', (chunk) => {
+                const text = chunk.toString();
+                const lines = text.split(/\r?\n/).filter(Boolean);
+                for (const l of lines) {
+                    const entry = { timestamp: '', level: 'E', tag: 'xcrun', message: l };
+                    stream.write(JSON.stringify(entry) + '\n');
+                }
+            });
+            proc.on('close', () => {
+                stream.end();
+                iosActiveLogStreams.delete(sessionId);
+            });
+            iosActiveLogStreams.set(sessionId, { proc, file });
+            return { success: true, stream_started: true };
+        }
+        catch {
+            return { success: false, error: 'log_stream_start_failed' };
+        }
+    }
+    async stopLogStream(sessionId = 'default') {
+        const entry = iosActiveLogStreams.get(sessionId);
+        if (!entry)
+            return { success: true };
+        try {
+            entry.proc.kill();
+        }
+        catch { }
+        iosActiveLogStreams.delete(sessionId);
+        return { success: true };
+    }
+    async readLogStream(sessionId = 'default', limit = 100, since) {
+        const entry = iosActiveLogStreams.get(sessionId);
+        if (!entry)
+            return { entries: [] };
+        try {
+            const data = await fsPromises.readFile(entry.file, 'utf8').catch(() => '');
+            if (!data)
+                return { entries: [], crash_summary: { crash_detected: false } };
+            const lines = data.split(/\r?\n/).filter(Boolean);
+            const parsed = lines.map(l => {
+                try {
+                    return JSON.parse(l);
+                }
+                catch {
+                    return { message: l, _iso: null, crash: false };
+                }
+            });
+            let filtered = parsed;
+            if (since) {
+                let sinceMs = null;
+                if (/^\d+$/.test(since))
+                    sinceMs = Number(since);
+                else {
+                    const sDate = new Date(since);
+                    if (!isNaN(sDate.getTime()))
+                        sinceMs = sDate.getTime();
+                }
+                if (sinceMs !== null) {
+                    filtered = parsed.filter(p => p._iso && (new Date(p._iso).getTime() >= sinceMs));
+                }
+            }
+            const entries = filtered.slice(-Math.max(0, limit));
+            const crashEntry = entries.find(e => e.crash);
+            const crash_summary = crashEntry ? { crash_detected: true, exception: crashEntry.exception, sample: crashEntry.message } : { crash_detected: false };
+            return { entries, crash_summary };
+        }
+        catch {
+            return { entries: [], crash_summary: { crash_detected: false } };
+        }
+    }
 }