mobile-debug-mcp 0.21.1 → 0.21.3

package/dist/interact/index.js

@@ -219,6 +219,23 @@ export class ToolsInteract {
         // Backwards-compatible wrapper that delegates to the core waitForUICore implementation
         return await ToolsInteract.waitForUICore({ type, query, timeoutMs, pollIntervalMs, includeSnapshotOnFailure, match, stability_ms, observationDelayMs, platform, deviceId });
     }
+    // Helper: normalize various log objects into plain message strings for comparison
+    static _logsToMessages(logsArr) {
+        if (!Array.isArray(logsArr))
+            return [];
+        return logsArr.map((l) => {
+            if (typeof l === 'string')
+                return l;
+            if (l && (l.message || l.msg))
+                return l.message || l.msg;
+            try {
+                return JSON.stringify(l);
+            }
+            catch {
+                return String(l);
+            }
+        });
+    }
     static async waitForScreenChangeHandler({ platform, previousFingerprint, timeoutMs = 5000, pollIntervalMs = 300, deviceId }) {
         const start = Date.now();
         let lastFingerprint = null;
@@ -275,7 +292,9 @@ export class ToolsInteract {
                 initialFingerprint = fpRes.fingerprint ?? null;
             if (gl) {
                 const logsArr = Array.isArray(gl.logs) ? gl.logs : [];
-                baselineLastLine = logsArr.length ? logsArr[logsArr.length - 1] : null;
+                // Normalize to last message string for baseline comparison
+                const msgs = ToolsInteract._logsToMessages(logsArr);
+                baselineLastLine = msgs.length ? msgs[msgs.length - 1] : null;
             }
         }
         catch (err) {
@@ -354,13 +373,15 @@ export class ToolsInteract {
                     }
                     const gl = await ToolsObserve.getLogsHandler({ platform, deviceId, lines: 200 });
                     const logsArr = Array.isArray(gl && gl.logs) ? gl.logs : [];
+                    // Normalize to messages for comparison
+                    const msgs = ToolsInteract._logsToMessages(logsArr);
                     let startIndex = 0;
                     if (baselineLastLine) {
-                        const idx = logsArr.lastIndexOf(baselineLastLine);
+                        const idx = msgs.lastIndexOf(baselineLastLine);
                         startIndex = idx >= 0 ? idx + 1 : 0;
                     }
-                    for (let i = startIndex; i < logsArr.length; i++) {
-                        const line = logsArr[i];
+                    for (let i = startIndex; i < msgs.length; i++) {
+                        const line = msgs[i];
                         if (q && String(line).includes(q)) {
                             const now2 = Date.now();
                             return { success: true, condition: 'present', query: q, poll_count: pollCount, duration_ms: now2 - start, stable_duration_ms: 0, matchedLog: { message: line }, matchSource: 'log-snapshot', timestamp: now2, type: 'log', observed_state: true };

package/dist/observe/android.js

@@ -5,6 +5,7 @@ import { createWriteStream } from "fs";
 import { promises as fsPromises } from "fs";
 import path from "path";
 import { computeScreenFingerprint } from "../utils/ui/index.js";
+import { parsePngSize } from "../utils/image.js";
 const activeLogStreams = new Map();
 export class AndroidObserve {
     async getDeviceMetadata(appId, deviceId) {
@@ -79,23 +80,98 @@ export class AndroidObserve {
             };
         }
     }
-    async getLogs(appId, lines = 200, deviceId) {
+    async getLogs(filters = {}) {
+        const { appId, deviceId, pid, tag, level, contains, since_seconds, limit } = filters;
         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;
+            const effectiveLimit = typeof limit === 'number' && limit > 0 ? limit : 50;
+            // If appId provided, try to get pid to filter at source
+            let pidArg = null;
             if (appId) {
-                const matchingLogs = allLogs.filter(line => line.includes(appId));
-                if (matchingLogs.length > 0) {
-                    filteredLogs = matchingLogs;
+                try {
+                    const pidOut = await execAdb(['shell', 'pidof', appId], deviceId).catch(() => '');
+                    const pidTrim = (pidOut || '').trim();
+                    if (pidTrim)
+                        pidArg = pidTrim.split('\n')[0];
                 }
-                else {
-                    filteredLogs = allLogs;
+                catch (err) {
+                    // Log a warning so failures to detect PID are visible during debugging
+                    try {
+                        console.warn(`getLogs: pid detection failed for appId=${appId}:`, err instanceof Error ? err.message : String(err));
+                    }
+                    catch { }
                 }
             }
-            return { device: deviceInfo, logs: filteredLogs, logCount: filteredLogs.length };
+            const args = ['logcat', '-d', '-v', 'threadtime'];
+            // Apply pid filter via --pid if available
+            if (pidArg)
+                args.push(`--pid=${pidArg}`);
+            else if (pid)
+                args.push(`--pid=${pid}`);
+            // Apply tag/level filter if provided
+            if (tag && level) {
+                // Map verbose/debug/info/warn/error to single-letter levels
+                const levelMap = { 'VERBOSE': 'V', 'DEBUG': 'D', 'INFO': 'I', 'WARN': 'W', 'ERROR': 'E' };
+                const L = (levelMap[(level || '').toUpperCase()] || 'V');
+                args.push(`${tag}:${L}`);
+            }
+            else {
+                // Default: show all levels
+                args.push('*:V');
+            }
+            // Use -t to limit lines (apply early)
+            args.push('-t', effectiveLimit.toString());
+            const stdout = await execAdb(args, deviceId);
+            const allLines = stdout ? stdout.split(/\r?\n/).filter(Boolean) : [];
+            // Parse lines into structured entries
+            const parsed = allLines.map(l => {
+                const entry = parseLogLine(l);
+                // normalize level
+                const levelChar = (entry.level || '').toUpperCase();
+                const levelMapChar = { 'V': 'VERBOSE', 'D': 'DEBUG', 'I': 'INFO', 'W': 'WARN', 'E': 'ERROR' };
+                const normLevel = levelMapChar[levelChar] || (entry.level && String(entry.level).toUpperCase()) || 'INFO';
+                const iso = entry._iso || (() => {
+                    const d = new Date(entry.timestamp || '');
+                    if (!isNaN(d.getTime()))
+                        return d.toISOString();
+                    return null;
+                })();
+                let pidNum = null;
+                if (entry.pid)
+                    pidNum = Number(entry.pid);
+                else if (pidArg)
+                    pidNum = Number(pidArg);
+                const pidVal = (pidNum !== null && !isNaN(pidNum)) ? pidNum : null;
+                return { timestamp: iso, level: normLevel, tag: entry.tag || '', pid: pidVal, message: entry.message || '' };
+            });
+            // Apply client-side filters: contains, since_seconds
+            let filtered = parsed;
+            if (contains)
+                filtered = filtered.filter(e => e.message && e.message.includes(contains));
+            if (since_seconds) {
+                const sinceMs = Date.now() - (since_seconds * 1000);
+                filtered = filtered.filter(e => {
+                    if (!e.timestamp)
+                        return false;
+                    const t = new Date(e.timestamp).getTime();
+                    return t >= sinceMs;
+                });
+            }
+            // If appId provided and no pidArg, try to filter by appId substring in message/tag
+            if (appId && !pidArg) {
+                const matched = filtered.filter(e => (e.message && e.message.includes(appId)) || (e.tag && e.tag.includes(appId)));
+                if (matched.length > 0)
+                    filtered = matched;
+            }
+            // Ensure ordering oldest -> newest (by timestamp when available)
+            filtered.sort((a, b) => {
+                const ta = a.timestamp ? new Date(a.timestamp).getTime() : 0;
+                const tb = b.timestamp ? new Date(b.timestamp).getTime() : 0;
+                return ta - tb;
+            });
+            const limited = filtered.slice(-Math.max(0, effectiveLimit));
+            return { device: deviceInfo, logs: limited, logCount: limited.length };
         }
         catch (e) {
             console.error("Error fetching logs:", e);
@@ -120,7 +196,7 @@ export class AndroidObserve {
                 child.kill();
                 reject(new Error(`ADB screencap timed out after 10s`));
             }, 10000);
-            child.on('close', (code) => {
+            child.on('close', async (code) => {
                 clearTimeout(timeout);
                 if (code !== 0) {
                     reject(new Error(stderr.trim() || `Screencap failed with code ${code}`));
@@ -128,28 +204,91 @@ export class AndroidObserve {
                 }
                 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);
+                const parsed = parsePngSize(screenshotBuffer);
+                if (parsed.width > 0 && parsed.height > 0) {
+                    // Attempt to convert to WebP (preferred) and provide JPEG fallback (awaited to avoid race)
+                    try {
+                        const sharpModule = await import('sharp');
+                        const sharp = sharpModule && sharpModule.default ? sharpModule.default : sharpModule;
+                        const buf = screenshotBuffer;
+                        const img = sharp(buf);
+                        const meta = await img.metadata().catch((err) => { console.error('sharp.metadata failed (Android):', err); return {}; });
+                        const hasAlpha = !!meta.hasAlpha || (meta.channels && meta.channels > 3);
+                        let webpBuf = null;
+                        let jpegBuf = null;
+                        try {
+                            webpBuf = await img.webp({ quality: 80 }).toBuffer();
+                        }
+                        catch (err) {
+                            console.error('WebP conversion failed (Android):', err instanceof Error ? err.message : String(err));
+                            webpBuf = null;
+                        }
+                        try {
+                            jpegBuf = await img.jpeg({ quality: 80 }).toBuffer();
+                        }
+                        catch (err) {
+                            console.error('JPEG conversion failed (Android):', err instanceof Error ? err.message : String(err));
+                            jpegBuf = null;
+                        }
+                        if (hasAlpha) {
+                            if (webpBuf) {
+                                const webpB64 = webpBuf.toString('base64');
+                                const jpegB64 = jpegBuf ? jpegBuf.toString('base64') : null;
+                                resolve({ device: deviceInfo, screenshot: webpB64, screenshot_mime: 'image/webp', screenshot_fallback: jpegB64, screenshot_fallback_mime: jpegB64 ? 'image/jpeg' : undefined, resolution: { width: parsed.width, height: parsed.height } });
+                                return;
+                            }
+                            const pngB64 = buf.toString('base64');
+                            resolve({ device: deviceInfo, screenshot: pngB64, screenshot_mime: 'image/png', resolution: { width: parsed.width, height: parsed.height } });
+                            return;
+                        }
+                        if (webpBuf) {
+                            const webpB64 = webpBuf.toString('base64');
+                            const jpegB64 = jpegBuf ? jpegBuf.toString('base64') : null;
+                            resolve({ device: deviceInfo, screenshot: webpB64, screenshot_mime: 'image/webp', screenshot_fallback: jpegB64, screenshot_fallback_mime: jpegB64 ? 'image/jpeg' : undefined, resolution: { width: parsed.width, height: parsed.height } });
+                            return;
+                        }
+                        if (jpegBuf) {
+                            resolve({ device: deviceInfo, screenshot: jpegBuf.toString('base64'), screenshot_mime: 'image/jpeg', resolution: { width: parsed.width, height: parsed.height } });
+                            return;
+                        }
+                        // No conversions succeeded; return original PNG
+                        resolve({ device: deviceInfo, screenshot: screenshotBase64, screenshot_mime: 'image/png', resolution: { width: parsed.width, height: parsed.height } });
+                        return;
                     }
-                    resolve({
-                        device: deviceInfo,
-                        screenshot: screenshotBase64,
-                        resolution: { width, height }
-                    });
-                })
-                    .catch(() => {
-                    resolve({
-                        device: deviceInfo,
-                        screenshot: screenshotBase64,
-                        resolution: { width: 0, height: 0 }
+                    catch (err) {
+                        console.error('Screenshot conversion pipeline failed (Android):', err instanceof Error ? err.message : String(err));
+                        // Conversion failed - fall back to original PNG with parsed resolution
+                        resolve({ device: deviceInfo, screenshot: screenshotBase64, screenshot_mime: 'image/png', 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);

package/dist/observe/index.js

@@ -33,19 +33,30 @@ export class ToolsObserve {
         // getCurrentScreen is Android-specific
         return await observe.getCurrentScreen(resolved.id);
     }
-    static async getLogsHandler({ platform, appId, deviceId, lines }) {
+    static async getLogsHandler({ platform, appId, deviceId, pid, tag, level, contains, since_seconds, limit, lines }) {
         const { observe, resolved } = await ToolsObserve.resolveObserve(platform, deviceId, appId);
+        const filters = { appId, deviceId: resolved.id, pid, tag, level, contains, since_seconds, limit: limit ?? lines };
+        // Validate filters
+        if (level && !['VERBOSE', 'DEBUG', 'INFO', 'WARN', 'ERROR'].includes(level.toString().toUpperCase())) {
+            return { device: resolved, logs: [], crashLines: [], logCount: 0, error: { code: 'INVALID_FILTER', message: `Unsupported level filter: ${level}` } };
+        }
         if (observe instanceof AndroidObserve) {
-            const response = await observe.getLogs(appId, lines ?? 200, resolved.id);
+            const response = await observe.getLogs(filters);
             const logs = Array.isArray(response.logs) ? response.logs : [];
-            const crashLines = logs.filter(line => line.includes('FATAL EXCEPTION'));
-            return { device: response.device, logs, crashLines };
+            const crashLines = logs.filter(entry => /FATAL EXCEPTION/i.test(entry.message));
+            const anyFilterApplied = !!(appId || pid || tag || level || contains || since_seconds);
+            if (anyFilterApplied && logs.length === 0)
+                return { device: response.device, logs: [], crashLines: [], logCount: 0, error: { code: 'LOGS_UNAVAILABLE', message: 'No logs match filters' } };
+            return { device: response.device, logs, crashLines, logCount: response.logCount };
         }
         else {
-            const resp = await observe.getLogs(appId, resolved.id);
+            const resp = await observe.getLogs(filters);
             const logs = Array.isArray(resp.logs) ? resp.logs : [];
-            const crashLines = logs.filter(l => l.includes('FATAL EXCEPTION'));
-            return { device: resp.device, logs, crashLines };
+            const crashLines = logs.filter(entry => /FATAL EXCEPTION/i.test(entry.message));
+            const anyFilterApplied = !!(appId || pid || tag || level || contains || since_seconds);
+            if (anyFilterApplied && logs.length === 0)
+                return { device: resp.device, logs: [], crashLines: [], logCount: 0, error: { code: 'LOGS_UNAVAILABLE', message: 'No logs match filters' } };
+            return { device: resp.device, logs, crashLines, logCount: resp.logCount };
         }
     }
     static async startLogStreamHandler({ platform, packageName, level, sessionId, deviceId }) {
@@ -154,9 +165,20 @@ export class ToolsObserve {
                 if (!entries || entries.length === 0) {
                     const gl = await ToolsObserve.getLogsHandler({ platform, appId, deviceId, lines: logLines });
                     const raw = (gl && gl.logs) ? gl.logs : [];
-                    entries = raw.slice(-Math.max(0, logLines)).map(line => {
-                        const level = /\b(FATAL EXCEPTION|ERROR| E )\b/i.test(line) ? 'ERROR' : /\b(WARN| W )\b/i.test(line) ? 'WARN' : 'INFO';
-                        return { timestamp: null, level, message: line };
+                    // raw may be structured entries or strings
+                    entries = raw.slice(-Math.max(0, logLines)).map(item => {
+                        if (!item)
+                            return { timestamp: null, level: 'INFO', message: '' };
+                        if (typeof item === 'string') {
+                            const level = /\b(FATAL EXCEPTION|ERROR| E )\b/i.test(item) ? 'ERROR' : /\b(WARN| W )\b/i.test(item) ? 'WARN' : 'INFO';
+                            return { timestamp: null, level, message: item };
+                        }
+                        const msg = item.message || item.msg || JSON.stringify(item);
+                        const levelRaw = item.level || item.levelName || item._level || '';
+                        const level = (levelRaw && String(levelRaw)).toUpperCase() || (/\bERROR\b/i.test(msg) ? 'ERROR' : /\bWARN\b/i.test(msg) ? 'WARN' : 'INFO');
+                        const ts = item.timestamp || item._iso || null;
+                        const tsNum = (ts && typeof ts === 'string') ? (isNaN(new Date(ts).getTime()) ? null : new Date(ts).getTime()) : (typeof ts === 'number' ? ts : null);
+                        return { timestamp: tsNum, level, message: msg };
                     });
                 }
                 else {

package/dist/observe/ios.js

@@ -5,6 +5,7 @@ import { createWriteStream, promises as fsPromises } from 'fs';
 import path from 'path';
 import { parseLogLine } from '../utils/android/utils.js';
 import { computeScreenFingerprint } from '../utils/ui/index.js';
+import { parsePngSize } from '../utils/image.js';
 const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 function parseIDBFrame(frame) {
     if (!frame)
@@ -87,20 +88,128 @@ 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'];
+    async getLogs(filters = {}) {
+        const { appId, deviceId = 'booted', pid, tag, level, contains, since_seconds, limit } = filters;
+        const args = ['simctl', 'spawn', deviceId, 'log', 'show', '--style', 'syslog'];
+        // Default to last N seconds if no since_seconds provided; limit lines handled after parsing
+        const effectiveLimit = typeof limit === 'number' && limit > 0 ? limit : 50;
+        if (since_seconds) {
+            // log show accepts --last <time>
+            args.push('--last', `${since_seconds}s`);
+        }
+        else {
+            // default to last 60s to keep quick
+            args.push('--last', '60s');
+        }
         if (appId) {
             validateBundleId(appId);
+            // constrain to subsystem or process matching 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,
-        };
+        else if (tag) {
+            // predicate by subsystem/category
+            args.push('--predicate', `subsystem contains "${tag}"`);
+        }
+        try {
+            const result = await execCommand(args, deviceId);
+            const device = await getIOSDeviceMetadata(deviceId);
+            const rawLines = result.output ? result.output.split(/\r?\n/).filter(Boolean) : [];
+            // Parse lines into structured entries. iOS log format: timestamp [PID:tid] <level> subsystem:category: message
+            const parsed = rawLines.map(line => {
+                // Example: 2023-08-12 12:34:56.789012+0000  pid  <Debug>  MyApp[123:456]  <info>  MySubsystem: MyCategory: Message here
+                // Simpler approach: try to extract ISO timestamp at start
+                let ts = null;
+                const tsMatch = line.match(/^(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}(?:\.\d+)?)/);
+                if (tsMatch) {
+                    const d = new Date(tsMatch[1]);
+                    if (!isNaN(d.getTime()))
+                        ts = d.toISOString();
+                }
+                // level mapping
+                let lvl = 'INFO';
+                const lvlMatch = line.match(/\b(Debug|Info|Default|Error|Fault|Warning)\b/i);
+                if (lvlMatch) {
+                    const map = { 'debug': 'DEBUG', 'info': 'INFO', 'default': 'DEBUG', 'error': 'ERROR', 'fault': 'ERROR', 'warning': 'WARN' };
+                    lvl = map[(lvlMatch[1] || '').toLowerCase()] || 'INFO';
+                }
+                // subsystem/category -> tag
+                let tagVal = '';
+                const tagMatch = line.match(/\s([A-Za-z0-9_./-]+):\s/);
+                if (tagMatch)
+                    tagVal = tagMatch[1];
+                // pid extraction
+                let pidNum = null;
+                const pidMatch = line.match(/\[(\d+):\d+\]/);
+                if (pidMatch)
+                    pidNum = Number(pidMatch[1]);
+                // message: extract robustly after the subsystem/category token when available
+                let message = line;
+                if (tagMatch) {
+                    // tagMatch[0] includes the delimiter (e.g. " MySubsystem: ") — use it to find the message start
+                    const marker = tagMatch[0];
+                    const idx = line.indexOf(marker);
+                    if (idx !== -1) {
+                        message = line.slice(idx + marker.length).trim();
+                    }
+                    else {
+                        // fallback: try to trim off common prefixes (timestamp, pid, level) and keep the rest
+                        const afterPidMatch = line.match(/\]\s+/);
+                        if (afterPidMatch) {
+                            const afterPidIdx = line.indexOf(afterPidMatch[0]) + afterPidMatch[0].length;
+                            message = line.slice(afterPidIdx).trim();
+                        }
+                        else {
+                            // remove leading level tokens like <Debug> and keep remainder
+                            message = line.replace(/^.*?<.*?>\s*/, '').trim();
+                        }
+                    }
+                }
+                else {
+                    // No tag found — strip obvious prefixes and keep remainder (preserve colons in message)
+                    message = line.replace(/^.*?<.*?>\s*/, '').trim();
+                }
+                return { timestamp: ts, level: lvl, tag: tagVal, pid: pidNum, message };
+            });
+            // Apply contains filter
+            let filtered = parsed;
+            if (contains)
+                filtered = filtered.filter(e => e.message && e.message.includes(contains));
+            // Apply since_seconds already applied by log show, but double-check timestamps
+            if (since_seconds) {
+                const sinceMs = Date.now() - (since_seconds * 1000);
+                filtered = filtered.filter(e => e.timestamp && (new Date(e.timestamp).getTime() >= sinceMs));
+            }
+            // level filter
+            if (level) {
+                const L = level.toUpperCase();
+                filtered = filtered.filter(e => e.level && e.level.toUpperCase() === L);
+            }
+            // tag filter
+            if (tag)
+                filtered = filtered.filter(e => e.tag && e.tag.includes(tag));
+            // pid filter
+            if (pid)
+                filtered = filtered.filter(e => e.pid === pid);
+            // If appId present but no predicate returned lines, try substring match
+            if (appId && filtered.length === 0) {
+                const matched = parsed.filter(e => (e.message && e.message.includes(appId)) || (e.tag && e.tag.includes(appId)));
+                if (matched.length > 0)
+                    filtered = matched;
+            }
+            // Order oldest -> newest
+            filtered.sort((a, b) => {
+                const ta = a.timestamp ? new Date(a.timestamp).getTime() : 0;
+                const tb = b.timestamp ? new Date(b.timestamp).getTime() : 0;
+                return ta - tb;
+            });
+            const limited = filtered.slice(-Math.max(0, effectiveLimit));
+            return { device, logs: limited, logCount: limited.length };
+        }
+        catch (err) {
+            console.error('iOS getLogs failed:', err);
+            const device = await getIOSDeviceMetadata(deviceId);
+            return { device, logs: [], logCount: 0 };
+        }
     }
     async captureScreenshot(deviceId = "booted") {
         const device = await getIOSDeviceMetadata(deviceId);
@@ -109,11 +218,59 @@ export class iOSObserve {
             await execCommand(['simctl', 'io', deviceId, 'screenshot', tmpFile], deviceId);
             const buffer = await fs.readFile(tmpFile);
             const base64 = buffer.toString('base64');
+            const dims = parsePngSize(buffer);
+            // Try to generate WebP (preferred) and JPEG fallback using sharp (in-process, cross-platform)
+            try {
+                const sharpModule = await import('sharp');
+                const sharp = sharpModule && sharpModule.default ? sharpModule.default : sharpModule;
+                const img = sharp(buffer);
+                const meta = await img.metadata().catch((err) => { console.error('sharp.metadata failed:', err); return {}; });
+                // If image has alpha channel, prefer lossless PNG to preserve transparency
+                const hasAlpha = !!meta.hasAlpha || (meta.channels && meta.channels > 3);
+                // Generate WebP and JPEG buffers; log failures
+                let webpBuf = null;
+                let jpegBuf = null;
+                try {
+                    webpBuf = await img.webp({ quality: 80 }).toBuffer();
+                }
+                catch (err) {
+                    console.error('WebP conversion failed (iOS):', err instanceof Error ? err.message : String(err));
+                    webpBuf = null;
+                }
+                try {
+                    jpegBuf = await img.jpeg({ quality: 80 }).toBuffer();
+                }
+                catch (err) {
+                    console.error('JPEG conversion failed (iOS):', err instanceof Error ? err.message : String(err));
+                    jpegBuf = null;
+                }
+                await fs.rm(tmpFile).catch(() => { });
+                if (hasAlpha) {
+                    // preserve alpha: return PNG if WebP not available
+                    if (webpBuf) {
+                        return { device, screenshot: webpBuf.toString('base64'), screenshot_mime: 'image/webp', screenshot_fallback: base64, screenshot_fallback_mime: 'image/png', resolution: { width: dims.width, height: dims.height } };
+                    }
+                    // if webp unavailable, return original PNG
+                    return { device, screenshot: base64, screenshot_mime: 'image/png', resolution: { width: dims.width, height: dims.height } };
+                }
+                // No alpha: prefer webp, fall back to jpeg
+                if (webpBuf) {
+                    return { device, screenshot: webpBuf.toString('base64'), screenshot_mime: 'image/webp', screenshot_fallback: jpegBuf ? jpegBuf.toString('base64') : undefined, screenshot_fallback_mime: jpegBuf ? 'image/jpeg' : undefined, resolution: { width: dims.width, height: dims.height } };
+                }
+                if (jpegBuf) {
+                    return { device, screenshot: jpegBuf.toString('base64'), screenshot_mime: 'image/jpeg', resolution: { width: dims.width, height: dims.height } };
+                }
+            }
+            catch (err) {
+                console.error('Screenshot conversion pipeline failed (iOS):', err instanceof Error ? err.message : String(err));
+                // fall through to png fallback
+            }
             await fs.rm(tmpFile).catch(() => { });
             return {
                 device,
                 screenshot: base64,
-                resolution: { width: 0, height: 0 },
+                screenshot_mime: 'image/png',
+                resolution: { width: dims.width, height: dims.height },
             };
         }
         catch (e) {

package/dist/server.js

@@ -148,7 +148,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
         {
             name: "get_logs",
-            description: "Get recent logs from Android or iOS simulator. Returns device metadata and the log output.",
+            description: "Get recent logs from Android or iOS simulator. Returns device metadata and structured logs suitable for AI consumption.",
             inputSchema: {
                 type: "object",
                 properties: {
@@ -164,9 +164,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                         type: "string",
                         description: "Device UDID (iOS) or Serial (Android). Defaults to booted/connected."
                     },
+                    pid: { type: "number", description: "Filter by process id" },
+                    tag: { type: "string", description: "Filter by tag (Android) or subsystem/category (iOS)" },
+                    level: { type: "string", description: "Log level filter (VERBOSE, DEBUG, INFO, WARN, ERROR)" },
+                    contains: { type: "string", description: "Substring to match in log message" },
+                    since_seconds: { type: "number", description: "Only return logs from the last N seconds" },
+                    limit: { type: "number", description: "Override default number of returned lines" },
                     lines: {
                         type: "number",
-                        description: "Number of log lines (android only)"
+                        description: "Legacy - number of log lines (android only)"
                     }
                 },
                 required: ["platform"]
@@ -563,12 +569,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             };
         }
         if (name === "get_logs") {
-            const { platform, appId, deviceId, lines } = args;
-            const res = await ToolsObserve.getLogsHandler({ platform, appId, deviceId, lines });
+            const { platform, appId, deviceId, pid, tag, level, contains, since_seconds, limit, lines } = args;
+            const res = await ToolsObserve.getLogsHandler({ platform, appId, deviceId, pid, tag, level, contains, since_seconds, limit, lines });
+            const filtered = !!(pid || tag || level || contains || since_seconds || appId);
             return {
                 content: [
-                    { type: 'text', text: JSON.stringify({ device: res.device, result: { lines: res.logs.length, crashLines: res.crashLines.length > 0 ? res.crashLines : undefined } }, null, 2) },
-                    { type: 'text', text: (res.logs || []).join('\n') }
+                    { type: 'text', text: JSON.stringify({ device: res.device, result: { count: res.logCount, filtered, crashLines: (res.crashLines || []) } }, null, 2) },
+                    { type: 'text', text: JSON.stringify({ logs: res.logs }, null, 2) }
                 ]
             };
         }
@@ -584,12 +591,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         if (name === "capture_screenshot") {
             const { platform, deviceId } = args;
             const res = await ToolsObserve.captureScreenshotHandler({ platform, deviceId });
-            return {
-                content: [
-                    { type: 'text', text: JSON.stringify({ device: res.device, result: { resolution: res.resolution } }, null, 2) },
-                    { type: 'image', data: res.screenshot, mimeType: 'image/png' }
-                ]
-            };
+            const mime = res.screenshot_mime || 'image/png';
+            const content = [
+                { type: 'text', text: JSON.stringify({ device: res.device, result: { resolution: res.resolution, mimeType: mime } }, null, 2) },
+                { type: 'image', data: res.screenshot, mimeType: mime }
+            ];
+            // If a jpeg fallback is available, include a small note and the fallback as an additional image block for compatibility
+            if (res.screenshot_fallback) {
+                content.push({ type: 'text', text: JSON.stringify({ note: 'JPEG fallback included for compatibility', mimeType: res.screenshot_fallback_mime || 'image/jpeg' }) });
+                content.push({ type: 'image', data: res.screenshot_fallback, mimeType: res.screenshot_fallback_mime || 'image/jpeg' });
+            }
+            return { content };
         }
         if (name === "capture_debug_snapshot") {
             const { reason, includeLogs, logLines, platform, appId, deviceId, sessionId } = args;

package/dist/utils/cli/ios/run-ios-smoke.js

@@ -13,7 +13,7 @@ async function main() {
         const shot = await obs.captureScreenshot(deviceId);
         console.log('screenshot OK? size:', shot && shot.screenshot ? shot.screenshot.length : 0);
         console.log('[3] getLogs');
-        const logs = await obs.getLogs(appId, undefined);
+        const logs = await obs.getLogs({ appId, deviceId });
         console.log('logs count:', logs.logCount);
         console.log('[4] terminateApp');
         const term = await manage.terminateApp(appId, deviceId);