mobile-debug-mcp 0.21.2 → 0.21.4

package/dist/interact/index.js

@@ -215,9 +215,200 @@ export class ToolsInteract {
         const scoreVal = Math.min(1, Number(bestScore.toFixed(3)));
         return { found: true, element: outEl, score: scoreVal, confidence: scoreVal };
     }
-    static async waitForUIHandler({ type = 'ui', query, timeoutMs = 30000, pollIntervalMs = 300, includeSnapshotOnFailure = true, match = 'present', stability_ms = 700, observationDelayMs = 0, platform, deviceId }) {
-        // 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 });
+    static async waitForUIHandler({ selector, condition = 'exists', timeout_ms = 60000, poll_interval_ms = 300, match, retry = { max_attempts: 1, backoff_ms: 0 }, platform, deviceId }) {
+        const overallStart = Date.now();
+        // Validate selector: require at least one of text, resource_id, or accessibility_id
+        if (!selector || (typeof selector === 'object' && Object.keys(selector).length === 0)) {
+            return { status: 'timeout', error: { code: 'INVALID_SELECTOR', message: 'At least one selector field must be provided (text, resource_id, or accessibility_id)' }, metrics: { latency_ms: Date.now() - overallStart, poll_count: 0, attempts: 0 } };
+        }
+        const hasText = selector && typeof selector.text === 'string' && selector.text.trim().length > 0;
+        const hasResId = selector && typeof selector.resource_id === 'string' && selector.resource_id.trim().length > 0;
+        const hasAccId = selector && typeof selector.accessibility_id === 'string' && selector.accessibility_id.trim().length > 0;
+        if (!hasText && !hasResId && !hasAccId) {
+            return { status: 'timeout', error: { code: 'INVALID_SELECTOR', message: 'Selector must include at least one of: text, resource_id, accessibility_id' }, metrics: { latency_ms: Date.now() - overallStart, poll_count: 0, attempts: 0 } };
+        }
+        // Validate condition
+        if (!['exists', 'not_exists', 'visible', 'clickable'].includes(condition)) {
+            return { status: 'timeout', error: { code: 'INVALID_CONDITION', message: `Unsupported condition: ${condition}` }, metrics: { latency_ms: Date.now() - overallStart, poll_count: 0, attempts: 0 } };
+        }
+        // Platform check
+        if (platform && !['android', 'ios'].includes(platform)) {
+            return { status: 'timeout', error: { code: 'PLATFORM_NOT_SUPPORTED', message: `Unsupported platform: ${platform}` }, metrics: { latency_ms: Date.now() - overallStart, poll_count: 0, attempts: 0 } };
+        }
+        const effectivePoll = Math.max(50, Math.min(poll_interval_ms || 300, 2000));
+        const maxAttempts = (retry && retry.max_attempts) ? Math.max(1, retry.max_attempts) : 1;
+        const backoff = (retry && retry.backoff_ms) ? Math.max(0, retry.backoff_ms) : 0;
+        let attempts = 0;
+        let totalPollCount = 0;
+        // Precompute normalized selector values and helpers (constant across polls)
+        const normalize = (s) => (s === null || s === undefined) ? '' : String(s).toLowerCase().trim();
+        const containsFlag = !!selector.contains;
+        const selText = normalize(selector.text);
+        const selRid = normalize(selector.resource_id);
+        const selAid = normalize(selector.accessibility_id);
+        try {
+            while (attempts < maxAttempts) {
+                attempts++;
+                const attemptStart = Date.now();
+                const deadline = attemptStart + (timeout_ms || 0);
+                while (Date.now() <= deadline) {
+                    totalPollCount++;
+                    try {
+                        const tree = await ToolsObserve.getUITreeHandler({ platform, deviceId });
+                        const elements = (tree && Array.isArray(tree.elements)) ? tree.elements : [];
+                        const matches = [];
+                        for (let i = 0; i < elements.length; i++) {
+                            const el = elements[i];
+                            let ok = true;
+                            // text
+                            if (selector.text !== undefined && selector.text !== null) {
+                                const val = normalize(el.text || el.label || el.value || '');
+                                if (containsFlag) {
+                                    if (!val.includes(selText))
+                                        ok = false;
+                                }
+                                else {
+                                    if (val !== selText)
+                                        ok = false;
+                                }
+                            }
+                            // resource_id
+                            if (ok && selector.resource_id !== undefined && selector.resource_id !== null) {
+                                const rid = normalize(el.resourceId || el.resourceID || el.id || '');
+                                if (containsFlag) {
+                                    if (!rid.includes(selRid))
+                                        ok = false;
+                                }
+                                else {
+                                    if (rid !== selRid)
+                                        ok = false;
+                                }
+                            }
+                            // accessibility_id
+                            if (ok && selector.accessibility_id !== undefined && selector.accessibility_id !== null) {
+                                const aid = normalize(el.contentDescription || el.contentDesc || el.accessibilityLabel || el.label || '');
+                                if (containsFlag) {
+                                    if (!aid.includes(selAid))
+                                        ok = false;
+                                }
+                                else {
+                                    if (aid !== selAid)
+                                        ok = false;
+                                }
+                            }
+                            if (ok)
+                                matches.push({ el, idx: i });
+                        }
+                        // Evaluate condition
+                        const matchedCount = matches.length;
+                        const pickIndexProvided = (match && typeof match.index === 'number');
+                        const pickIndex = pickIndexProvided ? Number(match.index) : 0;
+                        let chosen = null;
+                        if (matches.length === 0) {
+                            chosen = null;
+                        }
+                        else if (pickIndexProvided) {
+                            // If a specific index is requested but out of bounds, treat as not matched for this poll (deterministic)
+                            if (pickIndex >= 0 && pickIndex < matches.length)
+                                chosen = matches[pickIndex];
+                            else
+                                chosen = null;
+                        }
+                        else {
+                            chosen = matches[0];
+                        }
+                        let conditionMet = false;
+                        if (condition === 'exists') {
+                            // when an index is specified, existence requires that specific index be present
+                            conditionMet = pickIndexProvided ? (chosen !== null) : (matchedCount >= 1);
+                        }
+                        else if (condition === 'not_exists') {
+                            // when an index is specified, not_exists is true if that index is absent
+                            conditionMet = pickIndexProvided ? (chosen === null) : (matchedCount === 0);
+                        }
+                        else if (condition === 'visible') {
+                            if (chosen) {
+                                const b = chosen.el.bounds;
+                                const visibleFlag = !!chosen.el.visible && Array.isArray(b) && b.length >= 4 && (b[2] > b[0] && b[3] > b[1]);
+                                conditionMet = visibleFlag;
+                            }
+                            else
+                                conditionMet = false;
+                        }
+                        else if (condition === 'clickable') {
+                            if (chosen) {
+                                const b = chosen.el.bounds;
+                                const visibleFlag = !!chosen.el.visible && Array.isArray(b) && b.length >= 4 && (b[2] > b[0] && b[3] > b[1]);
+                                const enabled = !!chosen.el.enabled;
+                                const clickable = !!chosen.el.clickable || !!chosen.el._interactable;
+                                conditionMet = visibleFlag && enabled && clickable;
+                            }
+                            else
+                                conditionMet = false;
+                        }
+                        if (conditionMet) {
+                            const now = Date.now();
+                            const latency_ms = now - overallStart;
+                            // Build element output per spec
+                            const outEl = chosen ? {
+                                text: chosen.el.text ?? null,
+                                resource_id: chosen.el.resourceId ?? chosen.el.resourceID ?? chosen.el.id ?? null,
+                                accessibility_id: chosen.el.contentDescription ?? chosen.el.contentDesc ?? chosen.el.accessibilityLabel ?? chosen.el.label ?? null,
+                                class: chosen.el.type ?? chosen.el.class ?? null,
+                                bounds: Array.isArray(chosen.el.bounds) && chosen.el.bounds.length >= 4 ? chosen.el.bounds : null,
+                                index: chosen.idx
+                            } : null;
+                            return {
+                                status: 'success',
+                                matched: matchedCount,
+                                element: outEl,
+                                metrics: { latency_ms, poll_count: totalPollCount, attempts }
+                            };
+                        }
+                    }
+                    catch (e) {
+                        // Non-fatal per-poll error; record and continue
+                        console.warn('waitForUI: poll error (non-fatal):', e instanceof Error ? e.message : String(e));
+                    }
+                    // Sleep until next poll
+                    await new Promise(r => setTimeout(r, effectivePoll || 50));
+                }
+                // Attempt timed out; if more attempts allowed, backoff then retry
+                if (attempts < maxAttempts) {
+                    if (backoff > 0)
+                        await new Promise(r => setTimeout(r, backoff));
+                    continue;
+                }
+                // Final failure for this call
+                const elapsed = Date.now() - overallStart;
+                return {
+                    status: 'timeout',
+                    error: { code: 'ELEMENT_NOT_FOUND', message: `Condition ${condition} not satisfied within timeout` },
+                    metrics: { latency_ms: elapsed, poll_count: totalPollCount, attempts }
+                };
+            }
+        }
+        catch (err) {
+            const elapsed = Date.now() - overallStart;
+            return { status: 'timeout', error: { code: 'INTERNAL_ERROR', message: err instanceof Error ? err.message : String(err) }, metrics: { latency_ms: elapsed, poll_count: totalPollCount, attempts } };
+        }
+    }
+    // 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();
@@ -275,7 +466,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 +547,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

@@ -80,27 +80,104 @@ 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));
+            const source = pidArg ? 'pid' : (appId ? 'package' : 'broad');
+            const meta = { pidArg, appIdProvided: !!appId, filters: { tag, level, contains, since_seconds, limit: effectiveLimit }, pidExplicit: !!pid };
+            return { device: deviceInfo, logs: limited, logCount: limited.length, source, meta };
         }
         catch (e) {
             console.error("Error fetching logs:", e);
-            return { device: deviceInfo, logs: [], logCount: 0 };
+            return { device: deviceInfo, logs: [], logCount: 0, source: 'broad', meta: { error: e instanceof Error ? e.message : String(e) } };
         }
     }
     async captureScreen(deviceId) {

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, source: response.source, meta: response.meta, error: { code: 'LOGS_UNAVAILABLE', message: 'No logs match filters' } };
+            return { device: response.device, logs, crashLines, logCount: response.logCount, source: response.source, meta: response.meta };
         }
         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, source: resp.source, meta: resp.meta, error: { code: 'LOGS_UNAVAILABLE', message: 'No logs match filters' } };
+            return { device: resp.device, logs, crashLines, logCount: resp.logCount, source: resp.source, meta: resp.meta };
         }
     }
     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

@@ -88,20 +88,156 @@ 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');
+        }
+        let processNameUsed = undefined;
         if (appId) {
             validateBundleId(appId);
-            args.push('--predicate', `subsystem contains "${appId}" or process == "${appId}"`);
+            // prefer matching the simple process name (last segment of bundle id), but also match full bundle id in subsystem
+            const parts = appId.split('.');
+            const simpleName = parts[parts.length - 1];
+            processNameUsed = simpleName;
+            // predicate: match process by simple name or full bundle id, or subsystem contains bundle id
+            args.push('--predicate', `process == "${simpleName}" or process == "${appId}" or subsystem contains "${appId}"`);
+        }
+        else if (tag) {
+            // predicate by subsystem/category
+            args.push('--predicate', `subsystem contains "${tag}"`);
+        }
+        try {
+            // Attempt pid detection if appId provided and no explicit pid supplied — prefer process name derived from bundle id
+            let detectedPid = null;
+            if (appId && !pid) {
+                const parts = appId.split('.');
+                const simpleName = parts[parts.length - 1];
+                try {
+                    const pgrepRes = await execCommand(['simctl', 'spawn', deviceId, 'pgrep', '-f', simpleName], deviceId);
+                    const out = pgrepRes && pgrepRes.output ? pgrepRes.output.trim() : '';
+                    const firstLine = out.split(/\r?\n/).find(Boolean);
+                    if (firstLine) {
+                        const n = Number(firstLine.trim());
+                        if (!isNaN(n) && n > 0)
+                            detectedPid = n;
+                    }
+                }
+                catch {
+                    // ignore pgrep failures — we'll fall back to process/bundle matching
+                }
+            }
+            const effectivePid = pid || detectedPid || null;
+            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 (use detected/effective pid if available)
+            const pidToFilter = effectivePid;
+            if (pidToFilter)
+                filtered = filtered.filter(e => e.pid === pidToFilter);
+            // 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)) || (e.message && processNameUsed && e.message.includes(processNameUsed)));
+                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 source = pidToFilter ? 'pid' : (appId ? 'process' : 'broad');
+            const meta = { appIdProvided: !!appId, processNameUsed: processNameUsed || null, detectedPid: detectedPid || null, filters: { tag, level, contains, since_seconds, limit: effectiveLimit }, pidExplicit: !!pid };
+            const limited = filtered.slice(-Math.max(0, effectiveLimit));
+            return { device, logs: limited, logCount: limited.length, source, meta };
+        }
+        catch (err) {
+            console.error('iOS getLogs failed:', err);
+            const device = await getIOSDeviceMetadata(deviceId);
+            return { device, logs: [], logCount: 0, source: 'broad', meta: { error: err instanceof Error ? err.message : String(err) } };
         }
-        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);
@@ -275,7 +411,8 @@ export class iOSObserve {
     }
     async startLogStream(bundleId, deviceId = 'booted', sessionId = 'default') {
         try {
-            const predicate = `process == "${bundleId}" or subsystem contains "${bundleId}"`;
+            const simple = bundleId.split('.').pop() || bundleId;
+            const predicate = `process == "${simple}" or process == "${bundleId}" or subsystem contains "${bundleId}"`;
             if (iosActiveLogStreams.has(sessionId)) {
                 try {
                     iosActiveLogStreams.get(sessionId).proc.kill();