mobile-debug-mcp 0.34.0 → 0.35.0

package/dist/observe/android/screenshot.js

@@ -0,0 +1,70 @@
+import { encodeScreenshot } from '../screenshot-encoding.js';
+import { spawn } from "child_process";
+import { getAdbCmd, execAdb, getAndroidDeviceMetadata, getDeviceInfo } from "../../utils/android/utils.js";
+import { parsePngSize } from "../../utils/image.js";
+export async function collectCaptureScreen(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', async (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');
+            const parsed = parsePngSize(screenshotBuffer);
+            if (parsed.width > 0 && parsed.height > 0) {
+                const encoded = await encodeScreenshot(screenshotBuffer, 'android');
+                resolve({ device: deviceInfo, ...encoded, resolution: { width: parsed.width, height: parsed.height } });
+                return;
+            }
+            else {
+                // Fallback to querying wm size if parsing failed
+                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,
+                        screenshot_mime: 'image/png',
+                        resolution: { width, height }
+                    });
+                })
+                    .catch(() => {
+                    resolve({
+                        device: deviceInfo,
+                        screenshot: screenshotBase64,
+                        screenshot_mime: 'image/png',
+                        resolution: { width: 0, height: 0 }
+                    });
+                });
+            }
+        });
+        child.on('error', (err) => {
+            clearTimeout(timeout);
+            reject(err);
+        });
+    });
+}

package/dist/observe/android/ui-tree.js

@@ -0,0 +1,107 @@
+import { XMLParser } from "fast-xml-parser";
+import { getAdbCmd, execAdb, getAndroidDeviceMetadata, getDeviceInfo, delay, getScreenResolution, traverseNode } from "../../utils/android/utils.js";
+import { deriveSnapshotMetadata } from "../snapshot-metadata.js";
+import { remainingBudget } from '../../utils/operation-budget.js';
+import { createObservationMeasurement } from '../performance-metrics.js';
+export async function collectGetUITree(deviceId) {
+    const measurement = createObservationMeasurement('android');
+    let metadata;
+    try {
+        metadata = await measurement.timed('metadata_ms', () => getAndroidDeviceMetadata("", deviceId));
+    }
+    catch (error) {
+        measurement.setOutcome('unavailable');
+        measurement.finish();
+        throw error;
+    }
+    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata);
+    try {
+        // Get screen resolution first
+        const resolution = await measurement.timed('resolution_ms', () => getScreenResolution(deviceId));
+        if (resolution.width === 0 && resolution.height === 0) {
+            throw new Error("Failed to get screen resolution. Is the device connected and authorized?");
+        }
+        const xmlContent = await readAndroidTree(deviceId, measurement);
+        const parser = new XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: "@_"
+        });
+        const result = await measurement.timed('parse_ms', async () => 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);
+            }
+        }
+        const snapshotMetadata = deriveSnapshotMetadata(`android:${deviceInfo.id}`, {
+            screen: "",
+            resolution,
+            elements
+        }, 'ui_tree');
+        measurement.setOutcome('observed');
+        const response = measurement.bindObservation({
+            device: deviceInfo,
+            screen: "",
+            resolution,
+            elements,
+            ...snapshotMetadata
+        });
+        measurement.finish();
+        return response;
+    }
+    catch (e) {
+        const errorMessage = `Failed to get UI tree. ADB Path: '${getAdbCmd()}'. Error: ${e instanceof Error ? e.message : String(e)}`;
+        console.error(errorMessage);
+        const snapshotMetadata = deriveSnapshotMetadata(`android:${deviceInfo.id}`, null, 'ui_tree');
+        measurement.setOutcome('unavailable');
+        measurement.finish();
+        return {
+            device: deviceInfo,
+            screen: "",
+            resolution: { width: 0, height: 0 },
+            elements: [],
+            ...snapshotMetadata,
+            error: errorMessage
+        };
+    }
+}
+async function readAndroidTree(deviceId, measurement) {
+    // Retry Logic
+    let xmlContent = '';
+    let attempts = 0;
+    const maxAttempts = 3;
+    while (attempts < maxAttempts) {
+        remainingBudget();
+        attempts++;
+        try {
+            // The first read starts immediately so it remains fresh for in-place UI changes.
+            // Delay only a retry after a failed or invalid acquisition.
+            if (attempts > 1) {
+                await measurement.timed('observation_wait_ms', () => delay(Math.min(remainingBudget(300 + (attempts * 100)), 300 + (attempts * 100))));
+            }
+            remainingBudget();
+            xmlContent = await measurement.physicalRead(async () => {
+                await execAdb(['shell', 'uiautomator', 'dump', '/sdcard/ui.xml'], deviceId);
+                const content = await execAdb(['shell', 'cat', '/sdcard/ui.xml'], deviceId);
+                if (!content || !content.trim() || content.includes('ERROR:'))
+                    throw new Error('Empty or invalid UI dump');
+                return content;
+            });
+            break;
+        }
+        catch (e) {
+            if (e instanceof Error && e.message === 'ACTION_TIMEOUT')
+                throw e;
+            console.error(`Attempt ${attempts} failed: ${e}`);
+        }
+        if (attempts === maxAttempts) {
+            throw new Error(`Failed to retrieve valid UI dump after ${maxAttempts} attempts.`);
+        }
+    }
+    return xmlContent;
+}