mobile-debug-mcp 0.13.0 → 0.15.0

package/dist/observe/android.js

@@ -0,0 +1,351 @@
+import { spawn } from "child_process";
+import { XMLParser } from "fast-xml-parser";
+import { getAdbCmd, execAdb, getAndroidDeviceMetadata, getDeviceInfo, delay, getScreenResolution, traverseNode, parseLogLine } from "../utils/android/utils.js";
+import { createWriteStream } from "fs";
+import { promises as fsPromises } from "fs";
+import path from "path";
+import { computeScreenFingerprint } from "../interact/shared/fingerprint.js";
+const activeLogStreams = new Map();
+export class AndroidObserve {
+    async getDeviceMetadata(appId, deviceId) {
+        return getAndroidDeviceMetadata(appId, deviceId);
+    }
+    async getUITree(deviceId) {
+        const metadata = await getAndroidDeviceMetadata("", deviceId);
+        const deviceInfo = getDeviceInfo(deviceId || 'default', metadata);
+        try {
+            // Get screen resolution first
+            const resolution = await getScreenResolution(deviceId);
+            if (resolution.width === 0 && resolution.height === 0) {
+                throw new Error("Failed to get screen resolution. Is the device connected and authorized?");
+            }
+            // Retry Logic
+            let xmlContent = '';
+            let attempts = 0;
+            const maxAttempts = 3;
+            while (attempts < maxAttempts) {
+                attempts++;
+                try {
+                    // Stabilization delay
+                    await delay(300 + (attempts * 100)); // 300ms, 400ms, 500ms...
+                    // Dump UI hierarchy
+                    await execAdb(['shell', 'uiautomator', 'dump', '/sdcard/ui.xml'], deviceId);
+                    // Read the file
+                    xmlContent = await execAdb(['shell', 'cat', '/sdcard/ui.xml'], deviceId);
+                    // Check validity
+                    if (xmlContent && xmlContent.trim().length > 0 && !xmlContent.includes("ERROR:")) {
+                        break; // Success
+                    }
+                }
+                catch (e) {
+                    console.error(`Attempt ${attempts} failed: ${e}`);
+                }
+                if (attempts === maxAttempts) {
+                    throw new Error(`Failed to retrieve valid UI dump after ${maxAttempts} attempts.`);
+                }
+            }
+            const parser = new XMLParser({
+                ignoreAttributes: false,
+                attributeNamePrefix: "@_"
+            });
+            const result = parser.parse(xmlContent);
+            const elements = [];
+            // The root is usually hierarchy -> node
+            if (result.hierarchy && result.hierarchy.node) {
+                // If the root is an array (unlikely for root, but good to be safe) or single object
+                if (Array.isArray(result.hierarchy.node)) {
+                    result.hierarchy.node.forEach((n) => traverseNode(n, elements));
+                }
+                else {
+                    traverseNode(result.hierarchy.node, elements);
+                }
+            }
+            return {
+                device: deviceInfo,
+                screen: "",
+                resolution,
+                elements
+            };
+        }
+        catch (e) {
+            const errorMessage = `Failed to get UI tree. ADB Path: '${getAdbCmd()}'. Error: ${e instanceof Error ? e.message : String(e)}`;
+            console.error(errorMessage);
+            return {
+                device: deviceInfo,
+                screen: "",
+                resolution: { width: 0, height: 0 },
+                elements: [],
+                error: errorMessage
+            };
+        }
+    }
+    async getLogs(appId, lines = 200, deviceId) {
+        const metadata = await getAndroidDeviceMetadata(appId || "", deviceId);
+        const deviceInfo = getDeviceInfo(deviceId || 'default', metadata);
+        try {
+            const stdout = await execAdb(['logcat', '-d', '-t', lines.toString(), '-v', 'threadtime'], deviceId);
+            const allLogs = stdout.split('\n');
+            let filteredLogs = allLogs;
+            if (appId) {
+                const matchingLogs = allLogs.filter(line => line.includes(appId));
+                if (matchingLogs.length > 0) {
+                    filteredLogs = matchingLogs;
+                }
+                else {
+                    filteredLogs = allLogs;
+                }
+            }
+            return { device: deviceInfo, logs: filteredLogs, logCount: filteredLogs.length };
+        }
+        catch (e) {
+            console.error("Error fetching logs:", e);
+            return { device: deviceInfo, logs: [], logCount: 0 };
+        }
+    }
+    async captureScreen(deviceId) {
+        const metadata = await getAndroidDeviceMetadata("", deviceId);
+        const deviceInfo = getDeviceInfo(deviceId || 'default', metadata);
+        return new Promise((resolve, reject) => {
+            const args = deviceId ? ['-s', deviceId, 'exec-out', 'screencap', '-p'] : ['exec-out', 'screencap', '-p'];
+            const child = spawn(getAdbCmd(), args);
+            const chunks = [];
+            let stderr = '';
+            child.stdout.on('data', (chunk) => {
+                chunks.push(Buffer.from(chunk));
+            });
+            child.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            const timeout = setTimeout(() => {
+                child.kill();
+                reject(new Error(`ADB screencap timed out after 10s`));
+            }, 10000);
+            child.on('close', (code) => {
+                clearTimeout(timeout);
+                if (code !== 0) {
+                    reject(new Error(stderr.trim() || `Screencap failed with code ${code}`));
+                    return;
+                }
+                const screenshotBuffer = Buffer.concat(chunks);
+                const screenshotBase64 = screenshotBuffer.toString('base64');
+                execAdb(['shell', 'wm', 'size'], deviceId)
+                    .then(sizeStdout => {
+                    let width = 0;
+                    let height = 0;
+                    const match = sizeStdout.match(/Physical size: (\d+)x(\d+)/);
+                    if (match) {
+                        width = parseInt(match[1], 10);
+                        height = parseInt(match[2], 10);
+                    }
+                    resolve({
+                        device: deviceInfo,
+                        screenshot: screenshotBase64,
+                        resolution: { width, height }
+                    });
+                })
+                    .catch(() => {
+                    resolve({
+                        device: deviceInfo,
+                        screenshot: screenshotBase64,
+                        resolution: { width: 0, height: 0 }
+                    });
+                });
+            });
+            child.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+        });
+    }
+    async getCurrentScreen(deviceId) {
+        const metadata = await getAndroidDeviceMetadata("", deviceId);
+        const deviceInfo = getDeviceInfo(deviceId || 'default', metadata);
+        try {
+            const output = await execAdb(['shell', 'dumpsys', 'activity', 'activities'], deviceId, { timeout: 10000 });
+            const lines = output.split('\n');
+            let resumedLine = lines.find(line => /^\s*mResumedActivity:/.test(line));
+            if (!resumedLine) {
+                resumedLine = lines.find(line => /^\s*ResumedActivity:/.test(line));
+            }
+            if (!resumedLine) {
+                return {
+                    device: deviceInfo,
+                    package: "",
+                    activity: "",
+                    shortActivity: "",
+                    error: "Could not find 'mResumedActivity' in dumpsys output"
+                };
+            }
+            const match = resumedLine.match(/ActivityRecord\{[^ ]*(?:\s+[^ ]+)*\s+([^\/ ]+)\/([^ \{}]+)[^}]*\}/);
+            if (match) {
+                const packageName = match[1];
+                let activityName = match[2];
+                if (activityName.startsWith('.')) {
+                    activityName = packageName + activityName;
+                }
+                const shortActivity = activityName.split('.').pop() || activityName;
+                return {
+                    device: deviceInfo,
+                    package: packageName,
+                    activity: activityName,
+                    shortActivity: shortActivity
+                };
+            }
+            else {
+                return {
+                    device: deviceInfo,
+                    package: "",
+                    activity: "",
+                    shortActivity: "",
+                    error: `Found resumed activity line but failed to parse: '${resumedLine.trim()}'`
+                };
+            }
+        }
+        catch (e) {
+            return {
+                device: deviceInfo,
+                package: "",
+                activity: "",
+                shortActivity: "",
+                error: e instanceof Error ? e.message : String(e)
+            };
+        }
+    }
+    async getScreenFingerprint(deviceId) {
+        try {
+            const tree = await this.getUITree(deviceId);
+            if (!tree || tree.error)
+                return { fingerprint: null, error: tree.error };
+            const current = await this.getCurrentScreen(deviceId).catch(() => null);
+            return computeScreenFingerprint(tree, current, 'android', 50);
+        }
+        catch (e) {
+            return { fingerprint: null, error: e instanceof Error ? e.message : String(e) };
+        }
+    }
+    async startLogStream(packageName, level = 'error', deviceId, sessionId = 'default') {
+        try {
+            const pidOutput = await execAdb(['shell', 'pidof', packageName], deviceId).catch(() => '');
+            const pid = (pidOutput || '').trim();
+            if (!pid)
+                return { success: false, error: 'app_not_running' };
+            const levelMap = { error: '*:E', warn: '*:W', info: '*:I', debug: '*:D' };
+            const filter = levelMap[level] || levelMap['error'];
+            if (activeLogStreams.has(sessionId)) {
+                try {
+                    activeLogStreams.get(sessionId).proc.kill();
+                }
+                catch { }
+                activeLogStreams.delete(sessionId);
+            }
+            const args = ['logcat', `--pid=${pid}`, filter];
+            const proc = spawn(getAdbCmd(), args);
+            const tmpDir = process.env.TMPDIR || '/tmp';
+            const file = path.join(tmpDir, `mobile-debug-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: 'adb', message: l };
+                    stream.write(JSON.stringify(entry) + '\n');
+                }
+            });
+            proc.on('close', () => {
+                stream.end();
+                activeLogStreams.delete(sessionId);
+            });
+            activeLogStreams.set(sessionId, { proc, file });
+            return { success: true, stream_started: true };
+        }
+        catch (e) {
+            return { success: false, error: e instanceof Error ? e.message : String(e) };
+        }
+    }
+    async stopLogStream(sessionId = 'default') {
+        const entry = activeLogStreams.get(sessionId);
+        if (!entry)
+            return { success: true };
+        try {
+            entry.proc.kill();
+        }
+        catch { }
+        activeLogStreams.delete(sessionId);
+        return { success: true };
+    }
+    async readLogStream(sessionId = 'default', limit = 100, since) {
+        const entry = activeLogStreams.get(sessionId);
+        let file;
+        if (entry && entry.file)
+            file = entry.file;
+        else {
+            const tmpDir = process.env.TMPDIR || '/tmp';
+            const candidate = path.join(tmpDir, `mobile-debug-log-${sessionId}.ndjson`);
+            file = candidate;
+        }
+        try {
+            const data = await fsPromises.readFile(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 {
+                    const obj = JSON.parse(l);
+                    if (typeof obj._iso === 'undefined') {
+                        let iso = null;
+                        if (obj.timestamp) {
+                            const d = new Date(obj.timestamp);
+                            if (!isNaN(d.getTime()))
+                                iso = d.toISOString();
+                        }
+                        obj._iso = iso;
+                    }
+                    if (typeof obj.crash === 'undefined') {
+                        const msg = (obj.message || '').toString();
+                        const exMatch = msg.match(/\b([A-Za-z0-9_$.]+Exception)\b/);
+                        if (/FATAL EXCEPTION/i.test(msg) || exMatch) {
+                            obj.crash = true;
+                            if (exMatch)
+                                obj.exception = exMatch[1];
+                        }
+                        else {
+                            obj.crash = false;
+                        }
+                    }
+                    return obj;
+                }
+                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 } };
+        }
+    }
+}

package/dist/observe/fingerprint.js

@@ -0,0 +1 @@
+export * from '../intera../interact/shared/fingerprint.js';

package/dist/observe/index.js

@@ -0,0 +1,85 @@
+import { resolveTargetDevice } from '../utils/resolve-device.js';
+import { AndroidObserve } from './android.js';
+import { iOSObserve } from './ios.js';
+export { AndroidObserve } from './android.js';
+export { iOSObserve } from './ios.js';
+export class ToolsObserve {
+    // Resolve a target device and return the appropriate observe instance and resolved info.
+    static async resolveObserve(platform, deviceId, appId) {
+        if (platform === 'android') {
+            const resolved = await resolveTargetDevice({ platform: 'android', deviceId, appId });
+            return { observe: new AndroidObserve(), resolved };
+        }
+        if (platform === 'ios') {
+            const resolved = await resolveTargetDevice({ platform: 'ios', deviceId, appId });
+            return { observe: new iOSObserve(), resolved };
+        }
+        // No platform specified: try android then ios
+        try {
+            const resolved = await resolveTargetDevice({ platform: 'android', deviceId, appId });
+            return { observe: new AndroidObserve(), resolved };
+        }
+        catch {
+            const resolved = await resolveTargetDevice({ platform: 'ios', deviceId, appId });
+            return { observe: new iOSObserve(), resolved };
+        }
+    }
+    static async getUITreeHandler({ platform, deviceId }) {
+        const { observe, resolved } = await ToolsObserve.resolveObserve(platform, deviceId);
+        return await observe.getUITree(resolved.id);
+    }
+    static async getCurrentScreenHandler({ deviceId }) {
+        const { observe, resolved } = await ToolsObserve.resolveObserve('android', deviceId);
+        // getCurrentScreen is Android-specific
+        return await observe.getCurrentScreen(resolved.id);
+    }
+    static async getLogsHandler({ platform, appId, deviceId, lines }) {
+        const { observe, resolved } = await ToolsObserve.resolveObserve(platform, deviceId, appId);
+        if (observe instanceof AndroidObserve) {
+            const response = await observe.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 resp = await observe.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 sid = sessionId || 'default';
+        const { observe, resolved } = await ToolsObserve.resolveObserve(platform, deviceId, packageName);
+        if (observe instanceof AndroidObserve) {
+            return await observe.startLogStream(packageName, level || 'error', resolved.id, sid);
+        }
+        else {
+            return await observe.startLogStream(packageName, resolved.id, sid);
+        }
+    }
+    static async readLogStreamHandler({ platform, sessionId, limit, since }) {
+        const sid = sessionId || 'default';
+        const { observe } = await ToolsObserve.resolveObserve(platform);
+        return await observe.readLogStream(sid, limit ?? 100, since);
+    }
+    static async stopLogStreamHandler({ platform, sessionId }) {
+        const sid = sessionId || 'default';
+        const { observe } = await ToolsObserve.resolveObserve(platform);
+        return await observe.stopLogStream(sid);
+    }
+    static async captureScreenshotHandler({ platform, deviceId }) {
+        const { observe, resolved } = await ToolsObserve.resolveObserve(platform, deviceId);
+        if (observe instanceof AndroidObserve) {
+            return await observe.captureScreen(resolved.id);
+        }
+        else {
+            return await observe.captureScreenshot(resolved.id);
+        }
+    }
+    static async getScreenFingerprintHandler({ platform, deviceId } = {}) {
+        const { observe, resolved } = await ToolsObserve.resolveObserve(platform, deviceId);
+        // Both observes implement getScreenFingerprint
+        return await observe.getScreenFingerprint(resolved.id);
+    }
+}