mobile-debug-mcp 0.6.0 → 0.8.0

package/dist/ios/interact.js

@@ -1,6 +1,114 @@
 import { promises as fs } from "fs";
-import { execCommand, getIOSDeviceMetadata, validateBundleId } from "./utils.js";
+import { spawn } from "child_process";
+import { execCommand, getIOSDeviceMetadata, validateBundleId, IDB } from "./utils.js";
+import { iOSObserve } from "./observe.js";
 export class iOSInteract {
+    observe = new iOSObserve();
+    async waitForElement(text, timeout, deviceId = "booted") {
+        const device = await getIOSDeviceMetadata(deviceId);
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            try {
+                const tree = await this.observe.getUITree(deviceId);
+                if (tree.error) {
+                    return { device, found: false, error: tree.error };
+                }
+                const element = tree.elements.find(e => e.text === text);
+                if (element) {
+                    return { device, found: true, element };
+                }
+            }
+            catch (e) {
+                // Ignore errors during polling and retry
+                console.error("Error polling UI tree:", e);
+            }
+            const elapsed = Date.now() - startTime;
+            const remaining = timeout - elapsed;
+            if (remaining <= 0)
+                break;
+            await new Promise(resolve => setTimeout(resolve, Math.min(500, remaining)));
+        }
+        return { device, found: false };
+    }
+    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));
+        });
+        if (!idbExists) {
+            return {
+                device,
+                success: false,
+                x,
+                y,
+                error: "iOS tap requires 'idb' (iOS Device Bridge)."
+            };
+        }
+        try {
+            const targetUdid = (device.id && device.id !== 'booted') ? device.id : undefined;
+            const args = ['ui', 'tap', x.toString(), y.toString()];
+            if (targetUdid) {
+                args.push('--udid', targetUdid);
+            }
+            await new Promise((resolve, reject) => {
+                const proc = spawn(IDB, args);
+                let stderr = '';
+                proc.stderr.on('data', d => stderr += d.toString());
+                proc.on('close', code => {
+                    if (code === 0)
+                        resolve();
+                    else
+                        reject(new Error(`idb ui tap failed: ${stderr}`));
+                });
+                proc.on('error', err => reject(err));
+            });
+            return { device, success: true, x, y };
+        }
+        catch (e) {
+            return { device, success: false, x, y, error: e instanceof Error ? e.message : String(e) };
+        }
+    }
+    async installApp(appPath, deviceId = "booted") {
+        // Try simulator install first
+        const device = await getIOSDeviceMetadata(deviceId);
+        try {
+            const res = await execCommand(['simctl', 'install', deviceId, appPath], 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', appPath, '--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 (inner) {
+                // fallthrough
+            }
+            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);

package/dist/ios/utils.js

@@ -112,3 +112,157 @@ export async function getIOSDeviceMetadata(deviceId = "booted") {
         });
     });
 }
+export async function listIOSDevices(appId) {
+    return new Promise((resolve) => {
+        execFile(XCRUN, ['simctl', 'list', 'devices', '--json'], (err, stdout) => {
+            if (err || !stdout)
+                return resolve([]);
+            try {
+                const data = JSON.parse(stdout);
+                const devicesMap = data.devices || {};
+                const out = [];
+                const checks = [];
+                for (const runtime in devicesMap) {
+                    const devices = devicesMap[runtime];
+                    if (Array.isArray(devices)) {
+                        for (const device of devices) {
+                            const info = {
+                                platform: 'ios',
+                                id: device.udid,
+                                osVersion: parseRuntimeName(runtime),
+                                model: device.name,
+                                simulator: true
+                            };
+                            if (appId) {
+                                // check if installed
+                                const p = execCommand(['simctl', 'get_app_container', device.udid, appId, 'data'], device.udid)
+                                    .then(() => { info.appInstalled = true; })
+                                    .catch(() => { info.appInstalled = false; })
+                                    .then(() => { out.push(info); });
+                                checks.push(p);
+                            }
+                            else {
+                                out.push(info);
+                            }
+                        }
+                    }
+                }
+                Promise.all(checks).then(() => resolve(out)).catch(() => resolve(out));
+            }
+            catch (e) {
+                resolve([]);
+            }
+        });
+    });
+}
+// --- iOS live log stream support ---
+import { createWriteStream, promises as fsPromises } from 'fs';
+import path from 'path';
+import { parseLogLine } from '../android/utils.js';
+const iosActiveLogStreams = new Map();
+// Test helpers
+export function _setIOSActiveLogStream(sessionId, file) {
+    iosActiveLogStreams.set(sessionId, { proc: {}, file });
+}
+export function _clearIOSActiveLogStream(sessionId) {
+    iosActiveLogStreams.delete(sessionId);
+}
+export async function startIOSLogStream(bundleId, level = 'error', deviceId = 'booted', sessionId = 'default') {
+    try {
+        // Build predicate to filter by process or subsystem
+        const predicate = `process == "${bundleId}" or subsystem contains "${bundleId}"`;
+        // Prevent multiple streams per session
+        if (iosActiveLogStreams.has(sessionId)) {
+            try {
+                iosActiveLogStreams.get(sessionId).proc.kill();
+            }
+            catch (e) { }
+            iosActiveLogStreams.delete(sessionId);
+        }
+        // Start simctl log stream: xcrun simctl spawn <device> log stream --style syslog --predicate '<predicate>'
+        const args = ['simctl', 'spawn', deviceId, 'log', 'stream', '--style', 'syslog', '--predicate', predicate];
+        const proc = spawn(XCRUN, 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) {
+                // Try to parse with shared parser; parser may be optimized for Android but extracts exceptions and message
+                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', (code) => {
+            stream.end();
+            iosActiveLogStreams.delete(sessionId);
+        });
+        iosActiveLogStreams.set(sessionId, { proc, file });
+        return { success: true, stream_started: true };
+    }
+    catch (err) {
+        return { success: false, error: 'log_stream_start_failed' };
+    }
+}
+export async function stopIOSLogStream(sessionId = 'default') {
+    const entry = iosActiveLogStreams.get(sessionId);
+    if (!entry)
+        return { success: true };
+    try {
+        entry.proc.kill();
+    }
+    catch (e) { }
+    iosActiveLogStreams.delete(sessionId);
+    return { success: true };
+}
+export async function readIOSLogStreamLines(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 };
+            }
+        });
+        // Minimal since filtering if provided
+        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 (e) {
+        return { entries: [], crash_summary: { crash_detected: false } };
+    }
+}

package/dist/resolve-device.js

@@ -0,0 +1,70 @@
+import { listAndroidDevices } from "./android/utils.js";
+import { listIOSDevices } from "./ios/utils.js";
+function parseNumericVersion(v) {
+    if (!v)
+        return 0;
+    // extract first number groups like 17.0 -> 17.0 or Android 12 -> 12
+    const m = v.match(/(\d+)(?:[\.\-](\d+))?/);
+    if (!m)
+        return 0;
+    const major = parseInt(m[1], 10) || 0;
+    const minor = parseInt(m[2] || "0", 10) || 0;
+    return major + minor / 100;
+}
+export async function listDevices(platform, appId) {
+    if (!platform || platform === "android") {
+        const android = await listAndroidDevices(appId);
+        if (platform === "android")
+            return android;
+        // if no platform specified, merge with ios below
+        const ios = await listIOSDevices(appId);
+        return [...android, ...ios];
+    }
+    return listIOSDevices(appId);
+}
+export async function resolveTargetDevice(opts) {
+    const { platform, appId, prefer, deviceId } = opts;
+    const devices = await listDevices(platform, appId);
+    if (deviceId) {
+        const found = devices.find(d => d.id === deviceId);
+        if (!found)
+            throw new Error(`Device '${deviceId}' not found for platform ${platform}`);
+        return found;
+    }
+    let candidates = devices.slice();
+    // Apply prefer filter
+    if (prefer === "physical")
+        candidates = candidates.filter(d => !d.simulator);
+    if (prefer === "emulator")
+        candidates = candidates.filter(d => d.simulator);
+    // If appId provided, prefer devices with appInstalled
+    if (appId) {
+        const installed = candidates.filter(d => d.appInstalled);
+        if (installed.length > 0)
+            candidates = installed;
+    }
+    if (candidates.length === 1)
+        return candidates[0];
+    if (candidates.length > 1) {
+        // Prefer physical over emulator unless prefer=emulator
+        if (!prefer) {
+            const physical = candidates.filter(d => !d.simulator);
+            if (physical.length === 1)
+                return physical[0];
+            if (physical.length > 1)
+                candidates = physical;
+        }
+        // Pick highest OS version
+        candidates.sort((a, b) => parseNumericVersion(b.osVersion) - parseNumericVersion(a.osVersion));
+        // If top is unique (numeric differs), return it
+        if (candidates.length > 1 && parseNumericVersion(candidates[0].osVersion) > parseNumericVersion(candidates[1].osVersion)) {
+            return candidates[0];
+        }
+        // Ambiguous: throw an error with candidate list so caller (agent) can present choices
+        const list = candidates.map(d => ({ id: d.id, platform: d.platform, osVersion: d.osVersion, model: d.model, simulator: d.simulator, appInstalled: d.appInstalled }));
+        const err = new Error(`Multiple matching devices found: ${JSON.stringify(list, null, 2)}`);
+        err.devices = list;
+        throw err;
+    }
+    throw new Error(`No devices found for platform ${platform}`);
+}