mobile-debug-mcp 0.16.0 → 0.17.0

package/dist/observe/index.js

@@ -82,4 +82,107 @@ export class ToolsObserve {
         // Both observes implement getScreenFingerprint
         return await observe.getScreenFingerprint(resolved.id);
     }
+    static async captureDebugSnapshotHandler({ reason, includeLogs = true, logLines = 200, platform, appId, deviceId, sessionId } = {}) {
+        const timestamp = Date.now();
+        const out = { timestamp, reason: reason || '', activity: null, fingerprint: null, screenshot: null, ui_tree: null, logs: [] };
+        // Parallel fetches for performance: screenshot, current screen, fingerprint, ui tree, and log stream/get logs
+        const sid = sessionId || 'default';
+        const tasks = {
+            screenshot: ToolsObserve.captureScreenshotHandler({ platform, deviceId }),
+            currentScreen: (!platform || platform === 'android') ? ToolsObserve.getCurrentScreenHandler({ deviceId }) : Promise.resolve(null),
+            fingerprint: ToolsObserve.getScreenFingerprintHandler({ platform, deviceId }),
+            uiTree: ToolsObserve.getUITreeHandler({ platform, deviceId }),
+            readLogStream: includeLogs ? ToolsObserve.readLogStreamHandler({ platform, sessionId: sid, limit: logLines }) : Promise.resolve({ entries: [] }),
+        };
+        const results = await Promise.allSettled(Object.values(tasks));
+        const keys = Object.keys(tasks);
+        // Map results back to keys
+        for (let i = 0; i < results.length; i++) {
+            const key = keys[i];
+            const res = results[i];
+            if (res.status === 'fulfilled') {
+                const val = res.value;
+                if (key === 'screenshot') {
+                    out.screenshot = val && val.screenshot ? val.screenshot : null;
+                }
+                else if (key === 'currentScreen') {
+                    out.activity = val && ((val.activity || val.shortActivity)) ? (val.activity || val.shortActivity) : out.activity || '';
+                }
+                else if (key === 'fingerprint') {
+                    if (val && val.fingerprint)
+                        out.fingerprint = val.fingerprint;
+                    if (val && val.activity)
+                        out.activity = out.activity || val.activity;
+                    if (val && val.error)
+                        out.fingerprint_error = val.error;
+                }
+                else if (key === 'uiTree') {
+                    out.ui_tree = val;
+                    if (val && val.error)
+                        out.ui_tree_error = val.error;
+                }
+                else if (key === 'readLogStream') {
+                    // handle below after evaluating fallback
+                    // temporarily attach to out._streamEntries
+                    out._streamEntries = val && val.entries ? val.entries : [];
+                }
+            }
+            else {
+                const errMsg = res.reason instanceof Error ? res.reason.message : String(res.reason);
+                if (key === 'screenshot')
+                    out.screenshot_error = errMsg;
+                if (key === 'currentScreen')
+                    out.activity_error = errMsg;
+                if (key === 'fingerprint') {
+                    out.fingerprint = null;
+                    out.fingerprint_error = errMsg;
+                }
+                if (key === 'uiTree') {
+                    out.ui_tree = null;
+                    out.ui_tree_error = errMsg;
+                }
+                if (key === 'readLogStream') {
+                    out._streamEntries = [];
+                    out.logs_error = errMsg;
+                }
+            }
+        }
+        // Logs: prefer stream entries, fallback to snapshot logs when empty
+        if (includeLogs) {
+            try {
+                let entries = Array.isArray(out._streamEntries) ? out._streamEntries : [];
+                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 };
+                    });
+                }
+                else {
+                    entries = entries.map(ent => {
+                        const msg = (ent && (ent.message || ent.msg)) ? (ent.message || ent.msg) : (typeof ent === 'string' ? ent : JSON.stringify(ent));
+                        const levelRaw = (ent && (ent.level || ent.levelName || ent._level)) ? (ent.level || ent.levelName || ent._level) : '';
+                        const level = (levelRaw && String(levelRaw)).toString().toUpperCase() || (/\bERROR\b/i.test(msg) ? 'ERROR' : /\bWARN\b/i.test(msg) ? 'WARN' : 'INFO');
+                        let tsNum = null;
+                        const maybeIso = ent && (ent._iso || ent.timestamp);
+                        if (maybeIso && typeof maybeIso === 'string') {
+                            const d = new Date(maybeIso);
+                            if (!isNaN(d.getTime()))
+                                tsNum = d.getTime();
+                        }
+                        return { timestamp: tsNum, level, message: msg };
+                    });
+                }
+                out.logs = entries;
+            }
+            catch (e) {
+                out.logs = [];
+                out.logs_error = e instanceof Error ? e.message : String(e);
+            }
+        }
+        // Clean up internal temporary field
+        delete out._streamEntries;
+        return out;
+    }
 }

package/dist/server.js

@@ -195,6 +195,22 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["platform"]
             }
         },
+        {
+            name: "capture_debug_snapshot",
+            description: "Capture a complete debug snapshot (screenshot, ui tree, activity, fingerprint, logs). Returns structured JSON.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    reason: { type: "string", description: "Optional reason for snapshot" },
+                    includeLogs: { type: "boolean", description: "Whether to include logs", default: true },
+                    logLines: { type: "number", description: "Maximum number of log lines to include", default: 200 },
+                    platform: { type: "string", enum: ["android", "ios"], description: "Optional platform override" },
+                    appId: { type: "string", description: "Optional appId to scope logs (package/bundle id)" },
+                    deviceId: { type: "string", description: "Optional device serial/udid" },
+                    sessionId: { type: "string", description: "Optional log stream session id to prefer" }
+                }
+            }
+        },
         {
             name: "start_log_stream",
             description: "Start streaming logs for a target application on Android or iOS. For Android this uses adb logcat --pid=<pid>; for iOS it streams `xcrun simctl spawn <device> log stream` with a predicate.",
@@ -556,6 +572,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 ]
             };
         }
+        if (name === "capture_debug_snapshot") {
+            const { reason, includeLogs, logLines, platform, appId, deviceId, sessionId } = args;
+            const res = await ToolsObserve.captureDebugSnapshotHandler({ reason, includeLogs, logLines, platform, appId, deviceId, sessionId });
+            return wrapResponse(res);
+        }
         if (name === "get_ui_tree") {
             const { platform, deviceId } = args;
             const res = await ToolsObserve.getUITreeHandler({ platform, deviceId });

package/docs/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 All notable changes to the **Mobile Debug MCP** project will be documented in this file.
 
+## [0.17.0]
+- Added `capture_debug_snapshot` observe tool: captures a full debugging snapshot including screenshot (base64), UI tree, current activity (Android), screen fingerprint, and recent logs (prefers active log stream, falls back to snapshot logs). Returns a single structured JSON object and includes per-part error fields for partial failures. Implemented as `ToolsObserve.captureDebugSnapshotHandler` and registered in the server.
+
 ## [0.16.0]
 - Added `wait_for_screen_change` interact tool: polls the platform-specific `get_screen_fingerprint` until it differs from a provided `previousFingerprint`, with configurable `timeoutMs` and `pollIntervalMs` and an optional stability confirmation poll to avoid reacting to transient UI flickers. Implemented at the interact layer and delegates fingerprinting to the observe implementations (Android/iOS).
 - Added unit tests covering immediate change, transient null fingerprints, stability confirmation and timeout behavior: `test/interact/unit/wait_for_screen_change.test.ts`.

package/docs/tools/observe.md

@@ -76,6 +76,50 @@ Response:
 
 ---
 
+## capture_debug_snapshot
+Capture a complete debug snapshot of the app state for diagnostics and post-mortem analysis.
+
+Input:
+
+```json
+{
+  "reason": "optional string describing why snapshot is taken",
+  "includeLogs": true,
+  "logLines": 200,
+  "platform": "android | ios",
+  "appId": "optional package/bundle id to scope logs",
+  "deviceId": "optional device serial/udid",
+  "sessionId": "optional log stream session id to prefer"
+}
+```
+
+Behavior:
+- Captures screenshot (base64), current activity (Android), screen fingerprint, full UI tree, and recent logs.
+- Prefers active log stream entries (read_log_stream) and falls back to get_logs when no active stream is available.
+- Returns partial data when components fail and includes per-part error fields (e.g. `screenshot_error`, `ui_tree_error`).
+- Caps logs to `logLines` entries and prefers recent entries.
+- Fast by default: does not wait for new logs and avoids long blocking operations.
+
+Response (example):
+
+```json
+{
+  "timestamp": 1710000000,
+  "reason": "Crash after tapping checkout",
+  "activity": "CheckoutActivity",
+  "fingerprint": "abc123",
+  "screenshot": "<base64 PNG string>",
+  "ui_tree": { ... },
+  "logs": [ { "timestamp": 1710000000, "level": "ERROR", "message": "NullPointerException at CheckoutViewModel" } ]
+}
+```
+
+Notes:
+- Useful immediately after detecting crashes or unexpected UI behaviour.
+- Do not expect perfect data during a crash; tool is designed to return best-effort context and include errors for failed parts.
+
+---
+
 ## get_screen_fingerprint
 Generate a stable fingerprint representing the visible screen. Useful for detecting navigation changes, preventing loops, and synchronisation.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobile-debug-mcp",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "MCP server for mobile app debugging (Android + iOS), with focus on security and reliability",
   "type": "module",
   "bin": {

package/src/interact/index.ts

@@ -5,6 +5,8 @@ export { AndroidInteract, iOSInteract };
 import { resolveTargetDevice } from '../utils/resolve-device.js'
 import { ToolsObserve } from '../observe/index.js'
 
+interface ScreenFingerprintResponse { fingerprint: string | null }
+
 export class ToolsInteract {
 
   private static async getInteractionService(platform?: 'android' | 'ios', deviceId?: string) {
@@ -51,8 +53,8 @@ export class ToolsInteract {
 
     while (Date.now() - start < timeoutMs) {
       try {
-        const res = await ToolsObserve.getScreenFingerprintHandler({ platform, deviceId })
-        const fp = (res as any)?.fingerprint ?? null
+        const res = await ToolsObserve.getScreenFingerprintHandler({ platform, deviceId }) as ScreenFingerprintResponse | null
+        const fp = res?.fingerprint ?? null
         if (fp === null || fp === undefined) {
           lastFingerprint = null
           await new Promise(resolve => setTimeout(resolve, pollIntervalMs))
@@ -64,9 +66,9 @@ export class ToolsInteract {
         if (fp !== previousFingerprint) {
           // Stability confirmation
           await new Promise(resolve => setTimeout(resolve, pollIntervalMs))
-          try {
-            const confirmRes = await ToolsObserve.getScreenFingerprintHandler({ platform, deviceId })
-            const confirmFp = (confirmRes as any)?.fingerprint ?? null
+              try {
+            const confirmRes = await ToolsObserve.getScreenFingerprintHandler({ platform, deviceId }) as ScreenFingerprintResponse | null
+            const confirmFp = confirmRes?.fingerprint ?? null
             if (confirmFp === fp) {
               return { success: true, newFingerprint: fp, elapsedMs: Date.now() - start }
             }

package/src/observe/index.ts

@@ -89,4 +89,92 @@ export class ToolsObserve {
     // Both observes implement getScreenFingerprint
     return await (observe as any).getScreenFingerprint(resolved.id)
   }
+
+  static async captureDebugSnapshotHandler({ reason, includeLogs = true, logLines = 200, platform, appId, deviceId, sessionId }: { reason?: string; includeLogs?: boolean; logLines?: number; platform?: 'android' | 'ios'; appId?: string; deviceId?: string; sessionId?: string } = {}) {
+    const timestamp = Date.now()
+    const out: any = { timestamp, reason: reason || '', activity: null, fingerprint: null, screenshot: null, ui_tree: null, logs: [] }
+
+    // Parallel fetches for performance: screenshot, current screen, fingerprint, ui tree, and log stream/get logs
+    const sid = sessionId || 'default'
+    const tasks = {
+      screenshot: ToolsObserve.captureScreenshotHandler({ platform, deviceId }),
+      currentScreen: (!platform || platform === 'android') ? ToolsObserve.getCurrentScreenHandler({ deviceId }) : Promise.resolve(null),
+      fingerprint: ToolsObserve.getScreenFingerprintHandler({ platform, deviceId }),
+      uiTree: ToolsObserve.getUITreeHandler({ platform, deviceId }),
+      readLogStream: includeLogs ? ToolsObserve.readLogStreamHandler({ platform, sessionId: sid, limit: logLines }) : Promise.resolve({ entries: [] }),
+    }
+
+    const results = await Promise.allSettled(Object.values(tasks))
+    const keys = Object.keys(tasks)
+
+    // Map results back to keys
+    for (let i = 0; i < results.length; i++) {
+      const key = keys[i]
+      const res = results[i] as PromiseSettledResult<any>
+      if (res.status === 'fulfilled') {
+        const val = res.value
+        if (key === 'screenshot') {
+          out.screenshot = val && val.screenshot ? val.screenshot : null
+        } else if (key === 'currentScreen') {
+          out.activity = val && ((val.activity || val.shortActivity)) ? (val.activity || val.shortActivity) : out.activity || ''
+        } else if (key === 'fingerprint') {
+          if (val && val.fingerprint) out.fingerprint = val.fingerprint
+          if (val && val.activity) out.activity = out.activity || val.activity
+          if (val && val.error) out.fingerprint_error = val.error
+        } else if (key === 'uiTree') {
+          out.ui_tree = val
+          if (val && val.error) out.ui_tree_error = val.error
+        } else if (key === 'readLogStream') {
+          // handle below after evaluating fallback
+          // temporarily attach to out._streamEntries
+          out._streamEntries = val && val.entries ? val.entries : []
+        }
+      } else {
+        const errMsg = res.reason instanceof Error ? res.reason.message : String(res.reason)
+        if (key === 'screenshot') out.screenshot_error = errMsg
+        if (key === 'currentScreen') out.activity_error = errMsg
+        if (key === 'fingerprint') { out.fingerprint = null; out.fingerprint_error = errMsg }
+        if (key === 'uiTree') { out.ui_tree = null; out.ui_tree_error = errMsg }
+        if (key === 'readLogStream') { out._streamEntries = [] ; out.logs_error = errMsg }
+      }
+    }
+
+    // Logs: prefer stream entries, fallback to snapshot logs when empty
+    if (includeLogs) {
+      try {
+        let entries: any[] = Array.isArray(out._streamEntries) ? out._streamEntries : []
+        if (!entries || entries.length === 0) {
+          const gl = await ToolsObserve.getLogsHandler({ platform, appId, deviceId, lines: logLines })
+          const raw: string[] = (gl && (gl as any).logs) ? (gl as any).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 }
+          })
+        } else {
+          entries = entries.map(ent => {
+            const msg = (ent && (ent.message || ent.msg)) ? (ent.message || ent.msg) : (typeof ent === 'string' ? ent : JSON.stringify(ent))
+            const levelRaw = (ent && (ent.level || ent.levelName || ent._level)) ? (ent.level || ent.levelName || ent._level) : ''
+            const level = (levelRaw && String(levelRaw)).toString().toUpperCase() || (/\bERROR\b/i.test(msg) ? 'ERROR' : /\bWARN\b/i.test(msg) ? 'WARN' : 'INFO')
+            let tsNum: number | null = null
+            const maybeIso = ent && ((ent._iso || ent.timestamp) as any)
+            if (maybeIso && typeof maybeIso === 'string') {
+              const d = new Date(maybeIso)
+              if (!isNaN(d.getTime())) tsNum = d.getTime()
+            }
+            return { timestamp: tsNum, level, message: msg }
+          })
+        }
+
+        out.logs = entries
+      } catch (e) {
+        out.logs = []
+        out.logs_error = e instanceof Error ? e.message : String(e)
+      }
+    }
+
+    // Clean up internal temporary field
+    delete out._streamEntries
+
+    return out
+  }
 }

package/src/server.ts

@@ -215,6 +215,23 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         required: ["platform"]
       }
     },
+    {
+      name: "capture_debug_snapshot",
+      description: "Capture a complete debug snapshot (screenshot, ui tree, activity, fingerprint, logs). Returns structured JSON."
+      ,
+      inputSchema: {
+        type: "object",
+        properties: {
+          reason: { type: "string", description: "Optional reason for snapshot" },
+          includeLogs: { type: "boolean", description: "Whether to include logs", default: true },
+          logLines: { type: "number", description: "Maximum number of log lines to include", default: 200 },
+          platform: { type: "string", enum: ["android","ios"], description: "Optional platform override" },
+          appId: { type: "string", description: "Optional appId to scope logs (package/bundle id)" },
+          deviceId: { type: "string", description: "Optional device serial/udid" },
+          sessionId: { type: "string", description: "Optional log stream session id to prefer" }
+        }
+      }
+    },
     {
       name: "start_log_stream",
       description: "Start streaming logs for a target application on Android or iOS. For Android this uses adb logcat --pid=<pid>; for iOS it streams `xcrun simctl spawn <device> log stream` with a predicate.",
@@ -594,6 +611,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       }
     }
 
+    if (name === "capture_debug_snapshot") {
+      const { reason, includeLogs, logLines, platform, appId, deviceId, sessionId } = args as any
+      const res = await ToolsObserve.captureDebugSnapshotHandler({ reason, includeLogs, logLines, platform, appId, deviceId, sessionId })
+      return wrapResponse(res)
+    }
+
     if (name === "get_ui_tree") {
       const { platform, deviceId } = args as any
       const res = await ToolsObserve.getUITreeHandler({ platform, deviceId })

package/test/observe/unit/capture_debug_snapshot.test.ts

@@ -0,0 +1,89 @@
+import { ToolsObserve } from '../../../src/observe/index.js'
+
+async function run() {
+  console.log('Starting capture_debug_snapshot unit tests...')
+
+  // Save original ToolsObserve handlers
+  const origCaptureHandler = (ToolsObserve as any).captureScreenshotHandler
+  const origGetCurrentHandler = (ToolsObserve as any).getCurrentScreenHandler
+  const origGetFpHandler = (ToolsObserve as any).getScreenFingerprintHandler
+  const origGetTreeHandler = (ToolsObserve as any).getUITreeHandler
+  const origReadLogStreamHandler = (ToolsObserve as any).readLogStreamHandler
+  const origGetLogsHandler = (ToolsObserve as any).getLogsHandler
+
+  try {
+    // --- Test 1: all components succeed and logs come from stream ---
+    ;(ToolsObserve as any).captureScreenshotHandler = async function() {
+      return { device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true }, screenshot: 'BASE64PNG', resolution: { width: 1080, height: 1920 } }
+    }
+    ;(ToolsObserve as any).getCurrentScreenHandler = async function() {
+      return { device: { platform: 'android', id: 'mock' }, package: 'com.example', activity: 'com.example.Main', shortActivity: 'Main' }
+    }
+    ;(ToolsObserve as any).getScreenFingerprintHandler = async function() {
+      return { fingerprint: 'abc123', activity: 'Main' }
+    }
+    ;(ToolsObserve as any).getUITreeHandler = async function() {
+      return { device: { platform: 'android', id: 'mock', osVersion: '12', model: 'Pixel', simulator: true }, screen: '', resolution: { width: 1080, height: 1920 }, elements: [] }
+    }
+    ;(ToolsObserve as any).readLogStreamHandler = async function() {
+      return { entries: [ { timestamp: '2026-03-23T20:00:00.000Z', level: 'ERROR', message: 'Boom' } ], crash_summary: { crash_detected: true } }
+    }
+    ;(ToolsObserve as any).getLogsHandler = async function() {
+      return { device: { platform: 'android', id: 'mock' }, logs: [], logCount: 0 }
+    }
+
+    const res1: any = await ToolsObserve.captureDebugSnapshotHandler({ platform: 'android', includeLogs: true, logLines: 50, sessionId: 's1' })
+    console.log('res1:', JSON.stringify(res1, null, 2))
+    const pass1 = res1 && res1.screenshot === 'BASE64PNG' && res1.activity && res1.fingerprint === 'abc123' && Array.isArray(res1.logs) && res1.logs.length === 1
+    console.log('Test 1:', pass1 ? 'PASS' : 'FAIL')
+
+    // Restore handlers before next test
+    ;(ToolsObserve as any).captureScreenshotHandler = origCaptureHandler
+    ;(ToolsObserve as any).getCurrentScreenHandler = origGetCurrentHandler
+    ;(ToolsObserve as any).getScreenFingerprintHandler = origGetFpHandler
+    ;(ToolsObserve as any).getUITreeHandler = origGetTreeHandler
+    ;(ToolsObserve as any).readLogStreamHandler = origReadLogStreamHandler
+    ;(ToolsObserve as any).getLogsHandler = origGetLogsHandler
+
+    // --- Test 2: screenshot and ui tree fail; logs fallback to getLogs ---
+    ;(ToolsObserve as any).captureScreenshotHandler = async function() { throw new Error('screencap failed') }
+    ;(ToolsObserve as any).getUITreeHandler = async function() { throw new Error('uie_error') }
+    ;(ToolsObserve as any).readLogStreamHandler = async function() { return { entries: [] } }
+    ;(ToolsObserve as any).getLogsHandler = async function() { return { device: { platform: 'android', id: 'mock' }, logs: ['INFO starting','ERROR crash here'], logCount: 2 } }
+
+    const res2: any = await ToolsObserve.captureDebugSnapshotHandler({ platform: 'android', includeLogs: true, logLines: 10, appId: 'com.example' })
+    console.log('res2:', JSON.stringify(res2, null, 2))
+    const pass2 = res2 && res2.screenshot_error && res2.ui_tree_error && Array.isArray(res2.logs) && res2.logs.length === 2
+    console.log('Test 2:', pass2 ? 'PASS' : 'FAIL')
+
+    // Restore handlers before next test
+    ;(ToolsObserve as any).captureScreenshotHandler = origCaptureHandler
+    ;(ToolsObserve as any).getCurrentScreenHandler = origGetCurrentHandler
+    ;(ToolsObserve as any).getScreenFingerprintHandler = origGetFpHandler
+    ;(ToolsObserve as any).getUITreeHandler = origGetTreeHandler
+    ;(ToolsObserve as any).readLogStreamHandler = origReadLogStreamHandler
+    ;(ToolsObserve as any).getLogsHandler = origGetLogsHandler
+
+    // --- Test 3: includeLogs=false should omit logs ---
+    ;(ToolsObserve as any).captureScreenshotHandler = async function() { return { device: { platform: 'android', id: 'mock' }, screenshot: null } }
+    ;(ToolsObserve as any).getCurrentScreenHandler = async function() { return { device: { platform: 'android', id: 'mock' }, package: '', activity: '', shortActivity: '' } }
+    ;(ToolsObserve as any).getScreenFingerprintHandler = async function() { return { fingerprint: null } }
+    ;(ToolsObserve as any).getUITreeHandler = async function() { return { device: { platform: 'android', id: 'mock' }, screen: '', resolution: { width: 0, height: 0 }, elements: [] } }
+    ;(ToolsObserve as any).readLogStreamHandler = async function() { return { entries: [] } }
+
+    const res3: any = await ToolsObserve.captureDebugSnapshotHandler({ platform: 'android', includeLogs: false })
+    console.log('res3:', JSON.stringify(res3, null, 2))
+    const pass3 = res3 && typeof res3.logs !== 'undefined' && res3.logs.length === 0
+    console.log('Test 3:', pass3 ? 'PASS' : 'FAIL')
+
+  } finally {
+    ;(ToolsObserve as any).captureScreenshotHandler = origCaptureHandler
+    ;(ToolsObserve as any).getCurrentScreenHandler = origGetCurrentHandler
+    ;(ToolsObserve as any).getScreenFingerprintHandler = origGetFpHandler
+    ;(ToolsObserve as any).getUITreeHandler = origGetTreeHandler
+    ;(ToolsObserve as any).readLogStreamHandler = origReadLogStreamHandler
+    ;(ToolsObserve as any).getLogsHandler = origGetLogsHandler
+  }
+}
+
+run().catch(console.error)

package/test/unit/index.ts

@@ -11,5 +11,6 @@ import '../manage/unit/diagnostics.test.ts'
 import '../manage/unit/detection.test.ts'
 import '../manage/unit/mcp_disable_autodetect.test.ts'
 import '../interact/unit/wait_for_screen_change.test.ts'
+import '../observe/unit/capture_debug_snapshot.test.ts'
 
 console.log('Unit tests loaded.')