mobile-debug-mcp 0.10.0 → 0.12.0

package/src/android/interact.ts

@@ -1,11 +1,6 @@
-import { StartAppResponse, TerminateAppResponse, RestartAppResponse, ResetAppDataResponse, WaitForElementResponse, TapResponse, SwipeResponse, TypeTextResponse, PressBackResponse } from "../types.js"
-import { execAdb, getAndroidDeviceMetadata, getDeviceInfo, spawnAdb } from "./utils.js"
-import { detectJavaHome } from "../utils/java.js"
+import { WaitForElementResponse, TapResponse, SwipeResponse, TypeTextResponse, PressBackResponse } from "../types.js"
+import { execAdb, getAndroidDeviceMetadata, getDeviceInfo } from "./utils.js"
 import { AndroidObserve } from "./observe.js"
-import { promises as fs } from "fs"
-import { spawn } from "child_process"
-import path from "path"
-import { existsSync } from "fs"
 
 
 export class AndroidInteract {
@@ -93,152 +88,4 @@ export class AndroidInteract {
     }
   }
 
-  async installApp(apkPath: string, deviceId?: string): Promise<import("../types.js").InstallAppResponse> {
-    const metadata = await getAndroidDeviceMetadata("", deviceId)
-    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
-
-    // Helper to recursively find first APK under a directory
-    async function findApk(dir: string): Promise<string | undefined> {
-      const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => [])
-      for (const e of entries) {
-        const full = path.join(dir, e.name)
-        if (e.isDirectory()) {
-          const found = await findApk(full)
-          if (found) return found
-        } else if (e.isFile() && full.endsWith('.apk')) {
-          return full
-        }
-      }
-      return undefined
-    }
-
-    try {
-      let apkToInstall = apkPath
-
-      // If a directory is provided, attempt to build via Gradle
-      const stat = await fs.stat(apkPath).catch(() => null)
-      if (stat && stat.isDirectory()) {
-        const gradlewPath = path.join(apkPath, 'gradlew')
-        const gradleCmd = existsSync(gradlewPath) ? './gradlew' : 'gradle'
-
-        await new Promise<void>(async (resolve, reject) => {
-          // Auto-detect and set JAVA_HOME (prefer JDK 17) so builds don't require manual environment setup
-          const detectedJavaHome = await detectJavaHome().catch(() => undefined)
-          const env = Object.assign({}, process.env)
-          if (detectedJavaHome) {
-            // Override existing JAVA_HOME if detection found a preferably compatible JDK (e.g., JDK 17).
-            if (env.JAVA_HOME !== detectedJavaHome) {
-              env.JAVA_HOME = detectedJavaHome
-              // Also ensure the JDK bin is on PATH so tools like jlink/javac are resolved from the detected JDK
-              env.PATH = `${path.join(detectedJavaHome, 'bin')}${path.delimiter}${env.PATH || ''}`
-              console.debug('[android] Overriding JAVA_HOME with detected path:', detectedJavaHome)
-            }
-          }
-
-          // Sanitize environment so user shell init scripts are less likely to override our JAVA_HOME.
-          try {
-            // Remove obvious shell profile hints; avoid touching SDKMAN symlinks or on-disk state.
-            delete env.SHELL
-          } catch {}
-
-          // If we detected a compatible JDK, instruct Gradle to use it and avoid daemon reuse
-          // Prepare gradle invocation
-          const gradleArgs = ['assembleDebug']
-          if (detectedJavaHome) {
-            gradleArgs.push(`-Dorg.gradle.java.home=${detectedJavaHome}`)
-            gradleArgs.push('--no-daemon')
-            env.GRADLE_JAVA_HOME = detectedJavaHome
-          }
-
-          // Prefer invoking the wrapper directly without a shell to avoid user profile shims (sdkman) re-setting JAVA_HOME
-          const wrapperPath = path.join(apkPath, 'gradlew')
-          const useWrapper = existsSync(wrapperPath)
-          const execCmd = useWrapper ? wrapperPath : gradleCmd
-          const spawnOpts: any = { cwd: apkPath, env }
-          // When using wrapper, ensure it's executable and invoke directly (no shell)
-          if (useWrapper) {
-            // Ensure the wrapper is executable; swallow errors from chmod (best-effort).
-            await fs.chmod(wrapperPath, 0o755).catch(() => {})
-            spawnOpts.shell = false
-          } else {
-            // if using system 'gradle' allow shell to resolve platform PATH
-            spawnOpts.shell = true
-          }
-
-          const proc = spawn(execCmd, gradleArgs, spawnOpts)
-          let stderr = ''
-          proc.stderr?.on('data', d => stderr += d.toString())
-          proc.on('close', code => {
-            if (code === 0) resolve()
-            else reject(new Error(stderr || `Gradle build failed with code ${code}`))
-          })
-          proc.on('error', err => reject(err))
-        })
-
-        const built = await findApk(apkPath)
-        if (!built) throw new Error('Could not locate built APK after running Gradle')
-        apkToInstall = built
-      }
-
-      // Try normal adb install with streaming attempt
-      try {
-        const res = await spawnAdb(['install', '-r', apkToInstall], deviceId)
-        if (res.code === 0) {
-          return { device: deviceInfo, installed: true, output: res.stdout }
-        }
-        // fallthrough to fallback
-      } catch (e) {
-        // Log and continue to fallback
-        console.debug('[android] adb install failed, attempting push+pm fallback:', e instanceof Error ? e.message : String(e))
-      }
-
-      // Fallback: push APK to device and use pm install -r
-      const basename = path.basename(apkToInstall)
-      const remotePath = `/data/local/tmp/${basename}`
-      await execAdb(['push', apkToInstall, remotePath], deviceId)
-      const pmOut = await execAdb(['shell', 'pm', 'install', '-r', remotePath], deviceId)
-      // cleanup remote file
-      try { await execAdb(['shell', 'rm', remotePath], deviceId) } catch {}
-      return { device: deviceInfo, installed: true, output: pmOut }
-    } catch (e) {
-      return { device: deviceInfo, installed: false, error: e instanceof Error ? e.message : String(e) }
-    }
-  }
-
-  async startApp(appId: string, deviceId?: string): Promise<StartAppResponse> {
-    const metadata = await getAndroidDeviceMetadata(appId, deviceId)
-    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
-    
-    await execAdb(['shell', 'monkey', '-p', appId, '-c', 'android.intent.category.LAUNCHER', '1'], deviceId)
-    
-    return { device: deviceInfo, appStarted: true, launchTimeMs: 1000 }
-  }
-
-  async terminateApp(appId: string, deviceId?: string): Promise<TerminateAppResponse> {
-    const metadata = await getAndroidDeviceMetadata(appId, deviceId)
-    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
-
-    await execAdb(['shell', 'am', 'force-stop', appId], deviceId)
-    
-    return { device: deviceInfo, appTerminated: true }
-  }
-
-  async restartApp(appId: string, deviceId?: string): Promise<RestartAppResponse> {
-    await this.terminateApp(appId, deviceId)
-    const startResult = await this.startApp(appId, deviceId)
-    return {
-      device: startResult.device,
-      appRestarted: startResult.appStarted,
-      launchTimeMs: startResult.launchTimeMs
-    }
-  }
-
-  async resetAppData(appId: string, deviceId?: string): Promise<ResetAppDataResponse> {
-    const metadata = await getAndroidDeviceMetadata(appId, deviceId)
-    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
-
-    const output = await execAdb(['shell', 'pm', 'clear', appId], deviceId)
-    
-    return { device: deviceInfo, dataCleared: output === 'Success' }
-  }
 }

package/src/android/manage.ts

@@ -0,0 +1,157 @@
+import { promises as fs } from 'fs'
+import { spawn } from 'child_process'
+import path from 'path'
+import { existsSync } from 'fs'
+import { execAdb, spawnAdb, getAndroidDeviceMetadata, getDeviceInfo, findApk } from './utils.js'
+import { execAdbWithDiagnostics } from './diagnostics.js'
+import { detectJavaHome } from '../utils/java.js'
+import { InstallAppResponse, StartAppResponse, TerminateAppResponse, RestartAppResponse, ResetAppDataResponse } from '../types.js'
+
+export class AndroidManage {
+  async build(projectPath: string, _variant?: string): Promise<{ artifactPath: string, output?: string } | { error: string }> {
+    void _variant
+    try {
+      // Always use the shared prepareGradle utility for consistent env/setup
+      const { execCmd, gradleArgs, spawnOpts } = await (await import('./utils.js')).prepareGradle(projectPath)
+      await new Promise<void>((resolve, reject) => {
+        const proc = spawn(execCmd, gradleArgs, spawnOpts)
+        let stderr = ''
+        proc.stderr?.on('data', d => stderr += d.toString())
+        proc.on('close', code => {
+          if (code === 0) resolve()
+          else reject(new Error(stderr || `Gradle failed with code ${code}`))
+        })
+        proc.on('error', err => reject(err))
+      })
+    
+      const apk = await findApk(projectPath)
+      if (!apk) return { error: 'Could not find APK after build' }
+      return { artifactPath: apk }
+    } catch (e) {
+      return { error: e instanceof Error ? e.message : String(e) }
+    }
+  }
+
+  async installApp(apkPath: string, deviceId?: string): Promise<InstallAppResponse> {
+    const metadata = await getAndroidDeviceMetadata('', deviceId)
+    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
+
+    let apkToInstall: string = apkPath
+    try {
+      const stat = await fs.stat(apkPath).catch(() => null)
+      if (stat && stat.isDirectory()) {
+        const detectedJavaHome = await detectJavaHome().catch(() => undefined)
+        const env = Object.assign({}, process.env)
+        if (detectedJavaHome) {
+          if (env.JAVA_HOME !== detectedJavaHome) {
+            env.JAVA_HOME = detectedJavaHome
+            env.PATH = `${path.join(detectedJavaHome, 'bin')}${path.delimiter}${env.PATH || ''}`
+            console.debug('[android-run] Overriding JAVA_HOME with detected path:', detectedJavaHome)
+          }
+        }
+        try { delete env.SHELL } catch {}
+
+        const gradleArgs = ['assembleDebug']
+        if (detectedJavaHome) {
+          gradleArgs.push(`-Dorg.gradle.java.home=${detectedJavaHome}`)
+          gradleArgs.push('--no-daemon')
+          env.GRADLE_JAVA_HOME = detectedJavaHome
+        }
+
+        const wrapperPath = path.join(apkPath, 'gradlew')
+        const useWrapper = existsSync(wrapperPath)
+        const execCmd = useWrapper ? wrapperPath : 'gradle'
+        const spawnOpts: any = { cwd: apkPath, env }
+        if (useWrapper) {
+          await fs.chmod(wrapperPath, 0o755).catch(() => {})
+          spawnOpts.shell = false
+        } else spawnOpts.shell = true
+
+        const proc = spawn(execCmd, gradleArgs, spawnOpts)
+        let stderr = ''
+        await new Promise<void>((resolve, reject) => {
+          proc.stderr?.on('data', d => stderr += d.toString())
+          proc.on('close', code => {
+            if (code === 0) resolve()
+            else reject(new Error(stderr || `Gradle build failed with code ${code}`))
+          })
+          proc.on('error', err => reject(err))
+        })
+
+        const built = await findApk(apkPath)
+        if (!built) throw new Error('Could not locate built APK after running Gradle')
+        apkToInstall = built
+      }
+
+      try {
+        const res = await spawnAdb(['install', '-r', apkToInstall], deviceId)
+        if (res.code === 0) {
+          return { device: deviceInfo, installed: true, output: res.stdout }
+        }
+      } catch (e) {
+        console.debug('[android-run] adb install failed, attempting push+pm fallback:', e instanceof Error ? e.message : String(e))
+      }
+
+      const basename = path.basename(apkToInstall)
+      const remotePath = `/data/local/tmp/${basename}`
+      await execAdb(['push', apkToInstall, remotePath], deviceId)
+      const pmOut = await execAdb(['shell', 'pm', 'install', '-r', remotePath], deviceId)
+      try { await execAdb(['shell', 'rm', remotePath], deviceId) } catch {}
+      return { device: deviceInfo, installed: true, output: pmOut }
+    } catch (e) {
+      // gather diagnostics for attempted adb operations
+      const basename = path.basename(apkToInstall)
+      const remotePath = `/data/local/tmp/${basename}`
+      const installDiag = execAdbWithDiagnostics(['install', '-r', apkToInstall], deviceId)
+      const pushDiag = execAdbWithDiagnostics(['push', apkToInstall, remotePath], deviceId)
+      const pmDiag = execAdbWithDiagnostics(['shell', 'pm', 'install', '-r', remotePath], deviceId)
+      return { device: deviceInfo, installed: false, error: e instanceof Error ? e.message : String(e), diagnostics: { installDiag, pushDiag, pmDiag } }
+    }
+  }
+
+  async startApp(appId: string, deviceId?: string): Promise<StartAppResponse> {
+    const metadata = await getAndroidDeviceMetadata(appId, deviceId)
+    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
+    try {
+      await execAdb(['shell', 'monkey', '-p', appId, '-c', 'android.intent.category.LAUNCHER', '1'], deviceId)
+      return { device: deviceInfo, appStarted: true, launchTimeMs: 1000 }
+    } catch (e:any) {
+      const diag = execAdbWithDiagnostics(['shell', 'monkey', '-p', appId, '-c', 'android.intent.category.LAUNCHER', '1'], deviceId)
+      return { device: deviceInfo, appStarted: false, launchTimeMs: 0, error: e instanceof Error ? e.message : String(e), diagnostics: diag }
+    }
+  }
+
+  async terminateApp(appId: string, deviceId?: string): Promise<TerminateAppResponse> {
+    const metadata = await getAndroidDeviceMetadata(appId, deviceId)
+    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
+    try {
+      await execAdb(['shell', 'am', 'force-stop', appId], deviceId)
+      return { device: deviceInfo, appTerminated: true }
+    } catch (e:any) {
+      const diag = execAdbWithDiagnostics(['shell', 'am', 'force-stop', appId], deviceId)
+      return { device: deviceInfo, appTerminated: false, error: e instanceof Error ? e.message : String(e), diagnostics: diag }
+    }
+  }
+
+  async restartApp(appId: string, deviceId?: string): Promise<RestartAppResponse> {
+    await this.terminateApp(appId, deviceId)
+    const startResult = await this.startApp(appId, deviceId)
+    return {
+      device: startResult.device,
+      appRestarted: startResult.appStarted,
+      launchTimeMs: startResult.launchTimeMs
+    }
+  }
+
+  async resetAppData(appId: string, deviceId?: string): Promise<ResetAppDataResponse> {
+    const metadata = await getAndroidDeviceMetadata(appId, deviceId)
+    const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
+    try {
+      const output = await execAdb(['shell', 'pm', 'clear', appId], deviceId)
+      return { device: deviceInfo, dataCleared: output === 'Success' }
+    } catch (e:any) {
+      const diag = execAdbWithDiagnostics(['shell', 'pm', 'clear', appId], deviceId)
+      return { device: deviceInfo, dataCleared: false, error: e instanceof Error ? e.message : String(e), diagnostics: diag }
+    }
+  }
+}

package/src/android/observe.ts

@@ -1,104 +1,14 @@
 import { spawn } from "child_process"
 import { XMLParser } from "fast-xml-parser"
 import { GetLogsResponse, CaptureAndroidScreenResponse, GetUITreeResponse, GetCurrentScreenResponse, UIElement, DeviceInfo } from "../types.js"
-import { ADB, execAdb, getAndroidDeviceMetadata, getDeviceInfo } from "./utils.js"
+import { getAdbCmd, execAdb, getAndroidDeviceMetadata, getDeviceInfo, delay, getScreenResolution, traverseNode, parseLogLine } from "./utils.js"
+import { createWriteStream } from "fs"
+import { promises as fsPromises } from "fs"
+import path from "path"
 
-// --- Helper Functions Specific to Observe ---
+const activeLogStreams: Map<string, { proc: any, file: string }> = new Map()
 
-const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
 
-function parseBounds(bounds: string): [number, number, number, number] {
-  const match = bounds.match(/\[(\d+),(\d+)\]\[(\d+),(\d+)\]/);
-  if (match) {
-    return [parseInt(match[1]), parseInt(match[2]), parseInt(match[3]), parseInt(match[4])];
-  }
-  return [0, 0, 0, 0];
-}
-
-function getCenter(bounds: [number, number, number, number]): [number, number] {
-  const [x1, y1, x2, y2] = bounds;
-  return [Math.floor((x1 + x2) / 2), Math.floor((y1 + y2) / 2)];
-}
-
-async function getScreenResolution(deviceId?: string): Promise<{ width: number; height: number }> {
-  try {
-    const output = await execAdb(['shell', 'wm', 'size'], deviceId);
-    const match = output.match(/Physical size: (\d+)x(\d+)/);
-    if (match) {
-      return { width: parseInt(match[1]), height: parseInt(match[2]) };
-    }
-  } catch {
-    // ignore
-  }
-  return { width: 0, height: 0 };
-}
-
-function traverseNode(node: any, elements: UIElement[], parentIndex: number = -1, depth: number = 0): number {
-  if (!node) return -1;
-
-  let currentIndex = -1;
-
-  // Check if it's a valid node with attributes we care about
-  if (node['@_class']) {
-    const text = node['@_text'] || null;
-    const contentDescription = node['@_content-desc'] || null;
-    const clickable = node['@_clickable'] === 'true';
-    const bounds = parseBounds(node['@_bounds'] || '[0,0][0,0]');
-    
-    // Filtering Logic:
-    // Keep if clickable OR has visible text OR has content description
-    const isUseful = clickable || (text && text.length > 0) || (contentDescription && contentDescription.length > 0);
-
-    if (isUseful) {
-      const element: UIElement = {
-        text,
-        contentDescription,
-        type: node['@_class'] || 'unknown',
-        resourceId: node['@_resource-id'] || null,
-        clickable,
-        enabled: node['@_enabled'] === 'true',
-        visible: true, 
-        bounds,
-        center: getCenter(bounds),
-        depth
-      };
-      
-      if (parentIndex !== -1) {
-        element.parentId = parentIndex;
-      }
-      
-      elements.push(element);
-      currentIndex = elements.length - 1;
-    }
-  }
-
-  // If current node was skipped (not useful or no class), children inherit parentIndex
-  // If current node was added, children use currentIndex
-  const nextParentIndex = currentIndex !== -1 ? currentIndex : parentIndex;
-  const nextDepth = currentIndex !== -1 ? depth + 1 : depth; 
-  
-  const childrenIndices: number[] = [];
-
-  // Traverse children
-  if (node.node) {
-      if (Array.isArray(node.node)) {
-          node.node.forEach((child: any) => {
-            const childIndex = traverseNode(child, elements, nextParentIndex, nextDepth);
-            if (childIndex !== -1) childrenIndices.push(childIndex);
-          });
-      } else {
-          const childIndex = traverseNode(node.node, elements, nextParentIndex, nextDepth);
-          if (childIndex !== -1) childrenIndices.push(childIndex);
-      }
-  }
-  
-  // Update current element with children if it was added
-  if (currentIndex !== -1 && childrenIndices.length > 0) {
-      elements[currentIndex].children = childrenIndices;
-  }
-  
-  return currentIndex;
-}
 
 export class AndroidObserve {
   async getDeviceMetadata(appId: string, deviceId?: string): Promise<DeviceInfo> {
@@ -171,7 +81,7 @@ export class AndroidObserve {
         elements
       };
     } catch (e) {
-      const errorMessage = `Failed to get UI tree. ADB Path: '${ADB}'. Error: ${e instanceof Error ? e.message : String(e)}`;
+      const errorMessage = `Failed to get UI tree. ADB Path: '${getAdbCmd()}'. Error: ${e instanceof Error ? e.message : String(e)}`;
       console.error(errorMessage);
       return {
           device: deviceInfo,
@@ -226,7 +136,7 @@ export class AndroidObserve {
       const args = deviceId ? ['-s', deviceId, 'exec-out', 'screencap', '-p'] : ['exec-out', 'screencap', '-p'];
       
       // Using spawn for screencap as well to ensure consistent process handling
-      const child = spawn(ADB, args)
+      const child = spawn(getAdbCmd(), args)
       
       const chunks: Buffer[] = []
       let stderr = ''
@@ -357,4 +267,126 @@ export class AndroidObserve {
       };
     }
   }
+
+  async startLogStream(packageName: string, level: 'error' | 'warn' | 'info' | 'debug' = 'error', deviceId?: string, sessionId: string = 'default') {
+    try {
+      const pidOutput = await execAdb(['shell', 'pidof', packageName], deviceId).catch(() => '')
+      const pid = (pidOutput || '').trim()
+      if (!pid) return { success: false, error: 'app_not_running' }
+
+      const levelMap: Record<string, string> = { error: '*:E', warn: '*:W', info: '*:I', debug: '*:D' }
+      const filter = levelMap[level] || levelMap['error']
+
+      if (activeLogStreams.has(sessionId)) {
+        try { activeLogStreams.get(sessionId)!.proc.kill() } catch {}
+        activeLogStreams.delete(sessionId)
+      }
+
+      const args = ['logcat', `--pid=${pid}`, filter]
+      const proc = spawn(getAdbCmd(), args)
+
+      const tmpDir = process.env.TMPDIR || '/tmp'
+      const file = path.join(tmpDir, `mobile-debug-log-${sessionId}.ndjson`)
+      const stream = createWriteStream(file, { flags: 'a' })
+
+      proc.stdout.on('data', (chunk) => {
+        const text = chunk.toString()
+        const lines = text.split(/\r?\n/).filter(Boolean)
+        for (const l of lines) {
+          const entry = parseLogLine(l)
+          stream.write(JSON.stringify(entry) + '\n')
+        }
+      })
+
+      proc.stderr.on('data', (chunk) => {
+        const text = chunk.toString()
+        const lines = text.split(/\r?\n/).filter(Boolean)
+        for (const l of lines) {
+          const entry = { timestamp: '', level: 'E', tag: 'adb', message: l }
+          stream.write(JSON.stringify(entry) + '\n')
+        }
+      })
+
+      proc.on('close', () => {
+        stream.end()
+        activeLogStreams.delete(sessionId)
+      })
+
+      activeLogStreams.set(sessionId, { proc, file })
+      return { success: true, stream_started: true }
+    } catch (e) {
+      return { success: false, error: e instanceof Error ? e.message : String(e) }
+    }
+  }
+
+  async stopLogStream(sessionId: string = 'default') {
+    const entry = activeLogStreams.get(sessionId)
+    if (!entry) return { success: true }
+    try { entry.proc.kill() } catch {}
+    activeLogStreams.delete(sessionId)
+    return { success: true }
+  }
+
+  async readLogStream(sessionId: string = 'default', limit: number = 100, since?: string) {
+    // Prefer active stream if present, otherwise fall back to a well-known NDJSON file for the session
+    const entry = activeLogStreams.get(sessionId)
+    let file: string | undefined
+    if (entry && entry.file) file = entry.file
+    else {
+      const tmpDir = process.env.TMPDIR || '/tmp'
+      const candidate = path.join(tmpDir, `mobile-debug-log-${sessionId}.ndjson`)
+      file = candidate
+    }
+
+    try {
+      const data = await fsPromises.readFile(file, 'utf8').catch(() => '')
+      if (!data) return { entries: [], crash_summary: { crash_detected: false } }
+      const lines = data.split(/\r?\n/).filter(Boolean)
+
+      const parsed = lines.map(l => {
+        try {
+          const obj: any = JSON.parse(l)
+          if (typeof obj._iso === 'undefined') {
+            let iso: string | null = null
+            if (obj.timestamp) {
+              const d = new Date(obj.timestamp)
+              if (!isNaN(d.getTime())) iso = d.toISOString()
+            }
+            obj._iso = iso
+          }
+          if (typeof obj.crash === 'undefined') {
+            const msg = (obj.message || '').toString()
+            const exMatch = msg.match(/\b([A-Za-z0-9_$.]+Exception)\b/)
+            if (/FATAL EXCEPTION/i.test(msg) || exMatch) {
+              obj.crash = true
+              if (exMatch) obj.exception = exMatch[1]
+            } else {
+              obj.crash = false
+            }
+          }
+          return obj
+        } catch {
+          return { message: l, _iso: null, crash: false }
+        }
+      })
+
+      let filtered = parsed
+      if (since) {
+        let sinceMs: number | null = null
+        if (/^\d+$/.test(since)) sinceMs = Number(since)
+        else {
+          const sDate = new Date(since)
+          if (!isNaN(sDate.getTime())) sinceMs = sDate.getTime()
+        }
+        if (sinceMs !== null) filtered = parsed.filter(p => p._iso && (new Date(p._iso).getTime() >= sinceMs))
+      }
+
+      const entries = filtered.slice(-Math.max(0, limit))
+      const crashEntry = entries.find(e => e.crash)
+      const crash_summary = crashEntry ? { crash_detected: true, exception: crashEntry.exception, sample: crashEntry.message } : { crash_detected: false }
+      return { entries, crash_summary }
+    } catch {
+      return { entries: [], crash_summary: { crash_detected: false } }
+    }
+  }
 }