mobile-debug-mcp 0.13.0 → 0.15.0

package/dist/observe/ios.js

@@ -0,0 +1,320 @@
+import { spawn } from "child_process";
+import { promises as fs } from "fs";
+import { execCommand, getIOSDeviceMetadata, validateBundleId, getIdbCmd, getXcrunCmd, isIDBInstalled } from "../utils/ios/utils.js";
+import { createWriteStream, promises as fsPromises } from 'fs';
+import path from 'path';
+import { parseLogLine } from '../utils/android/utils.js';
+import { computeScreenFingerprint } from '../interact/shared/fingerprint.js';
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+function parseIDBFrame(frame) {
+    if (!frame)
+        return [0, 0, 0, 0];
+    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);
+    const h = Number(frame.height || frame.h || 0);
+    return [Math.round(x), Math.round(y), Math.round(x + w), Math.round(y + h)];
+}
+function getCenter(bounds) {
+    const [x1, y1, x2, y2] = bounds;
+    return [Math.floor((x1 + x2) / 2), Math.floor((y1 + y2) / 2)];
+}
+function traverseIDBNode(node, elements, parentIndex = -1, depth = 0) {
+    if (!node)
+        return -1;
+    let currentIndex = -1;
+    const type = node.AXElementType || node.type || "unknown";
+    const label = node.AXLabel || node.label || null;
+    const value = node.AXValue || null;
+    const frame = node.AXFrame || node.frame;
+    const traits = node.AXTraits || [];
+    const clickable = traits.includes("UIAccessibilityTraitButton") || type === "Button" || type === "Cell";
+    const isUseful = clickable || (label && label.length > 0) || (value && value.length > 0) || type === "Application" || type === "Window";
+    if (isUseful) {
+        const bounds = parseIDBFrame(frame);
+        const element = {
+            text: label,
+            contentDescription: value,
+            type: type,
+            resourceId: node.AXUniqueId || null,
+            clickable: clickable,
+            enabled: true,
+            visible: true,
+            bounds: bounds,
+            center: getCenter(bounds),
+            depth: depth
+        };
+        if (parentIndex !== -1) {
+            element.parentId = parentIndex;
+        }
+        elements.push(element);
+        currentIndex = elements.length - 1;
+    }
+    const nextParentIndex = currentIndex !== -1 ? currentIndex : parentIndex;
+    const nextDepth = currentIndex !== -1 ? depth + 1 : depth;
+    const childrenIndices = [];
+    if (node.children && Array.isArray(node.children)) {
+        for (const child of node.children) {
+            const childIndex = traverseIDBNode(child, elements, nextParentIndex, nextDepth);
+            if (childIndex !== -1) {
+                childrenIndices.push(childIndex);
+            }
+        }
+    }
+    if (currentIndex !== -1 && childrenIndices.length > 0) {
+        elements[currentIndex].children = childrenIndices;
+    }
+    return currentIndex;
+}
+const iosActiveLogStreams = new Map();
+export function _setIOSActiveLogStream(sessionId, file) {
+    iosActiveLogStreams.set(sessionId, { proc: {}, file });
+}
+export function _clearIOSActiveLogStream(sessionId) {
+    iosActiveLogStreams.delete(sessionId);
+}
+export class iOSObserve {
+    async getDeviceMetadata(deviceId = "booted") {
+        return getIOSDeviceMetadata(deviceId);
+    }
+    async getLogs(appId, deviceId = "booted") {
+        const args = ['simctl', 'spawn', deviceId, 'log', 'show', '--style', 'syslog', '--last', '1m'];
+        if (appId) {
+            validateBundleId(appId);
+            args.push('--predicate', `subsystem contains "${appId}" or process == "${appId}"`);
+        }
+        const result = await execCommand(args, deviceId);
+        const device = await getIOSDeviceMetadata(deviceId);
+        const logs = result.output ? result.output.split('\n') : [];
+        return {
+            device,
+            logs,
+            logCount: logs.length,
+        };
+    }
+    async captureScreenshot(deviceId = "booted") {
+        const device = await getIOSDeviceMetadata(deviceId);
+        const tmpFile = `/tmp/mcp-ios-screenshot-${Date.now()}.png`;
+        try {
+            await execCommand(['simctl', 'io', deviceId, 'screenshot', tmpFile], deviceId);
+            const buffer = await fs.readFile(tmpFile);
+            const base64 = buffer.toString('base64');
+            await fs.rm(tmpFile).catch(() => { });
+            return {
+                device,
+                screenshot: base64,
+                resolution: { width: 0, height: 0 },
+            };
+        }
+        catch (e) {
+            await fs.rm(tmpFile).catch(() => { });
+            throw new Error(`Failed to capture screenshot: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    async getUITree(deviceId = "booted") {
+        const device = await getIOSDeviceMetadata(deviceId);
+        const idbExists = await isIDBInstalled();
+        if (!idbExists) {
+            return {
+                device,
+                screen: "",
+                resolution: { width: 0, height: 0 },
+                elements: [],
+                error: "iOS UI tree retrieval requires 'idb' (iOS Device Bridge). Please install it via Homebrew: `brew tap facebook/fb && brew install idb-companion` and `pip3 install fb-idb`."
+            };
+        }
+        const targetUdid = (device.id && device.id !== 'booted') ? device.id : undefined;
+        let jsonContent = null;
+        let attempts = 0;
+        const maxAttempts = 3;
+        while (attempts < maxAttempts) {
+            attempts++;
+            try {
+                await delay(300 + (attempts * 100));
+                const args = ['ui', 'describe-all', '--json'];
+                if (targetUdid) {
+                    args.push('--udid', targetUdid);
+                }
+                const output = await new Promise((resolve, reject) => {
+                    const child = spawn(getIdbCmd(), args);
+                    let stdout = '';
+                    let stderr = '';
+                    child.stdout.on('data', (data) => stdout += data.toString());
+                    child.stderr.on('data', (data) => stderr += data.toString());
+                    child.on('error', (err) => reject(new Error(`Failed to execute idb: ${err.message}`)));
+                    child.on('close', (code) => {
+                        if (code !== 0) {
+                            reject(new Error(`idb failed (code ${code}): ${stderr.trim()}`));
+                        }
+                        else {
+                            resolve(stdout);
+                        }
+                    });
+                });
+                if (output && output.trim().length > 0) {
+                    jsonContent = JSON.parse(output);
+                    break; // Success
+                }
+            }
+            catch (e) {
+                console.error(`Attempt ${attempts} failed: ${e}`);
+            }
+            if (attempts === maxAttempts) {
+                return {
+                    device,
+                    screen: "",
+                    resolution: { width: 0, height: 0 },
+                    elements: [],
+                    error: `Failed to retrieve valid UI dump after ${maxAttempts} attempts.`
+                };
+            }
+        }
+        try {
+            const elements = [];
+            if (Array.isArray(jsonContent)) {
+                for (const node of jsonContent) {
+                    traverseIDBNode(node, elements);
+                }
+            }
+            else {
+                traverseIDBNode(jsonContent, elements);
+            }
+            let width = 0;
+            let height = 0;
+            if (elements.length > 0) {
+                const rootBounds = elements[0].bounds;
+                width = rootBounds[2] - rootBounds[0];
+                height = rootBounds[3] - rootBounds[1];
+            }
+            return {
+                device,
+                screen: "",
+                resolution: { width, height },
+                elements
+            };
+        }
+        catch (e) {
+            return {
+                device,
+                screen: "",
+                resolution: { width: 0, height: 0 },
+                elements: [],
+                error: `Failed to parse idb output: ${e instanceof Error ? e.message : String(e)}`
+            };
+        }
+    }
+    async getScreenFingerprint(deviceId = 'booted') {
+        try {
+            const tree = await this.getUITree(deviceId);
+            if (!tree || tree.error)
+                return { fingerprint: null, error: tree && tree.error };
+            return computeScreenFingerprint(tree, null, 'ios', 50);
+        }
+        catch (e) {
+            return { fingerprint: null, error: e instanceof Error ? e.message : String(e) };
+        }
+    }
+    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);
+            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 } };
+        }
+    }
+}

package/dist/observe/test/device/logstream-real.js

@@ -0,0 +1,34 @@
+import { AndroidObserve } from '../../../../index.js';
+async function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+async function main() {
+    const packageName = process.argv[2] || 'com.android.systemui';
+    const sessionId = 'real-logstream';
+    console.log('Starting log stream for', packageName);
+    const obs = new AndroidObserve();
+    const start = await obs.startLogStream(packageName, 'error', undefined, sessionId);
+    console.log('start result:', start);
+    if (!start.success) {
+        console.error('Failed to start log stream:', start.error);
+        process.exit(start.error === 'app_not_running' ? 2 : 1);
+    }
+    try {
+        for (let i = 0; i < 10; i++) {
+            console.log('\nPolling logs (iteration', i + 1, ')');
+            const { entries, crash_summary } = await obs.readLogStream(sessionId, 50);
+            console.log(`Entries: ${entries.length}`);
+            if (entries.length > 0)
+                console.log('Latest:', entries[entries.length - 1]);
+            console.log('Crash summary:', crash_summary);
+            if (crash_summary && crash_summary.crash_detected) {
+                console.log('Crash detected; stopping early');
+                break;
+            }
+            await sleep(1000);
+        }
+    }
+    finally {
+        console.log('Stopping log stream');
+        await obs.stopLogStream(sessionId);
+    }
+}
+main().catch(err => { console.error(err); process.exit(1); });

package/dist/observe/test/device/run-screen-fingerprint.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+/**
+ * Device E2E: get_screen_fingerprint
+ * Usage: RUN_DEVICE_TESTS=true npx tsx run-screen-fingerprint.ts [android|ios] [deviceId]
+ */
+import { AndroidObserve, iOSObserve } from '../../../../../index.js';
+async function main() {
+    const args = process.argv.slice(2);
+    const platform = (args[0] || 'android').toLowerCase();
+    const deviceId = args[1];
+    console.log(`Running screen fingerprint test for ${platform}${deviceId ? ` on ${deviceId}` : ''}`);
+    try {
+        const obs = platform === 'ios' ? new iOSObserve() : new AndroidObserve();
+        const id = platform === 'ios' ? (deviceId || 'booted') : deviceId;
+        const res = await obs.getScreenFingerprint(id);
+        if (res.error || !res.fingerprint) {
+            console.error('❌ Failed to compute fingerprint:', res.error);
+            process.exit(1);
+        }
+        console.log('Fingerprint:', res.fingerprint);
+        console.log('Activity:', res.activity || '<n/a>');
+        process.exit(0);
+    }
+    catch (err) {
+        console.error('❌ Test failed:', err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+main();

package/dist/observe/test/device/run-scroll-test-android.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import { AndroidInteract } from '../../../dist/android/interact.js';
+// Usage: tsx test/device/observe/run-scroll-test-android.ts <deviceId> <appId> <selectorText>
+const args = process.argv.slice(2);
+const DEVICE_ID = args[0] || process.env.DEVICE_ID || 'emulator-5554';
+const SELECTOR = args[2] || process.env.SELECTOR || 'Generate Session';
+async function main() {
+    console.log('Starting app if not running...');
+    // Best-effort tap to wake device/emulator
+    try {
+        const tmp = new AndroidInteract();
+        await tmp.tap(10, 10, DEVICE_ID).catch(() => { });
+    }
+    catch { }
+    await new Promise(r => setTimeout(r, 1000));
+    console.log('Running scroll_to_element for selector:', SELECTOR);
+    // Use ToolsInteract from dist to call the handler
+    const ToolsInteract = (await import('../../../dist/tools/interact.js')).ToolsInteract;
+    const res = await ToolsInteract.scrollToElementHandler({ platform: 'android', selector: { text: SELECTOR }, direction: 'down', maxScrolls: 10, scrollAmount: 0.7, deviceId: DEVICE_ID });
+    console.log('Result:', JSON.stringify(res, null, 2));
+}
+main().catch(console.error);

package/dist/observe/test/device/test-ui-tree.js

@@ -0,0 +1,67 @@
+/**
+ * Test script for verify UI Tree functionality.
+ *
+ * Usage:
+ *   npx tsx test-ui-tree.ts [android|ios] [deviceId]
+ *
+ * Examples:
+ *   npx tsx test-ui-tree.ts android
+ *   npx tsx test-ui-tree.ts ios booted
+ */
+import { AndroidObserve, iOSObserve } from '../../../../index.js';
+async function main() {
+    const args = process.argv.slice(2);
+    const platform = (args[0] || 'android').toLowerCase();
+    const deviceId = args[1];
+    console.log(`Starting UI Tree Test for ${platform}...`);
+    if (deviceId)
+        console.log(`Targeting device: ${deviceId}`);
+    try {
+        let result;
+        if (platform === 'ios') {
+            const observer = new iOSObserve();
+            result = await observer.getUITree(deviceId || 'booted');
+        }
+        else {
+            const observer = new AndroidObserve();
+            result = await observer.getUITree(deviceId);
+        }
+        console.log("\nUI Tree Result Summary:");
+        console.log("-----------------------");
+        if (result.error) {
+            console.error("❌ Error:", result.error);
+            process.exit(1);
+        }
+        console.log(`Device: ${result.device.platform} (${result.device.model || 'Unknown Model'})`);
+        console.log(`Resolution: ${result.resolution.width}x${result.resolution.height}`);
+        console.log(`Elements Found: ${result.elements.length}`);
+        if (result.elements.length === 0) {
+            console.warn("⚠️ Warning: No elements found. Is the screen empty or locked?");
+        }
+        else {
+            // Print sample element to verify structure
+            const first = result.elements[0];
+            console.log("\nSample Element (First):");
+            console.log(JSON.stringify(first, null, 2));
+            // Check for new fields
+            if (first.center && first.depth !== undefined) {
+                console.log("\n✅ Verified 'center' and 'depth' fields exist.");
+            }
+            else {
+                console.error("\n❌ 'center' or 'depth' fields missing!");
+                process.exit(1);
+            }
+            // Check for filtering
+            const interactive = result.elements.filter(e => e.clickable).length;
+            const withText = result.elements.filter(e => e.text).length;
+            console.log(`\nStats:`);
+            console.log(`- Interactive elements: ${interactive}`);
+            console.log(`- Elements with text: ${withText}`);
+        }
+    }
+    catch {
+        console.error("\n❌ Test Failed:", error);
+        process.exit(1);
+    }
+}
+main();

package/dist/observe/test/device/wait_for_element_real.js

@@ -0,0 +1,69 @@
+import { AndroidInteract } from "../../src/android/interact.js";
+import { AndroidObserve } from "../../../../index.js";
+// Usage: npx tsx test/wait_for_element_real.ts <deviceId> <appId>
+const args = process.argv.slice(2);
+const DEVICE_ID = args[0] || process.env.DEVICE_ID;
+const APP_ID = args[1] || process.env.APP_ID;
+if (!DEVICE_ID || !APP_ID) {
+    console.error("Usage: npx tsx test/wait_for_element_real.ts <deviceId> <appId> or set DEVICE_ID and APP_ID env vars");
+    process.exit(1);
+}
+async function runRealTest() {
+    console.log(`Connecting to device ${DEVICE_ID}...`);
+    const interact = new AndroidInteract();
+    const observe = new AndroidObserve();
+    try {
+        console.log(`\nStarting app ${APP_ID}...`);
+        await interact.startApp(APP_ID, DEVICE_ID);
+        console.log("Waiting 3s for app to render...");
+        await new Promise(r => setTimeout(r, 3000));
+        console.log("\nFetching UI Tree to find a target text...");
+        const tree = await observe.getUITree(DEVICE_ID);
+        if (tree.error) {
+            console.error("Failed to get UI Tree:", tree.error);
+            return;
+        }
+        const targetElement = tree.elements.find(e => e.text && e.text.length > 0 && e.visible);
+        if (!targetElement || !targetElement.text) {
+            console.warn("No visible text elements found on screen to test with.");
+            console.log("Elements found:", tree.elements.length);
+            return;
+        }
+        const targetText = targetElement.text;
+        console.log(`Found target element: "${targetText}"`);
+        console.log(`\nTest 1: Waiting for existing element "${targetText}" (should succeed)...`);
+        const start1 = Date.now();
+        const result1 = await interact.waitForElement(targetText, 5000, DEVICE_ID);
+        const elapsed1 = Date.now() - start1;
+        console.log(`Result: ${result1.found ? "PASS" : "FAIL"}`);
+        console.log(`Found Element: ${result1.element?.text}`);
+        console.log(`Time taken: ${elapsed1}ms`);
+        const missingText = "THIS_TEXT_SHOULD_NOT_EXIST_XYZ_123";
+        console.log(`\nTest 2: Waiting for missing element "${missingText}" (should timeout)...`);
+        const start2 = Date.now();
+        const result2 = await interact.waitForElement(missingText, 2000, DEVICE_ID);
+        const elapsed2 = Date.now() - start2;
+        console.log(`Result: ${!result2.found ? "PASS" : "FAIL"}`);
+        console.log(`Found: ${result2.found}`);
+        console.log(`Time taken: ${elapsed2}ms (expected ~2000ms)`);
+        console.log(`\nTest 3: Found after polling`);
+        let calls = 0;
+        AndroidObserve.prototype.getUITree = async function () {
+            calls++;
+            if (calls < 3) {
+                return { device: { platform: "android", id: "mock", osVersion: "12", model: "Pixel", simulator: true }, screen: "", resolution: { width: 1080, height: 1920 }, elements: [] };
+            }
+            return { device: { platform: "android", id: "mock", osVersion: "12", model: "Pixel", simulator: true }, screen: "", resolution: { width: 1080, height: 1920 }, elements: [{ text: "Target", type: "Button", contentDescription: null, clickable: true, enabled: true, visible: true, bounds: [0, 0, 100, 100], resourceId: null }] };
+        };
+        const start3 = Date.now();
+        const result3 = await interact.waitForElement("Target", 2000, DEVICE_ID);
+        const elapsed3 = Date.now() - start3;
+        console.log(`Result: ${result3.found ? "PASS" : "FAIL"}`);
+        console.log(`Calls: ${calls} ${calls === 3 ? "PASS" : "FAIL"}`);
+        console.log(`Elapsed time (should be >= 1000ms): ${elapsed3} ${elapsed3 >= 1000 ? "PASS" : "FAIL"}`);
+    }
+    catch {
+        console.error("Test failed with error:", error);
+    }
+}
+runRealTest();

package/dist/observe/test/unit/get_screen_fingerprint.test.js

@@ -0,0 +1,54 @@
+import { AndroidObserve } from '../../../../../index.js';
+async function run() {
+    console.log('Starting get_screen_fingerprint unit tests...');
+    const origGet = AndroidObserve.prototype.getUITree;
+    const origCurrent = AndroidObserve.prototype.getCurrentScreen;
+    AndroidObserve.prototype.getUITree = async function () {
+        return {
+            device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
+            screen: '',
+            resolution: { width: 1080, height: 1920 },
+            elements: [
+                { text: 'Title', type: 'TextView', contentDescription: null, clickable: false, enabled: true, visible: true, bounds: [0, 0, 1080, 100], resourceId: 'id/title' },
+                { text: 'Sign in', type: 'Button', contentDescription: null, clickable: true, enabled: true, visible: true, bounds: [0, 200, 200, 260], resourceId: 'id/signin' }
+            ]
+        };
+    };
+    AndroidObserve.prototype.getCurrentScreen = async function () {
+        return { device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true }, package: 'com.example', activity: 'com.example.MainActivity', shortActivity: 'MainActivity' };
+    };
+    const ai = new AndroidObserve();
+    const a = await ai.getScreenFingerprint('mock');
+    const b = await ai.getScreenFingerprint('mock');
+    console.log('Test 1:', a.fingerprint === b.fingerprint ? 'PASS' : 'FAIL');
+    AndroidObserve.prototype.getUITree = async function () {
+        return {
+            device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
+            screen: '',
+            resolution: { width: 1080, height: 1920 },
+            elements: [
+                { text: 'Title', type: 'TextView', contentDescription: null, clickable: false, enabled: true, visible: true, bounds: [0, 0, 1080, 100], resourceId: 'id/title' },
+                { text: 'Profile', type: 'Button', contentDescription: null, clickable: true, enabled: true, visible: true, bounds: [0, 200, 200, 260], resourceId: 'id/signin' }
+            ]
+        };
+    };
+    const c = await ai.getScreenFingerprint('mock');
+    console.log('Test 2:', a.fingerprint !== c.fingerprint ? 'PASS' : 'FAIL');
+    AndroidObserve.prototype.getUITree = async function () {
+        return {
+            device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true },
+            screen: '',
+            resolution: { width: 1080, height: 1920 },
+            elements: [
+                { text: 'Title', type: 'TextView', contentDescription: null, clickable: false, enabled: true, visible: true, bounds: [0, 0, 1080, 100], resourceId: 'id/title' },
+                { text: 'Sign in', type: 'Button', contentDescription: null, clickable: true, enabled: true, visible: true, bounds: [0, 200, 200, 260], resourceId: 'id/signin' },
+                { text: '12:34', type: 'TextView', contentDescription: null, clickable: false, enabled: true, visible: true, bounds: [900, 10, 1080, 40], resourceId: null }
+            ]
+        };
+    };
+    const d = await ai.getScreenFingerprint('mock');
+    console.log('Test 3:', a.fingerprint === d.fingerprint ? 'PASS' : 'FAIL');
+    AndroidObserve.prototype.getUITree = origGet;
+    AndroidObserve.prototype.getCurrentScreen = origCurrent;
+}
+run().catch(console.error);

package/dist/observe/test/unit/logparse.test.js

@@ -0,0 +1,39 @@
+import { parseLogLine } from '../../../src/android/utils.js';
+function assert(cond, msg) { if (!cond)
+    throw new Error(msg || 'Assertion failed'); }
+function run() {
+    const samples = [
+        // Standard format
+        {
+            line: '03-13 15:08:25.257  2468  2578 E FromGoneTransitionInteractor: Ignoring startTransition: ...',
+            expect: { level: 'E', tag: 'FromGoneTransitionInteractor', crash: false }
+        },
+        // Full date format
+        {
+            line: '2026-03-13 15:08:25.257  2468  2578 E Something: Boom happened',
+            expect: { level: 'E', tag: 'Something', crash: false }
+        },
+        // Simple priority/tag
+        {
+            line: 'W/MyTag: Some warning here',
+            expect: { level: 'W', tag: 'MyTag', crash: false }
+        },
+        // Crash message
+        {
+            line: '03-13 15:09:01.123  9999  9999 E AndroidRuntime: FATAL EXCEPTION: main\njava.lang.NullPointerException: at ...',
+            expect: { level: 'E', tag: 'AndroidRuntime', crash: true, exceptionContains: 'NullPointerException' }
+        }
+    ];
+    for (const s of samples) {
+        const res = parseLogLine(s.line);
+        console.log('Parsed:', res);
+        assert(res.level === s.expect.level, `Expected level ${s.expect.level} got ${res.level}`);
+        assert(res.tag === s.expect.tag, `Expected tag ${s.expect.tag} got ${res.tag}`);
+        if (s.expect.crash)
+            assert(res.crash === true, 'Expected crash true');
+        if (s.expect.exceptionContains)
+            assert(res.exception && res.exception.indexOf(s.expect.exceptionContains) !== -1, 'Expected exception to contain ' + s.expect.exceptionContains);
+    }
+    console.log('Log parse tests passed');
+}
+run();