mobile-debug-mcp 0.21.1 → 0.21.3

package/src/observe/ios.ts

@@ -6,6 +6,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: number) => new Promise(resolve => setTimeout(resolve, ms));
 
@@ -120,20 +121,132 @@ export class iOSObserve {
     return getIOSDeviceMetadata(deviceId);
   }
 
-  async getLogs(appId?: string, deviceId: string = "booted"): Promise<GetLogsResponse> {
-    const args = ['simctl', 'spawn', deviceId, 'log', 'show', '--style', 'syslog', '--last', '1m']
+  async getLogs(filters: { appId?: string, deviceId?: string, pid?: number, tag?: string, level?: string, contains?: string, since_seconds?: number, limit?: number } = {}): Promise<GetLogsResponse> {
+    const { appId, deviceId = 'booted', pid, tag, level, contains, since_seconds, limit } = filters
+    const args: string[] = ['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}"`)
+    } else if (tag) {
+      // predicate by subsystem/category
+      args.push('--predicate', `subsystem contains "${tag}"`)
     }
-    
-    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,
+
+    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: string | null = 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: Record<string, string> = { '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: number | null = 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 }
     }
   }
 
@@ -146,13 +259,63 @@ export class iOSObserve {
       
       const buffer = await fs.readFile(tmpFile)
       const base64 = buffer.toString('base64')
-      
-      await fs.rm(tmpFile).catch(() => {})
 
+      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 as any).default ? (sharpModule as any).default : sharpModule;
+        const img = sharp(buffer);
+        const meta = await img.metadata().catch((err: any) => { console.error('sharp.metadata failed:', err); return {} as any });
+
+        // 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: Buffer | null = null;
+        let jpegBuf: Buffer | null = 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) {
       await fs.rm(tmpFile).catch(() => {})

package/src/server.ts

@@ -171,7 +171,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: {
@@ -187,9 +187,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"]
@@ -603,12 +609,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request: SchemaOutput<typ
 
 
     if (name === "get_logs") {
-      const { platform, appId, deviceId, lines } = args as any
-      const res = await ToolsObserve.getLogsHandler({ platform, appId, deviceId, lines })
+      const { platform, appId, deviceId, pid, tag, level, contains, since_seconds, limit, lines } = args as any
+      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) }
         ]
       }
     }
@@ -628,12 +635,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request: SchemaOutput<typ
     if (name === "capture_screenshot") {
       const { platform, deviceId } = args as any
       const res = await ToolsObserve.captureScreenshotHandler({ platform, deviceId })
-      return {
-        content: [
-          { type: 'text', text: JSON.stringify({ device: res.device, result: { resolution: (res as any).resolution } }, null, 2) },
-          { type: 'image', data: (res as any).screenshot, mimeType: 'image/png' }
-        ]
+      const mime = (res as any).screenshot_mime || 'image/png'
+      const content: any[] = [
+        { type: 'text', text: JSON.stringify({ device: res.device, result: { resolution: (res as any).resolution, mimeType: mime } }, null, 2) },
+        { type: 'image', data: (res as any).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 as any).screenshot_fallback) {
+        content.push({ type: 'text', text: JSON.stringify({ note: 'JPEG fallback included for compatibility', mimeType: (res as any).screenshot_fallback_mime || 'image/jpeg' }) })
+        content.push({ type: 'image', data: (res as any).screenshot_fallback, mimeType: (res as any).screenshot_fallback_mime || 'image/jpeg' })
       }
+      return { content }
     }
 
     if (name === "capture_debug_snapshot") {

package/src/types.ts

@@ -36,9 +36,17 @@ export interface ResetAppDataResponse {
   diagnostics?: any;
 }
 
+export interface StructuredLogEntry {
+  timestamp: string | null; // ISO string
+  level: string; // VERBOSE, DEBUG, INFO, WARN, ERROR
+  tag: string;
+  pid: number | null;
+  message: string;
+}
+
 export interface GetLogsResponse {
   device: DeviceInfo;
-  logs: string[];
+  logs: StructuredLogEntry[];
   logCount: number;
 }
 
@@ -50,6 +58,9 @@ export interface GetCrashResponse {
 export interface CaptureAndroidScreenResponse {
   device: DeviceInfo;
   screenshot: string; // base64 encoded string
+  screenshot_mime?: string; // e.g. image/webp, image/jpeg, image/png
+  screenshot_fallback?: string; // optional fallback base64 (e.g., jpeg)
+  screenshot_fallback_mime?: string;
   resolution: {
     width: number;
     height: number;
@@ -59,6 +70,9 @@ export interface CaptureAndroidScreenResponse {
 export interface CaptureIOSScreenshotResponse {
   device: DeviceInfo;
   screenshot: string; // base64 encoded string
+  screenshot_mime?: string; // e.g. image/webp, image/jpeg, image/png
+  screenshot_fallback?: string; // optional fallback base64 (e.g., jpeg)
+  screenshot_fallback_mime?: string;
   resolution: {
     width: number;
     height: number;

package/src/utils/cli/ios/run-ios-smoke.ts

@@ -17,7 +17,7 @@ async function main() {
     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')

package/src/utils/image.ts

@@ -0,0 +1,14 @@
+export function parsePngSize(buf: Buffer): { width: number; height: number } {
+  try {
+    if (!buf || buf.length < 24) return { width: 0, height: 0 };
+    // PNG signature + IHDR checks
+    if (buf.readUInt32BE(0) !== 0x89504e47 || buf.readUInt32BE(4) !== 0x0d0a1a0a) return { width: 0, height: 0 };
+    const ihdr = buf.toString('ascii', 12, 16);
+    if (ihdr !== 'IHDR') return { width: 0, height: 0 };
+    const width = buf.readUInt32BE(16);
+    const height = buf.readUInt32BE(20);
+    return { width, height };
+  } catch {
+    return { width: 0, height: 0 };
+  }
+}

package/test/helpers/run-get-logs.ts

@@ -0,0 +1,20 @@
+import { ToolsObserve } from '../../src/observe/index.js'
+import minimist from 'minimist'
+
+async function main() {
+  const args = minimist(process.argv.slice(2))
+  const platform = args.platform || args.p || 'android'
+  const id = args.id || args.device || args.deviceId || 'default'
+  const limit = typeof args.limit === 'number' ? args.limit : (typeof args.lines === 'number' ? args.lines : 50)
+
+  try {
+    const res = await ToolsObserve.getLogsHandler({ platform, id, limit })
+    console.log(JSON.stringify(res))
+    process.exit(0)
+  } catch (err: any) {
+    console.error(JSON.stringify({ error: { message: err.message || String(err) } }))
+    process.exit(2)
+  }
+}
+
+main()

package/test/observe/device/get_logs.android.smoke.ts

@@ -0,0 +1,35 @@
+import fs from 'fs'
+import { execSync } from 'child_process'
+
+function log(msg: string) { console.log(msg) }
+
+if (process.env.SKIP_DEVICE_TESTS === '1') {
+  log('SKIP_DEVICE_TESTS=1 detected - skipping android device smoke test')
+  process.exit(0)
+}
+
+// Ensure helper script exists
+const helperScript = 'test/helpers/run-get-logs.ts'
+if (!fs.existsSync(helperScript)) {
+  console.error(`Missing ${helperScript}. Run 'npm run build' first or ensure the helper exists.`)
+  process.exit(1)
+}
+
+try {
+  // Run the helper smoke script for android
+  const cmd = `tsx ${helperScript} --platform android --id default --limit 20`
+  const out = execSync(cmd, { encoding: 'utf8', maxBuffer: 10 * 1024 * 1024, timeout: 30000 })
+  const parsed = JSON.parse(out)
+
+  if (!parsed || !Array.isArray(parsed.logs)) throw new Error('Output missing logs array')
+  const count = parsed.count ?? parsed.logs.length
+  if (count !== parsed.logs.length) throw new Error('count mismatch')
+  if (parsed.logs.some((e: any) => !e.timestamp || !e.level || typeof e.message !== 'string')) throw new Error('log entry missing fields')
+
+  log('Android device smoke test: PASS')
+  process.exit(0)
+} catch (err: any) {
+  console.error('Android device smoke test: FAIL')
+  console.error(err && err.message ? err.message : err)
+  process.exit(2)
+}

package/test/observe/device/get_logs.ios.smoke.ts

@@ -0,0 +1,33 @@
+import fs from 'fs'
+import { execSync } from 'child_process'
+
+function log(msg: string) { console.log(msg) }
+
+if (process.env.SKIP_DEVICE_TESTS === '1') {
+  log('SKIP_DEVICE_TESTS=1 detected - skipping ios device smoke test')
+  process.exit(0)
+}
+
+const helperScript = 'test/helpers/run-get-logs.ts'
+if (!fs.existsSync(helperScript)) {
+  console.error(`Missing ${helperScript}. Run 'npm run build' first or ensure the helper exists.`)
+  process.exit(1)
+}
+
+try {
+  const cmd = `tsx ${helperScript} --platform ios --id booted --limit 20`
+  const out = execSync(cmd, { encoding: 'utf8', maxBuffer: 10 * 1024 * 1024, timeout: 30000 })
+  const parsed = JSON.parse(out)
+
+  if (!parsed || !Array.isArray(parsed.logs)) throw new Error('Output missing logs array')
+  const count = parsed.count ?? parsed.logs.length
+  if (count !== parsed.logs.length) throw new Error('count mismatch')
+  if (parsed.logs.some((e: any) => !e.timestamp || !e.level || typeof e.message !== 'string')) throw new Error('log entry missing fields')
+
+  log('iOS device smoke test: PASS')
+  process.exit(0)
+} catch (err: any) {
+  console.error('iOS device smoke test: FAIL')
+  console.error(err && err.message ? err.message : err)
+  process.exit(2)
+}

package/test/observe/unit/get_logs.test.ts

@@ -0,0 +1,58 @@
+import { StructuredLogEntry } from '../../../src/types.js'
+
+function assert(cond: boolean, msg?: string) { if (!cond) throw new Error(msg || 'Assertion failed') }
+
+function applyFilters(entries: StructuredLogEntry[], opts: { contains?: string, level?: string, tag?: string, pid?: number, since_seconds?: number, limit?: number }) {
+  let filtered = entries.slice()
+  if (opts.contains) filtered = filtered.filter(e => e.message && e.message.includes(opts.contains!))
+  if (opts.since_seconds) {
+    const sinceMs = Date.now() - (opts.since_seconds * 1000)
+    filtered = filtered.filter(e => e.timestamp && (new Date(e.timestamp).getTime() >= sinceMs))
+  }
+  if (opts.level) filtered = filtered.filter(e => e.level && e.level.toUpperCase() === opts.level!.toUpperCase())
+  if (opts.tag) filtered = filtered.filter(e => e.tag && e.tag.includes(opts.tag!))
+  if (typeof opts.pid === 'number') filtered = filtered.filter(e => e.pid === opts.pid)
+  // oldest -> newest
+  filtered.sort((a,b) => (a.timestamp? new Date(a.timestamp).getTime():0) - (b.timestamp? new Date(b.timestamp).getTime():0))
+  const lim = typeof opts.limit === 'number' && opts.limit > 0 ? opts.limit : 50
+  return filtered.slice(-Math.max(0, lim))
+}
+
+function run() {
+  const now = Date.now()
+  const entries: StructuredLogEntry[] = [
+    { timestamp: new Date(now - 60000).toISOString(), level: 'INFO', tag: 'A', pid: 123, message: 'startup complete' },
+    { timestamp: new Date(now - 45000).toISOString(), level: 'WARN', tag: 'B', pid: 124, message: 'slow response' },
+    { timestamp: new Date(now - 30000).toISOString(), level: 'ERROR', tag: 'A', pid: 123, message: 'Unhandled exception' },
+    { timestamp: new Date(now - 15000).toISOString(), level: 'DEBUG', tag: 'C', pid: 125, message: 'debug info' },
+    { timestamp: new Date(now - 5000).toISOString(), level: 'INFO', tag: 'A', pid: 123, message: 'user action happened' }
+  ]
+
+  // contains filter
+  const c1 = applyFilters(entries, { contains: 'user' })
+  assert(c1.length === 1 && c1[0].message.includes('user'), 'contains filter failed')
+
+  // level filter
+  const e1 = applyFilters(entries, { level: 'ERROR' })
+  assert(e1.length === 1 && e1[0].level === 'ERROR', 'level filter failed')
+
+  // tag filter
+  const t1 = applyFilters(entries, { tag: 'A' })
+  assert(t1.length === 3, 'tag filter failed')
+
+  // pid filter
+  const p1 = applyFilters(entries, { pid: 123 })
+  assert(p1.length === 3, 'pid filter failed')
+
+  // since_seconds filter (last 20s) should include last two entries
+  const s1 = applyFilters(entries, { since_seconds: 20 })
+  if (s1.length !== 2) throw new Error('since_seconds filter expected 2 entries, got ' + s1.length)
+
+  // limit
+  const l1 = applyFilters(entries, { limit: 2 })
+  assert(l1.length === 2 && l1[0].timestamp <= l1[1].timestamp, 'limit or ordering failed')
+
+  console.log('get_logs unit tests passed')
+}
+
+run()