mobile-debug-mcp 0.21.1 → 0.21.2

package/dist/observe/android.js

@@ -5,6 +5,7 @@ import { createWriteStream } from "fs";
 import { promises as fsPromises } from "fs";
 import path from "path";
 import { computeScreenFingerprint } from "../utils/ui/index.js";
+import { parsePngSize } from "../utils/image.js";
 const activeLogStreams = new Map();
 export class AndroidObserve {
     async getDeviceMetadata(appId, deviceId) {
@@ -120,7 +121,7 @@ export class AndroidObserve {
                 child.kill();
                 reject(new Error(`ADB screencap timed out after 10s`));
             }, 10000);
-            child.on('close', (code) => {
+            child.on('close', async (code) => {
                 clearTimeout(timeout);
                 if (code !== 0) {
                     reject(new Error(stderr.trim() || `Screencap failed with code ${code}`));
@@ -128,28 +129,91 @@ export class AndroidObserve {
                 }
                 const screenshotBuffer = Buffer.concat(chunks);
                 const screenshotBase64 = screenshotBuffer.toString('base64');
-                execAdb(['shell', 'wm', 'size'], deviceId)
-                    .then(sizeStdout => {
-                    let width = 0;
-                    let height = 0;
-                    const match = sizeStdout.match(/Physical size: (\d+)x(\d+)/);
-                    if (match) {
-                        width = parseInt(match[1], 10);
-                        height = parseInt(match[2], 10);
+                const parsed = parsePngSize(screenshotBuffer);
+                if (parsed.width > 0 && parsed.height > 0) {
+                    // Attempt to convert to WebP (preferred) and provide JPEG fallback (awaited to avoid race)
+                    try {
+                        const sharpModule = await import('sharp');
+                        const sharp = sharpModule && sharpModule.default ? sharpModule.default : sharpModule;
+                        const buf = screenshotBuffer;
+                        const img = sharp(buf);
+                        const meta = await img.metadata().catch((err) => { console.error('sharp.metadata failed (Android):', err); return {}; });
+                        const hasAlpha = !!meta.hasAlpha || (meta.channels && meta.channels > 3);
+                        let webpBuf = null;
+                        let jpegBuf = null;
+                        try {
+                            webpBuf = await img.webp({ quality: 80 }).toBuffer();
+                        }
+                        catch (err) {
+                            console.error('WebP conversion failed (Android):', err instanceof Error ? err.message : String(err));
+                            webpBuf = null;
+                        }
+                        try {
+                            jpegBuf = await img.jpeg({ quality: 80 }).toBuffer();
+                        }
+                        catch (err) {
+                            console.error('JPEG conversion failed (Android):', err instanceof Error ? err.message : String(err));
+                            jpegBuf = null;
+                        }
+                        if (hasAlpha) {
+                            if (webpBuf) {
+                                const webpB64 = webpBuf.toString('base64');
+                                const jpegB64 = jpegBuf ? jpegBuf.toString('base64') : null;
+                                resolve({ device: deviceInfo, screenshot: webpB64, screenshot_mime: 'image/webp', screenshot_fallback: jpegB64, screenshot_fallback_mime: jpegB64 ? 'image/jpeg' : undefined, resolution: { width: parsed.width, height: parsed.height } });
+                                return;
+                            }
+                            const pngB64 = buf.toString('base64');
+                            resolve({ device: deviceInfo, screenshot: pngB64, screenshot_mime: 'image/png', resolution: { width: parsed.width, height: parsed.height } });
+                            return;
+                        }
+                        if (webpBuf) {
+                            const webpB64 = webpBuf.toString('base64');
+                            const jpegB64 = jpegBuf ? jpegBuf.toString('base64') : null;
+                            resolve({ device: deviceInfo, screenshot: webpB64, screenshot_mime: 'image/webp', screenshot_fallback: jpegB64, screenshot_fallback_mime: jpegB64 ? 'image/jpeg' : undefined, resolution: { width: parsed.width, height: parsed.height } });
+                            return;
+                        }
+                        if (jpegBuf) {
+                            resolve({ device: deviceInfo, screenshot: jpegBuf.toString('base64'), screenshot_mime: 'image/jpeg', resolution: { width: parsed.width, height: parsed.height } });
+                            return;
+                        }
+                        // No conversions succeeded; return original PNG
+                        resolve({ device: deviceInfo, screenshot: screenshotBase64, screenshot_mime: 'image/png', resolution: { width: parsed.width, height: parsed.height } });
+                        return;
                     }
-                    resolve({
-                        device: deviceInfo,
-                        screenshot: screenshotBase64,
-                        resolution: { width, height }
-                    });
-                })
-                    .catch(() => {
-                    resolve({
-                        device: deviceInfo,
-                        screenshot: screenshotBase64,
-                        resolution: { width: 0, height: 0 }
+                    catch (err) {
+                        console.error('Screenshot conversion pipeline failed (Android):', err instanceof Error ? err.message : String(err));
+                        // Conversion failed - fall back to original PNG with parsed resolution
+                        resolve({ device: deviceInfo, screenshot: screenshotBase64, screenshot_mime: 'image/png', resolution: { width: parsed.width, height: parsed.height } });
+                        return;
+                    }
+                }
+                else {
+                    // Fallback to querying wm size if parsing failed
+                    execAdb(['shell', 'wm', 'size'], deviceId)
+                        .then(sizeStdout => {
+                        let width = 0;
+                        let height = 0;
+                        const match = sizeStdout.match(/Physical size: (\d+)x(\d+)/);
+                        if (match) {
+                            width = parseInt(match[1], 10);
+                            height = parseInt(match[2], 10);
+                        }
+                        resolve({
+                            device: deviceInfo,
+                            screenshot: screenshotBase64,
+                            screenshot_mime: 'image/png',
+                            resolution: { width, height }
+                        });
+                    })
+                        .catch(() => {
+                        resolve({
+                            device: deviceInfo,
+                            screenshot: screenshotBase64,
+                            screenshot_mime: 'image/png',
+                            resolution: { width: 0, height: 0 }
+                        });
                     });
-                });
+                }
             });
             child.on('error', (err) => {
                 clearTimeout(timeout);

package/dist/observe/ios.js

@@ -5,6 +5,7 @@ import { createWriteStream, promises as fsPromises } from 'fs';
 import path from 'path';
 import { parseLogLine } from '../utils/android/utils.js';
 import { computeScreenFingerprint } from '../utils/ui/index.js';
+import { parsePngSize } from '../utils/image.js';
 const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 function parseIDBFrame(frame) {
     if (!frame)
@@ -109,11 +110,59 @@ export class iOSObserve {
             await execCommand(['simctl', 'io', deviceId, 'screenshot', tmpFile], deviceId);
             const buffer = await fs.readFile(tmpFile);
             const base64 = buffer.toString('base64');
+            const dims = parsePngSize(buffer);
+            // Try to generate WebP (preferred) and JPEG fallback using sharp (in-process, cross-platform)
+            try {
+                const sharpModule = await import('sharp');
+                const sharp = sharpModule && sharpModule.default ? sharpModule.default : sharpModule;
+                const img = sharp(buffer);
+                const meta = await img.metadata().catch((err) => { console.error('sharp.metadata failed:', err); return {}; });
+                // If image has alpha channel, prefer lossless PNG to preserve transparency
+                const hasAlpha = !!meta.hasAlpha || (meta.channels && meta.channels > 3);
+                // Generate WebP and JPEG buffers; log failures
+                let webpBuf = null;
+                let jpegBuf = null;
+                try {
+                    webpBuf = await img.webp({ quality: 80 }).toBuffer();
+                }
+                catch (err) {
+                    console.error('WebP conversion failed (iOS):', err instanceof Error ? err.message : String(err));
+                    webpBuf = null;
+                }
+                try {
+                    jpegBuf = await img.jpeg({ quality: 80 }).toBuffer();
+                }
+                catch (err) {
+                    console.error('JPEG conversion failed (iOS):', err instanceof Error ? err.message : String(err));
+                    jpegBuf = null;
+                }
+                await fs.rm(tmpFile).catch(() => { });
+                if (hasAlpha) {
+                    // preserve alpha: return PNG if WebP not available
+                    if (webpBuf) {
+                        return { device, screenshot: webpBuf.toString('base64'), screenshot_mime: 'image/webp', screenshot_fallback: base64, screenshot_fallback_mime: 'image/png', resolution: { width: dims.width, height: dims.height } };
+                    }
+                    // if webp unavailable, return original PNG
+                    return { device, screenshot: base64, screenshot_mime: 'image/png', resolution: { width: dims.width, height: dims.height } };
+                }
+                // No alpha: prefer webp, fall back to jpeg
+                if (webpBuf) {
+                    return { device, screenshot: webpBuf.toString('base64'), screenshot_mime: 'image/webp', screenshot_fallback: jpegBuf ? jpegBuf.toString('base64') : undefined, screenshot_fallback_mime: jpegBuf ? 'image/jpeg' : undefined, resolution: { width: dims.width, height: dims.height } };
+                }
+                if (jpegBuf) {
+                    return { device, screenshot: jpegBuf.toString('base64'), screenshot_mime: 'image/jpeg', resolution: { width: dims.width, height: dims.height } };
+                }
+            }
+            catch (err) {
+                console.error('Screenshot conversion pipeline failed (iOS):', err instanceof Error ? err.message : String(err));
+                // fall through to png fallback
+            }
             await fs.rm(tmpFile).catch(() => { });
             return {
                 device,
                 screenshot: base64,
-                resolution: { width: 0, height: 0 },
+                screenshot_mime: 'image/png',
+                resolution: { width: dims.width, height: dims.height },
             };
         }
         catch (e) {

package/dist/server.js

@@ -584,12 +584,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         if (name === "capture_screenshot") {
             const { platform, deviceId } = args;
             const res = await ToolsObserve.captureScreenshotHandler({ platform, deviceId });
-            return {
-                content: [
-                    { type: 'text', text: JSON.stringify({ device: res.device, result: { resolution: res.resolution } }, null, 2) },
-                    { type: 'image', data: res.screenshot, mimeType: 'image/png' }
-                ]
-            };
+            const mime = res.screenshot_mime || 'image/png';
+            const content = [
+                { type: 'text', text: JSON.stringify({ device: res.device, result: { resolution: res.resolution, mimeType: mime } }, null, 2) },
+                { type: 'image', data: res.screenshot, mimeType: mime }
+            ];
+            // If a jpeg fallback is available, include a small note and the fallback as an additional image block for compatibility
+            if (res.screenshot_fallback) {
+                content.push({ type: 'text', text: JSON.stringify({ note: 'JPEG fallback included for compatibility', mimeType: res.screenshot_fallback_mime || 'image/jpeg' }) });
+                content.push({ type: 'image', data: res.screenshot_fallback, mimeType: res.screenshot_fallback_mime || 'image/jpeg' });
+            }
+            return { content };
         }
         if (name === "capture_debug_snapshot") {
             const { reason, includeLogs, logLines, platform, appId, deviceId, sessionId } = args;

package/dist/utils/image.js

@@ -0,0 +1,18 @@
+export function parsePngSize(buf) {
+    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/docs/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 All notable changes to the **Mobile Debug MCP** project will be documented in this file.
 
+## [0.21.2]
+- Fixed screenshots not working, imnproved tool
+
 ## [0.21.1]
 - Removed wait_for_element and renamed observe_until to wait_for_ui (obsolete references removed)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobile-debug-mcp",
-  "version": "0.21.1",
+  "version": "0.21.2",
   "description": "MCP server for mobile app debugging (Android + iOS), with focus on security and reliability",
   "type": "module",
   "bin": {
@@ -27,7 +27,8 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
     "fast-xml-parser": "^5.5.1",
-    "zod": "^3.22.4"
+    "zod": "^3.22.4",
+    "sharp": "^0.32.1"
   },
   "devDependencies": {
     "@types/node": "^25.4.0",

package/src/observe/android.ts

@@ -6,6 +6,7 @@ import { createWriteStream } from "fs"
 import { promises as fsPromises } from "fs"
 import path from "path"
 import { computeScreenFingerprint } from "../utils/ui/index.js"
+import { parsePngSize } from "../utils/image.js"
 
 const activeLogStreams: Map<string, { proc: any, file: string }> = new Map()
 
@@ -142,7 +143,7 @@ export class AndroidObserve {
         reject(new Error(`ADB screencap timed out after 10s`))
       }, 10000)
 
-      child.on('close', (code) => {
+      child.on('close', async (code) => {
         clearTimeout(timeout)
         if (code !== 0) {
           reject(new Error(stderr.trim() || `Screencap failed with code ${code}`))
@@ -152,28 +153,91 @@ export class AndroidObserve {
         const screenshotBuffer = Buffer.concat(chunks)
         const screenshotBase64 = screenshotBuffer.toString('base64')
 
-        execAdb(['shell', 'wm', 'size'], deviceId)
-          .then(sizeStdout => {
-            let width = 0
-            let height = 0
-            const match = sizeStdout.match(/Physical size: (\d+)x(\d+)/)
-            if (match) {
-              width = parseInt(match[1], 10)
-              height = parseInt(match[2], 10)
+        const parsed = parsePngSize(screenshotBuffer)
+        if (parsed.width > 0 && parsed.height > 0) {
+          // Attempt to convert to WebP (preferred) and provide JPEG fallback (awaited to avoid race)
+          try {
+            const sharpModule = await import('sharp'); const sharp = sharpModule && (sharpModule as any).default ? (sharpModule as any).default : sharpModule;
+            const buf = screenshotBuffer;
+            const img = sharp(buf);
+            const meta = await img.metadata().catch((err: any) => { console.error('sharp.metadata failed (Android):', err); return {} as any });
+            const hasAlpha = !!meta.hasAlpha || (meta.channels && meta.channels > 3);
+
+            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 (Android):', err instanceof Error ? err.message : String(err));
+              webpBuf = null;
             }
-            resolve({
-              device: deviceInfo,
-              screenshot: screenshotBase64,
-              resolution: { width, height }
+            try {
+              jpegBuf = await img.jpeg({ quality: 80 }).toBuffer();
+            } catch (err) {
+              console.error('JPEG conversion failed (Android):', err instanceof Error ? err.message : String(err));
+              jpegBuf = null;
+            }
+
+            if (hasAlpha) {
+              if (webpBuf) {
+                const webpB64 = webpBuf.toString('base64')
+                const jpegB64 = jpegBuf ? jpegBuf.toString('base64') : null
+                resolve({ device: deviceInfo, screenshot: webpB64, screenshot_mime: 'image/webp', screenshot_fallback: jpegB64, screenshot_fallback_mime: jpegB64 ? 'image/jpeg' : undefined, resolution: { width: parsed.width, height: parsed.height } } as any)
+                return
+              }
+              const pngB64 = buf.toString('base64')
+              resolve({ device: deviceInfo, screenshot: pngB64, screenshot_mime: 'image/png', resolution: { width: parsed.width, height: parsed.height } })
+              return
+            }
+
+            if (webpBuf) {
+              const webpB64 = webpBuf.toString('base64')
+              const jpegB64 = jpegBuf ? jpegBuf.toString('base64') : null
+              resolve({ device: deviceInfo, screenshot: webpB64, screenshot_mime: 'image/webp', screenshot_fallback: jpegB64, screenshot_fallback_mime: jpegB64 ? 'image/jpeg' : undefined, resolution: { width: parsed.width, height: parsed.height } } as any)
+              return
+            }
+
+            if (jpegBuf) {
+              resolve({ device: deviceInfo, screenshot: jpegBuf.toString('base64'), screenshot_mime: 'image/jpeg', resolution: { width: parsed.width, height: parsed.height } })
+              return
+            }
+
+            // No conversions succeeded; return original PNG
+            resolve({ device: deviceInfo, screenshot: screenshotBase64, screenshot_mime: 'image/png', resolution: { width: parsed.width, height: parsed.height } })
+            return
+          } catch (err) {
+            console.error('Screenshot conversion pipeline failed (Android):', err instanceof Error ? err.message : String(err));
+            // Conversion failed - fall back to original PNG with parsed resolution
+            resolve({ device: deviceInfo, screenshot: screenshotBase64, screenshot_mime: 'image/png', resolution: { width: parsed.width, height: parsed.height } })
+            return
+          }
+        } else {
+          // Fallback to querying wm size if parsing failed
+          execAdb(['shell', 'wm', 'size'], deviceId)
+            .then(sizeStdout => {
+              let width = 0
+              let height = 0
+              const match = sizeStdout.match(/Physical size: (\d+)x(\d+)/)
+              if (match) {
+                width = parseInt(match[1], 10)
+                height = parseInt(match[2], 10)
+              }
+              resolve({
+                device: deviceInfo,
+                screenshot: screenshotBase64,
+                screenshot_mime: 'image/png',
+                resolution: { width, height }
+              })
             })
-          })
-          .catch(() => {
-             resolve({
-              device: deviceInfo,
-              screenshot: screenshotBase64,
-              resolution: { width: 0, height: 0 }
+            .catch(() => {
+               resolve({
+                device: deviceInfo,
+                screenshot: screenshotBase64,
+                screenshot_mime: 'image/png',
+                resolution: { width: 0, height: 0 }
+              })
             })
-          })
+        }
       })
 
       child.on('error', (err) => {

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));
 
@@ -146,13 +147,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

@@ -628,12 +628,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

@@ -50,6 +50,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 +62,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/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 };
+  }
+}