mobile-debug-mcp 0.13.0 → 0.15.0

package/dist/tools/observe.js

@@ -1,80 +1,82 @@
 import { resolveTargetDevice } from '../utils/resolve-device.js';
-import { AndroidObserve } from '../android/observe.js';
-import { iOSObserve } from '../ios/observe.js';
+import { AndroidObserve, iOSObserve } from '../observe/index.js';
 export class ToolsObserve {
-    static async getUITreeHandler({ platform, deviceId }) {
+    // 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 });
-            return await new AndroidObserve().getUITree(resolved.id);
+            const resolved = await resolveTargetDevice({ platform: 'android', deviceId, appId });
+            return { observe: new AndroidObserve(), resolved };
         }
-        else {
-            const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
-            return await new iOSObserve().getUITree(resolved.id);
+        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 (e) {
+            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 resolved = await resolveTargetDevice({ platform: 'android', deviceId });
-        return await new AndroidObserve().getCurrentScreen(resolved.id);
+        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 }) {
-        if (platform === 'android') {
-            const resolved = await resolveTargetDevice({ platform: 'android', appId, deviceId });
-            const response = await new AndroidObserve().getLogs(appId, lines ?? 200, resolved.id);
+        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 resolved = await resolveTargetDevice({ platform: 'ios', appId, deviceId });
-            const resp = await new iOSObserve().getLogs(appId, resolved.id);
+            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 effectivePlatform = platform || 'android';
         const sid = sessionId || 'default';
-        if (effectivePlatform === 'android') {
-            const resolved = await resolveTargetDevice({ platform: 'android', appId: packageName, deviceId });
-            // Delegate to AndroidObserve's log stream methods
-            return await new AndroidObserve().startLogStream(packageName, level || 'error', resolved.id, sid);
+        const { observe, resolved } = await ToolsObserve.resolveObserve(platform, deviceId, packageName);
+        if (observe instanceof AndroidObserve) {
+            return await observe.startLogStream(packageName, level || 'error', resolved.id, sid);
         }
         else {
-            const resolved = await resolveTargetDevice({ platform: 'ios', appId: packageName, deviceId });
-            // Delegate to iOSObserve for starting log streams
-            return await new iOSObserve().startLogStream(packageName, resolved.id, sid);
+            return await observe.startLogStream(packageName, resolved.id, sid);
         }
     }
     static async readLogStreamHandler({ platform, sessionId, limit, since }) {
-        const effectivePlatform = platform || 'android';
         const sid = sessionId || 'default';
-        if (effectivePlatform === 'android') {
-            return await new AndroidObserve().readLogStream(sid, limit ?? 100, since);
-        }
-        else {
-            return await new iOSObserve().readLogStream(sid, limit ?? 100, since);
-        }
+        const { observe } = await ToolsObserve.resolveObserve(platform);
+        return await observe.readLogStream(sid, limit ?? 100, since);
     }
     static async stopLogStreamHandler({ platform, sessionId }) {
-        const effectivePlatform = platform || 'android';
         const sid = sessionId || 'default';
-        if (effectivePlatform === 'android') {
-            return await new AndroidObserve().stopLogStream(sid);
-        }
-        else {
-            return await new iOSObserve().stopLogStream(sid);
-        }
+        const { observe } = await ToolsObserve.resolveObserve(platform);
+        return await observe.stopLogStream(sid);
     }
     static async captureScreenshotHandler({ platform, deviceId }) {
-        const effectivePlatform = platform || 'android';
-        if (effectivePlatform === 'android') {
-            const resolved = await resolveTargetDevice({ platform: 'android', deviceId });
-            return await new AndroidObserve().captureScreen(resolved.id);
+        const { observe, resolved } = await ToolsObserve.resolveObserve(platform, deviceId);
+        if (observe instanceof AndroidObserve) {
+            return await observe.captureScreen(resolved.id);
         }
         else {
-            const resolved = await resolveTargetDevice({ platform: 'ios', deviceId });
-            return await new iOSObserve().captureScreenshot(resolved.id);
+            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);
+    }
 }

package/dist/tools/scroll_to_element.js

@@ -0,0 +1,98 @@
+export async function scrollToElementShared(opts) {
+    const { selector, direction = 'down', maxScrolls = 10, scrollAmount = 0.7, deviceId, fetchTree, swipe, stabilizationDelayMs = 350 } = opts;
+    const matchElement = (el) => {
+        if (!el)
+            return false;
+        if (selector.text !== undefined && selector.text !== el.text)
+            return false;
+        if (selector.resourceId !== undefined && selector.resourceId !== el.resourceId)
+            return false;
+        if (selector.contentDesc !== undefined && selector.contentDesc !== el.contentDescription)
+            return false;
+        if (selector.className !== undefined && selector.className !== el.type)
+            return false;
+        return true;
+    };
+    const isVisible = (el, resolution) => {
+        if (!el)
+            return false;
+        if (el.visible === false)
+            return false;
+        if (!el.bounds || !resolution || !resolution.width || !resolution.height)
+            return (el.visible === undefined ? true : !!el.visible);
+        const [left, top, right, bottom] = el.bounds;
+        const withinY = bottom > 0 && top < resolution.height;
+        const withinX = right > 0 && left < resolution.width;
+        return withinX && withinY;
+    };
+    const findVisibleMatch = (elements, resolution) => {
+        if (!Array.isArray(elements))
+            return null;
+        for (const e of elements) {
+            if (matchElement(e) && isVisible(e, resolution))
+                return e;
+        }
+        return null;
+    };
+    // Initial check
+    let tree = await fetchTree();
+    if (tree.error)
+        return { success: false, reason: tree.error, scrollsPerformed: 0 };
+    let found = findVisibleMatch(tree.elements, tree.resolution);
+    if (found) {
+        return { success: true, element: { text: found.text, resourceId: found.resourceId, bounds: found.bounds }, scrollsPerformed: 0 };
+    }
+    const fingerprintOf = (t) => {
+        try {
+            return JSON.stringify((t.elements || []).map((e) => ({ text: e.text, resourceId: e.resourceId, bounds: e.bounds })));
+        }
+        catch {
+            return '';
+        }
+    };
+    let prevFingerprint = fingerprintOf(tree);
+    const width = (tree.resolution && tree.resolution.width) ? tree.resolution.width : 0;
+    const height = (tree.resolution && tree.resolution.height) ? tree.resolution.height : 0;
+    const centerX = Math.round(width / 2) || 50;
+    const clampPct = (v) => Math.max(0.05, Math.min(0.95, v));
+    const computeCoords = () => {
+        const defaultStart = direction === 'down' ? 0.8 : 0.2;
+        const startPct = clampPct(defaultStart);
+        const endPct = clampPct(defaultStart + (direction === 'down' ? -scrollAmount : scrollAmount));
+        const x1 = centerX;
+        const x2 = centerX;
+        const y1 = Math.round((height || 100) * startPct);
+        const y2 = Math.round((height || 100) * endPct);
+        return { x1, y1, x2, y2 };
+    };
+    const duration = 300;
+    let scrollsPerformed = 0;
+    for (let i = 0; i < maxScrolls; i++) {
+        const { x1, y1, x2, y2 } = computeCoords();
+        try {
+            await swipe(x1, y1, x2, y2, duration, deviceId);
+        }
+        catch (e) {
+            // Log swipe failures to aid debugging but don't fail the overall flow
+            try {
+                console.warn(`scrollToElement swipe failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            catch { }
+        }
+        scrollsPerformed++;
+        await new Promise(resolve => setTimeout(resolve, stabilizationDelayMs));
+        tree = await fetchTree();
+        if (tree.error)
+            return { success: false, reason: tree.error, scrollsPerformed: scrollsPerformed };
+        found = findVisibleMatch(tree.elements, tree.resolution);
+        if (found) {
+            return { success: true, element: { text: found.text, resourceId: found.resourceId, bounds: found.bounds }, scrollsPerformed };
+        }
+        const fp = fingerprintOf(tree);
+        if (fp === prevFingerprint) {
+            return { success: false, reason: 'UI unchanged after scroll; likely end of list', scrollsPerformed: scrollsPerformed };
+        }
+        prevFingerprint = fp;
+    }
+    return { success: false, reason: 'Element not found after scrolling', scrollsPerformed: scrollsPerformed };
+}

package/dist/utils/android/utils.js

@@ -0,0 +1,429 @@
+import { spawn } from 'child_process';
+import { promises as fsPromises, existsSync } from 'fs';
+import path from 'path';
+import { detectJavaHome } from '../java.js';
+export function getAdbCmd() { return process.env.ADB_PATH || 'adb'; }
+/**
+ * Prepare Gradle execution options for building an Android project.
+ * Returns execCmd (wrapper or gradle), base gradleArgs array, and spawn options including env.
+ */
+export async function prepareGradle(projectPath) {
+    const gradlewPath = path.join(projectPath, 'gradlew');
+    const gradleCmd = existsSync(gradlewPath) ? './gradlew' : 'gradle';
+    const execCmd = existsSync(gradlewPath) ? gradlewPath : gradleCmd;
+    // Start with a default task; callers may append/override via env flags
+    const gradleArgs = [process.env.MCP_GRADLE_TASK || 'assembleDebug'];
+    // Respect generic MCP_BUILD_JOBS and Android-specific MCP_GRADLE_WORKERS
+    const workers = process.env.MCP_GRADLE_WORKERS || process.env.MCP_BUILD_JOBS;
+    if (workers) {
+        gradleArgs.push(`--max-workers=${workers}`);
+    }
+    // Respect gradle cache env: default enabled; set MCP_GRADLE_CACHE=0 to disable
+    if (process.env.MCP_GRADLE_CACHE === '0') {
+        gradleArgs.push('-Dorg.gradle.caching=false');
+    }
+    const detectedJavaHome = await detectJavaHome().catch(() => undefined);
+    const env = Object.assign({}, process.env);
+    if (detectedJavaHome) {
+        if (env.JAVA_HOME !== detectedJavaHome) {
+            env.JAVA_HOME = detectedJavaHome;
+            env.PATH = `${path.join(detectedJavaHome, 'bin')}${path.delimiter}${env.PATH || ''}`;
+        }
+        gradleArgs.push(`-Dorg.gradle.java.home=${detectedJavaHome}`);
+        gradleArgs.push('--no-daemon');
+        env.GRADLE_JAVA_HOME = detectedJavaHome;
+    }
+    try {
+        delete env.SHELL;
+    }
+    catch { }
+    const useWrapper = existsSync(gradlewPath);
+    const spawnOpts = { cwd: projectPath, env };
+    if (useWrapper) {
+        try {
+            await fsPromises.chmod(gradlewPath, 0o755);
+        }
+        catch { }
+        spawnOpts.shell = false;
+    }
+    else {
+        spawnOpts.shell = true;
+    }
+    return { execCmd, gradleArgs, spawnOpts };
+}
+// Helper to construct ADB args with optional device ID
+function getAdbArgs(args, deviceId) {
+    if (deviceId) {
+        return ['-s', deviceId, ...args];
+    }
+    return args;
+}
+/**
+ * Determine an effective ADB timeout (ms) prioritizing:
+ * 1. provided customTimeout
+ * 2. MCP_ADB_TIMEOUT or ADB_TIMEOUT env vars
+ * 3. sensible per-command defaults
+ */
+function getAdbTimeout(args, customTimeout) {
+    if (typeof customTimeout === 'number' && !isNaN(customTimeout))
+        return customTimeout;
+    const envTimeout = parseInt(process.env.MCP_ADB_TIMEOUT || process.env.ADB_TIMEOUT || '', 10);
+    if (!isNaN(envTimeout) && envTimeout > 0)
+        return envTimeout;
+    if (args.includes('logcat'))
+        return 10000;
+    if (args.includes('uiautomator') && args.includes('dump'))
+        return 20000;
+    return 120000;
+}
+export function execAdb(args, deviceId, options = {}) {
+    const adbArgs = getAdbArgs(args, deviceId);
+    return new Promise((resolve, reject) => {
+        // Extract timeout from options if present, otherwise pass options to spawn
+        const { timeout: customTimeout, ...spawnOptions } = options;
+        // Use spawn instead of execFile for better stream control and to avoid potential buffering hangs
+        const child = spawn(getAdbCmd(), adbArgs, spawnOptions);
+        let stdout = '';
+        let stderr = '';
+        if (child.stdout) {
+            child.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+        }
+        if (child.stderr) {
+            child.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+        }
+        const timeoutMs = getAdbTimeout(args, customTimeout);
+        const timeout = setTimeout(() => {
+            child.kill();
+            reject(new Error(`ADB command timed out after ${timeoutMs}ms: ${args.join(' ')}`));
+        }, timeoutMs);
+        child.on('close', (code) => {
+            clearTimeout(timeout);
+            if (code !== 0) {
+                // If there's an actual error (non-zero exit code), reject
+                reject(new Error(stderr.trim() || `Command failed with code ${code}`));
+            }
+            else {
+                // If exit code is 0, resolve with stdout
+                resolve(stdout.trim());
+            }
+        });
+        child.on('error', (err) => {
+            clearTimeout(timeout);
+            reject(err);
+        });
+    });
+}
+// Spawn adb but return full streams and exit code so callers can implement fallbacks or stream output
+export function spawnAdb(args, deviceId, options = {}) {
+    const adbArgs = getAdbArgs(args, deviceId);
+    return new Promise((resolve, reject) => {
+        const { timeout: customTimeout, ...spawnOptions } = options;
+        const child = spawn(getAdbCmd(), adbArgs, spawnOptions);
+        let stdout = '';
+        let stderr = '';
+        if (child.stdout)
+            child.stdout.on('data', d => { stdout += d.toString(); });
+        if (child.stderr)
+            child.stderr.on('data', d => { stderr += d.toString(); });
+        const timeoutMs = getAdbTimeout(args, customTimeout);
+        const timeout = setTimeout(() => {
+            try {
+                child.kill();
+            }
+            catch { }
+            reject(new Error(`ADB command timed out after ${timeoutMs}ms: ${args.join(' ')}`));
+        }, timeoutMs);
+        child.on('close', (code) => {
+            clearTimeout(timeout);
+            resolve({ stdout: stdout.trim(), stderr: stderr.trim(), code });
+        });
+        child.on('error', (err) => {
+            clearTimeout(timeout);
+            reject(err);
+        });
+    });
+}
+export function getDeviceInfo(deviceId, metadata = {}) {
+    return {
+        platform: 'android',
+        id: deviceId || 'default',
+        osVersion: metadata.osVersion || '',
+        model: metadata.model || '',
+        simulator: metadata.simulator || false
+    };
+}
+export async function getAndroidDeviceMetadata(appId, deviceId) {
+    try {
+        // If no deviceId provided, try to auto-detect a single connected device
+        let resolvedDeviceId = deviceId;
+        if (!resolvedDeviceId) {
+            try {
+                const devicesOutput = await execAdb(['devices']);
+                // Parse lines like: "<serial>\tdevice"
+                const lines = devicesOutput.split('\n').map(l => l.trim()).filter(Boolean);
+                const deviceLines = lines.slice(1) // skip header
+                    .map(l => l.split('\t'))
+                    .filter(parts => parts.length >= 2 && parts[1] === 'device')
+                    .map(parts => parts[0]);
+                if (deviceLines.length === 1) {
+                    resolvedDeviceId = deviceLines[0];
+                }
+            }
+            catch {
+                // ignore and continue without resolvedDeviceId
+            }
+        }
+        // Run these in parallel to avoid sequential timeouts
+        const [osVersion, model, simOutput] = await Promise.all([
+            execAdb(['shell', 'getprop', 'ro.build.version.release'], resolvedDeviceId).catch(() => ''),
+            execAdb(['shell', 'getprop', 'ro.product.model'], resolvedDeviceId).catch(() => ''),
+            execAdb(['shell', 'getprop', 'ro.kernel.qemu'], resolvedDeviceId).catch(() => '0')
+        ]);
+        const simulator = simOutput === '1';
+        return { platform: 'android', id: resolvedDeviceId || 'default', osVersion, model, simulator };
+    }
+    catch {
+        return { platform: 'android', id: deviceId || 'default', osVersion: '', model: '', simulator: false };
+    }
+}
+export async function findApk(dir) {
+    const entries = await fsPromises.readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const e of entries) {
+        const full = path.join(dir, e.name);
+        if (e.isDirectory()) {
+            const found = await findApk(full);
+            if (found)
+                return found;
+        }
+        else if (e.isFile() && full.endsWith('.apk')) {
+            return full;
+        }
+    }
+    return undefined;
+}
+export async function listAndroidDevices(appId) {
+    try {
+        const devicesOutput = await execAdb(['devices', '-l']);
+        const lines = devicesOutput.split('\n').map(l => l.trim()).filter(Boolean);
+        // Skip header if present (some adb versions include 'List of devices attached')
+        const deviceLines = lines.filter(l => !l.startsWith('List of devices')).map(l => l);
+        const serials = deviceLines.map(line => line.split(/\s+/)[0]).filter(Boolean);
+        const infos = await Promise.all(serials.map(async (serial) => {
+            try {
+                const [osVersion, model, simOutput] = await Promise.all([
+                    execAdb(['shell', 'getprop', 'ro.build.version.release'], serial).catch(() => ''),
+                    execAdb(['shell', 'getprop', 'ro.product.model'], serial).catch(() => ''),
+                    execAdb(['shell', 'getprop', 'ro.kernel.qemu'], serial).catch(() => '0')
+                ]);
+                const simulator = simOutput === '1';
+                let appInstalled = false;
+                if (appId) {
+                    try {
+                        const pm = await execAdb(['shell', 'pm', 'path', appId], serial);
+                        appInstalled = !!(pm && pm.includes('package:'));
+                    }
+                    catch {
+                        appInstalled = false;
+                    }
+                }
+                return { platform: 'android', id: serial, osVersion, model, simulator, appInstalled };
+            }
+            catch {
+                return { platform: 'android', id: serial, osVersion: '', model: '', simulator: false, appInstalled: false };
+            }
+        }));
+        return infos;
+    }
+    catch {
+        return [];
+    }
+}
+// UI helper utilities shared by observe/interact
+export const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+export function parseBounds(bounds) {
+    const match = bounds.match(/\[(\d+),(\d+)\]\[(\d+),(\d+)\]/);
+    if (match) {
+        return [parseInt(match[1]), parseInt(match[2]), parseInt(match[3]), parseInt(match[4])];
+    }
+    return [0, 0, 0, 0];
+}
+export function getCenter(bounds) {
+    const [x1, y1, x2, y2] = bounds;
+    return [Math.floor((x1 + x2) / 2), Math.floor((y1 + y2) / 2)];
+}
+export async function getScreenResolution(deviceId) {
+    try {
+        const output = await execAdb(['shell', 'wm', 'size'], deviceId);
+        const match = output.match(/Physical size: (\d+)x(\d+)/);
+        if (match) {
+            return { width: parseInt(match[1]), height: parseInt(match[2]) };
+        }
+    }
+    catch {
+        // ignore
+    }
+    return { width: 0, height: 0 };
+}
+export function traverseNode(node, elements, parentIndex = -1, depth = 0) {
+    if (!node)
+        return -1;
+    let currentIndex = -1;
+    if (node['@_class']) {
+        const text = node['@_text'] || null;
+        const contentDescription = node['@_content-desc'] || null;
+        const clickable = node['@_clickable'] === 'true';
+        const bounds = parseBounds(node['@_bounds'] || '[0,0][0,0]');
+        const isUseful = clickable || (text && text.length > 0) || (contentDescription && contentDescription.length > 0);
+        if (isUseful) {
+            const element = {
+                text,
+                contentDescription,
+                type: node['@_class'] || 'unknown',
+                resourceId: node['@_resource-id'] || null,
+                clickable,
+                enabled: node['@_enabled'] === 'true',
+                visible: true,
+                bounds,
+                center: getCenter(bounds),
+                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.node) {
+        if (Array.isArray(node.node)) {
+            node.node.forEach((child) => {
+                const childIndex = traverseNode(child, elements, nextParentIndex, nextDepth);
+                if (childIndex !== -1)
+                    childrenIndices.push(childIndex);
+            });
+        }
+        else {
+            const childIndex = traverseNode(node.node, elements, nextParentIndex, nextDepth);
+            if (childIndex !== -1)
+                childrenIndices.push(childIndex);
+        }
+    }
+    if (currentIndex !== -1 && childrenIndices.length > 0) {
+        elements[currentIndex].children = childrenIndices;
+    }
+    return currentIndex;
+}
+// Log stream management (one stream per session)
+// (Legacy active stream map removed from utils during refactor; Observe modules manage their own active streams.)
+// Robust log line parser supporting multiple logcat formats
+export function parseLogLine(line) {
+    const rawLine = line;
+    const normalizedLine = rawLine.replace(/\r?\n/g, ' ');
+    const entry = { timestamp: '', level: '', tag: '', message: rawLine, _iso: null, crash: false };
+    const nowYear = new Date().getFullYear();
+    const tryIso = (ts) => {
+        if (!ts)
+            return null;
+        // If it's already ISO
+        if (/^\d{4}-\d{2}-\d{2}T/.test(ts))
+            return ts;
+        // If format MM-DD HH:MM:SS(.sss)
+        const m = ts.match(/^(\d{2})-(\d{2})\s+(\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)$/);
+        if (m) {
+            const month = m[1];
+            const day = m[2];
+            const time = m[3];
+            const candidate = `${nowYear}-${month}-${day}T${time}`;
+            const d = new Date(candidate);
+            if (!isNaN(d.getTime()))
+                return d.toISOString();
+        }
+        // If format YYYY-MM-DD HH:MM:SS(.sss)
+        const m2 = ts.match(/^(\d{4}-\d{2}-\d{2})\s+(\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)$/);
+        if (m2) {
+            const candidate = `${m2[1]}T${m2[2]}`;
+            const d = new Date(candidate);
+            if (!isNaN(d.getTime()))
+                return d.toISOString();
+        }
+        return null;
+    };
+    // Patterns to try (ordered)
+    const patterns = [
+        // MM-DD HH:MM:SS.mmm PID TID LEVEL/Tag: msg
+        { re: /^(\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)\s+(\d+)\s+(\d+)\s+([VDIWE])\/([^:]+):\s*(.*)$/, groups: ['ts', 'pid', 'tid', 'level', 'tag', 'msg'] },
+        // MM-DD HH:MM:SS.mmm PID TID LEVEL Tag: msg  (space between level and tag)
+        { re: /^(\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)\s+(\d+)\s+(\d+)\s+([VDIWE])\s+([^:]+):\s*(.*)$/, groups: ['ts', 'pid', 'tid', 'level', 'tag', 'msg'] },
+        // YYYY-MM-DD full date with PID TID LEVEL/Tag
+        { re: /^(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)\s+(\d+)\s+(\d+)\s+([VDIWE])\/([^:]+):\s*(.*)$/, groups: ['ts', 'pid', 'tid', 'level', 'tag', 'msg'] },
+        // YYYY-MM-DD with space separation
+        { re: /^(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)\s+(\d+)\s+(\d+)\s+([VDIWE])\s+([^:]+):\s*(.*)$/, groups: ['ts', 'pid', 'tid', 'level', 'tag', 'msg'] },
+        // MM-DD PID LEVEL/Tag: msg
+        { re: /^(\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)\s+(\d+)\s+([VDIWE])\/([^:]+):\s*(.*)$/, groups: ['ts', 'pid', 'level', 'tag', 'msg'] },
+        // MM-DD PID LEVEL Tag: msg (space)
+        { re: /^(\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?)\s+(\d+)\s+([VDIWE])\s+([^:]+):\s*(.*)$/, groups: ['ts', 'pid', 'level', 'tag', 'msg'] },
+        // Short form LEVEL/Tag: msg
+        { re: /^([VDIWE])\/([^\(\:]+)(?:\([0-9]+\))?:\s*(.*)$/, groups: ['level', 'tag', 'msg'] },
+        // Short form LEVEL Tag: msg
+        { re: /^([VDIWE])\s+([^\(\:]+)(?:\([0-9]+\))?:\s*(.*)$/, groups: ['level', 'tag', 'msg'] },
+    ];
+    for (const p of patterns) {
+        const m = normalizedLine.match(p.re);
+        if (m) {
+            const g = p.groups;
+            const vals = {};
+            for (let i = 0; i < g.length; i++)
+                vals[g[i]] = m[i + 1];
+            const ts = vals.ts;
+            if (ts) {
+                const iso = tryIso(ts);
+                if (iso) {
+                    entry.timestamp = ts;
+                    entry._iso = iso;
+                }
+                else {
+                    entry.timestamp = ts;
+                }
+            }
+            if (vals.level)
+                entry.level = vals.level;
+            if (vals.tag)
+                entry.tag = vals.tag.trim();
+            entry.message = vals.msg || entry.message;
+            // Crash heuristics
+            const msg = (entry.message || '').toString();
+            const crash = /FATAL EXCEPTION/i.test(msg) || /\b([A-Za-z0-9_$.]+Exception)\b/.test(msg);
+            if (crash) {
+                entry.crash = true;
+                const exMatch = msg.match(/\b([A-Za-z0-9_$.]+Exception)\b/);
+                if (exMatch)
+                    entry.exception = exMatch[1];
+            }
+            return entry;
+        }
+    }
+    // No pattern matched: attempt to extract level/tag like '... E/Tag: msg'
+    const alt = normalizedLine.match(/([VDIWE])\/([^:]+):\s*(.*)$/);
+    if (alt) {
+        entry.level = alt[1];
+        entry.tag = alt[2].trim();
+        entry.message = alt[3];
+        const msg = entry.message;
+        const crash = /FATAL EXCEPTION/i.test(msg) || /\b([A-Za-z0-9_$.]+Exception)\b/.test(msg);
+        if (crash) {
+            entry.crash = true;
+            const exMatch = msg.match(/\b([A-Za-z0-9_$.]+Exception)\b/);
+            if (exMatch)
+                entry.exception = exMatch[1];
+        }
+    }
+    return entry;
+}
+// Legacy readLogStreamLines shim removed. Use AndroidObserve.readLogStream(sessionId, limit, since) instead.