mobile-debug-mcp 0.15.0 → 0.17.0

package/dist/interact/android.js

@@ -1,6 +1,6 @@
 import { execAdb, getAndroidDeviceMetadata, getDeviceInfo } from "../utils/android/utils.js";
 import { AndroidObserve } from "../observe/index.js";
-import { scrollToElementShared } from "../interact/shared/scroll_to_element.js";
+import { scrollToElementShared } from "../utils/ui/index.js";
 export class AndroidInteract {
     observe = new AndroidObserve();
     async waitForElement(text, timeout, deviceId) {

package/dist/interact/index.js

@@ -2,6 +2,7 @@ import { AndroidInteract } from './android.js';
 import { iOSInteract } from './ios.js';
 export { AndroidInteract, iOSInteract };
 import { resolveTargetDevice } from '../utils/resolve-device.js';
+import { ToolsObserve } from '../observe/index.js';
 export class ToolsInteract {
     static async getInteractionService(platform, deviceId) {
         const effectivePlatform = platform || 'android';
@@ -34,4 +35,42 @@ export class ToolsInteract {
         const { interact, resolved } = await ToolsInteract.getInteractionService(platform, deviceId);
         return await interact.scrollToElement(selector, direction, maxScrolls, scrollAmount, resolved.id);
     }
+    static async waitForScreenChangeHandler({ platform, previousFingerprint, timeoutMs = 5000, pollIntervalMs = 300, deviceId }) {
+        const start = Date.now();
+        let lastFingerprint = null;
+        while (Date.now() - start < timeoutMs) {
+            try {
+                const res = await ToolsObserve.getScreenFingerprintHandler({ platform, deviceId });
+                const fp = res?.fingerprint ?? null;
+                if (fp === null || fp === undefined) {
+                    lastFingerprint = null;
+                    await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+                    continue;
+                }
+                lastFingerprint = fp;
+                if (fp !== previousFingerprint) {
+                    // Stability confirmation
+                    await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+                    try {
+                        const confirmRes = await ToolsObserve.getScreenFingerprintHandler({ platform, deviceId });
+                        const confirmFp = confirmRes?.fingerprint ?? null;
+                        if (confirmFp === fp) {
+                            return { success: true, newFingerprint: fp, elapsedMs: Date.now() - start };
+                        }
+                        lastFingerprint = confirmFp;
+                        continue;
+                    }
+                    catch {
+                        // ignore and continue polling
+                        continue;
+                    }
+                }
+            }
+            catch {
+                // ignore transient errors
+            }
+            await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+        }
+        return { success: false, reason: 'timeout', lastFingerprint, elapsedMs: Date.now() - start };
+    }
 }

package/dist/interact/ios.js

@@ -1,7 +1,7 @@
 import { spawn } from "child_process";
 import { getIOSDeviceMetadata, getIdbCmd, isIDBInstalled } from "../utils/ios/utils.js";
 import { iOSObserve } from "../observe/index.js";
-import { scrollToElementShared } from "../interact/shared/scroll_to_element.js";
+import { scrollToElementShared } from "../utils/ui/index.js";
 export class iOSInteract {
     observe = new iOSObserve();
     async waitForElement(text, timeout, deviceId = "booted") {

package/dist/interact/shared/fingerprint.js

@@ -1,72 +1 @@
-import crypto from 'crypto';
-const ANDROID_STRUCTURAL_TYPES = ['Window', 'Application', 'View', 'ViewGroup', 'LinearLayout', 'FrameLayout', 'RelativeLayout', 'ScrollView', 'RecyclerView', 'TextView', 'ImageView'];
-const IOS_STRUCTURAL_TYPES = ['Window', 'Application', 'View', 'ViewController', 'UITableView', 'UICollectionView', 'UILabel', 'UIImageView', 'UIView', 'UIWindow', 'UIStackView', 'UITextView', 'UITableViewCell'];
-function isDynamicText(t) {
-    if (!t)
-        return false;
-    const txt = t.trim();
-    if (!txt)
-        return false;
-    if (/\b\d{1,2}:\d{2}\b/.test(txt))
-        return true;
-    if (/\b\d{4}-\d{2}-\d{2}\b/.test(txt))
-        return true;
-    if (/^\d+(?:\.\d+)?%$/.test(txt))
-        return true;
-    if (/^\d+$/.test(txt))
-        return true;
-    if (/^[\d,]{1,10}$/.test(txt))
-        return true;
-    return false;
-}
-function normalizeElement(e) {
-    return {
-        type: (e.type || '').toString(),
-        resourceId: (e.resourceId || '').toString(),
-        text: typeof e.text === 'string' ? (isDynamicText(e.text) ? '' : e.text.trim().toLowerCase()) : '',
-        contentDesc: (e.contentDescription || '').toString(),
-        bounds: Array.isArray(e.bounds) ? e.bounds.slice(0, 4).map((n) => Number(n) || 0) : [0, 0, 0, 0]
-    };
-}
-export function computeScreenFingerprint(tree, current, platform, limit = 50) {
-    try {
-        if (!tree || tree.error)
-            return { fingerprint: null, error: tree.error };
-        const activity = current && (current.activity || current.shortActivity) ? (current.activity || current.shortActivity) : '';
-        const candidates = (tree.elements || []).filter(e => {
-            if (!e)
-                return false;
-            if (!e.visible)
-                return false;
-            const hasStableText = typeof e.text === 'string' && e.text.trim().length > 0;
-            const hasResource = !!e.resourceId;
-            const interactable = !!e.clickable || !!e.enabled;
-            const structuralList = platform === 'android' ? ANDROID_STRUCTURAL_TYPES : IOS_STRUCTURAL_TYPES;
-            const structurallySignificant = hasStableText || hasResource || structuralList.includes(e.type || '');
-            return interactable || structurallySignificant;
-        });
-        const normalized = candidates.map(normalizeElement);
-        const filteredNormalized = normalized.filter(e => (e.text && e.text.length > 0) || (e.resourceId && e.resourceId.length > 0) || (e.contentDesc && e.contentDesc.length > 0));
-        filteredNormalized.sort((a, b) => {
-            const ay = (a.bounds && a.bounds[1]) || 0;
-            const by = (b.bounds && b.bounds[1]) || 0;
-            if (ay !== by)
-                return ay - by;
-            const ax = (a.bounds && a.bounds[0]) || 0;
-            const bx = (b.bounds && b.bounds[0]) || 0;
-            return ax - bx;
-        });
-        const limited = filteredNormalized.slice(0, Math.max(0, limit));
-        const payload = {
-            activity: platform === 'android' ? (activity || '') : '',
-            resolution: tree.resolution || { width: 0, height: 0 },
-            elements: limited.map(e => ({ type: e.type, resourceId: e.resourceId, text: e.text, contentDesc: e.contentDesc }))
-        };
-        const combined = JSON.stringify(payload);
-        const hash = crypto.createHash('sha256').update(combined).digest('hex');
-        return { fingerprint: hash, activity: activity };
-    }
-    catch (e) {
-        return { fingerprint: null, error: e instanceof Error ? e.message : String(e) };
-    }
-}
+export { computeScreenFingerprint } from '../../utils/ui/index.js';

package/dist/interact/shared/scroll_to_element.js

@@ -1,98 +1 @@
-export async function scrollToElementShared(opts) {
-    const { selector, direction = 'down', maxScrolls = 10, scrollAmount = 0.7, deviceId, fetchTree, swipe, stabilizationDelayMs = 350 } = opts;
-    const matchElement = (el) => {
-        if (!el)
-            return false;
-        if (selector.text !== undefined && selector.text !== el.text)
-            return false;
-        if (selector.resourceId !== undefined && selector.resourceId !== el.resourceId)
-            return false;
-        if (selector.contentDesc !== undefined && selector.contentDesc !== el.contentDescription)
-            return false;
-        if (selector.className !== undefined && selector.className !== el.type)
-            return false;
-        return true;
-    };
-    const isVisible = (el, resolution) => {
-        if (!el)
-            return false;
-        if (el.visible === false)
-            return false;
-        if (!el.bounds || !resolution || !resolution.width || !resolution.height)
-            return (el.visible === undefined ? true : !!el.visible);
-        const [left, top, right, bottom] = el.bounds;
-        const withinY = bottom > 0 && top < resolution.height;
-        const withinX = right > 0 && left < resolution.width;
-        return withinX && withinY;
-    };
-    const findVisibleMatch = (elements, resolution) => {
-        if (!Array.isArray(elements))
-            return null;
-        for (const e of elements) {
-            if (matchElement(e) && isVisible(e, resolution))
-                return e;
-        }
-        return null;
-    };
-    // Initial check
-    let tree = await fetchTree();
-    if (tree.error)
-        return { success: false, reason: tree.error, scrollsPerformed: 0 };
-    let found = findVisibleMatch(tree.elements, tree.resolution);
-    if (found) {
-        return { success: true, element: { text: found.text, resourceId: found.resourceId, bounds: found.bounds }, scrollsPerformed: 0 };
-    }
-    const fingerprintOf = (t) => {
-        try {
-            return JSON.stringify((t.elements || []).map((e) => ({ text: e.text, resourceId: e.resourceId, bounds: e.bounds })));
-        }
-        catch {
-            return '';
-        }
-    };
-    let prevFingerprint = fingerprintOf(tree);
-    const width = (tree.resolution && tree.resolution.width) ? tree.resolution.width : 0;
-    const height = (tree.resolution && tree.resolution.height) ? tree.resolution.height : 0;
-    const centerX = Math.round(width / 2) || 50;
-    const clampPct = (v) => Math.max(0.05, Math.min(0.95, v));
-    const computeCoords = () => {
-        const defaultStart = direction === 'down' ? 0.8 : 0.2;
-        const startPct = clampPct(defaultStart);
-        const endPct = clampPct(defaultStart + (direction === 'down' ? -scrollAmount : scrollAmount));
-        const x1 = centerX;
-        const x2 = centerX;
-        const y1 = Math.round((height || 100) * startPct);
-        const y2 = Math.round((height || 100) * endPct);
-        return { x1, y1, x2, y2 };
-    };
-    const duration = 300;
-    let scrollsPerformed = 0;
-    for (let i = 0; i < maxScrolls; i++) {
-        const { x1, y1, x2, y2 } = computeCoords();
-        try {
-            await swipe(x1, y1, x2, y2, duration, deviceId);
-        }
-        catch (e) {
-            // Log swipe failures to aid debugging but don't fail the overall flow
-            try {
-                console.warn(`scrollToElement swipe failed: ${e instanceof Error ? e.message : String(e)}`);
-            }
-            catch { }
-        }
-        scrollsPerformed++;
-        await new Promise(resolve => setTimeout(resolve, stabilizationDelayMs));
-        tree = await fetchTree();
-        if (tree.error)
-            return { success: false, reason: tree.error, scrollsPerformed: scrollsPerformed };
-        found = findVisibleMatch(tree.elements, tree.resolution);
-        if (found) {
-            return { success: true, element: { text: found.text, resourceId: found.resourceId, bounds: found.bounds }, scrollsPerformed };
-        }
-        const fp = fingerprintOf(tree);
-        if (fp === prevFingerprint) {
-            return { success: false, reason: 'UI unchanged after scroll; likely end of list', scrollsPerformed: scrollsPerformed };
-        }
-        prevFingerprint = fp;
-    }
-    return { success: false, reason: 'Element not found after scrolling', scrollsPerformed: scrollsPerformed };
-}
+export { scrollToElementShared } from '../../utils/ui/index.js';

package/dist/observe/android.js

@@ -4,7 +4,7 @@ import { getAdbCmd, execAdb, getAndroidDeviceMetadata, getDeviceInfo, delay, get
 import { createWriteStream } from "fs";
 import { promises as fsPromises } from "fs";
 import path from "path";
-import { computeScreenFingerprint } from "../interact/shared/fingerprint.js";
+import { computeScreenFingerprint } from "../utils/ui/index.js";
 const activeLogStreams = new Map();
 export class AndroidObserve {
     async getDeviceMetadata(appId, deviceId) {

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/observe/ios.js

@@ -4,7 +4,7 @@ import { execCommand, getIOSDeviceMetadata, validateBundleId, getIdbCmd, getXcru
 import { createWriteStream, promises as fsPromises } from 'fs';
 import path from 'path';
 import { parseLogLine } from '../utils/android/utils.js';
-import { computeScreenFingerprint } from '../interact/shared/fingerprint.js';
+import { computeScreenFingerprint } from '../utils/ui/index.js';
 const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 function parseIDBFrame(frame) {
     if (!frame)

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.",
@@ -273,6 +289,21 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 }
             }
         },
+        {
+            name: "wait_for_screen_change",
+            description: "Wait until the current screen fingerprint differs from a provided previousFingerprint. Useful to wait for navigation/animation completion.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    platform: { type: "string", enum: ["android", "ios"], description: "Optional platform override (android|ios)" },
+                    previousFingerprint: { type: "string", description: "The fingerprint to compare against (required)" },
+                    timeoutMs: { type: "number", description: "Timeout in ms to wait for change (default 5000)", default: 5000 },
+                    pollIntervalMs: { type: "number", description: "Polling interval in ms (default 300)", default: 300 },
+                    deviceId: { type: "string", description: "Optional device id/udid to target" }
+                },
+                required: ["previousFingerprint"]
+            }
+        },
         {
             name: "wait_for_element",
             description: "Wait until a UI element with matching text appears on screen or timeout is reached.",
@@ -541,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 });
@@ -556,6 +592,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const res = await ToolsObserve.getScreenFingerprintHandler({ platform, deviceId });
             return wrapResponse(res);
         }
+        if (name === "wait_for_screen_change") {
+            const { platform, previousFingerprint, timeoutMs, pollIntervalMs, deviceId } = (args || {});
+            const res = await ToolsInteract.waitForScreenChangeHandler({ platform, previousFingerprint, timeoutMs, pollIntervalMs, deviceId });
+            return wrapResponse(res);
+        }
         if (name === "wait_for_element") {
             const { platform, text, timeout, deviceId } = (args || {});
             const res = await ToolsInteract.waitForElementHandler({ platform, text, timeout, deviceId });

package/dist/utils/android/utils.js

@@ -1,7 +1,7 @@
-import { spawn } from 'child_process';
 import { promises as fsPromises, existsSync } from 'fs';
 import path from 'path';
 import { detectJavaHome } from '../java.js';
+import { execCmd } from '../exec.js';
 export function getAdbCmd() { return process.env.ADB_PATH || 'adb'; }
 /**
  * Prepare Gradle execution options for building an Android project.
@@ -76,76 +76,20 @@ function getAdbTimeout(args, customTimeout) {
         return 20000;
     return 120000;
 }
-export function execAdb(args, deviceId, options = {}) {
+export async function execAdb(args, deviceId, options = {}) {
     const adbArgs = getAdbArgs(args, deviceId);
-    return new Promise((resolve, reject) => {
-        // Extract timeout from options if present, otherwise pass options to spawn
-        const { timeout: customTimeout, ...spawnOptions } = options;
-        // Use spawn instead of execFile for better stream control and to avoid potential buffering hangs
-        const child = spawn(getAdbCmd(), adbArgs, spawnOptions);
-        let stdout = '';
-        let stderr = '';
-        if (child.stdout) {
-            child.stdout.on('data', (data) => {
-                stdout += data.toString();
-            });
-        }
-        if (child.stderr) {
-            child.stderr.on('data', (data) => {
-                stderr += data.toString();
-            });
-        }
-        const timeoutMs = getAdbTimeout(args, customTimeout);
-        const timeout = setTimeout(() => {
-            child.kill();
-            reject(new Error(`ADB command timed out after ${timeoutMs}ms: ${args.join(' ')}`));
-        }, timeoutMs);
-        child.on('close', (code) => {
-            clearTimeout(timeout);
-            if (code !== 0) {
-                // If there's an actual error (non-zero exit code), reject
-                reject(new Error(stderr.trim() || `Command failed with code ${code}`));
-            }
-            else {
-                // If exit code is 0, resolve with stdout
-                resolve(stdout.trim());
-            }
-        });
-        child.on('error', (err) => {
-            clearTimeout(timeout);
-            reject(err);
-        });
-    });
+    const timeoutMs = getAdbTimeout(args, options.timeout);
+    const res = await execCmd(getAdbCmd(), adbArgs, { timeout: timeoutMs, env: options.env, cwd: typeof options.cwd === 'string' ? options.cwd : undefined, shell: !!options.shell });
+    if (res.exitCode !== 0)
+        throw new Error(res.stderr || `Command failed with code ${res.exitCode}`);
+    return res.stdout;
 }
 // Spawn adb but return full streams and exit code so callers can implement fallbacks or stream output
-export function spawnAdb(args, deviceId, options = {}) {
+export async function spawnAdb(args, deviceId, options = {}) {
     const adbArgs = getAdbArgs(args, deviceId);
-    return new Promise((resolve, reject) => {
-        const { timeout: customTimeout, ...spawnOptions } = options;
-        const child = spawn(getAdbCmd(), adbArgs, spawnOptions);
-        let stdout = '';
-        let stderr = '';
-        if (child.stdout)
-            child.stdout.on('data', d => { stdout += d.toString(); });
-        if (child.stderr)
-            child.stderr.on('data', d => { stderr += d.toString(); });
-        const timeoutMs = getAdbTimeout(args, customTimeout);
-        const timeout = setTimeout(() => {
-            try {
-                child.kill();
-            }
-            catch { }
-            reject(new Error(`ADB command timed out after ${timeoutMs}ms: ${args.join(' ')}`));
-        }, timeoutMs);
-        child.on('close', (code) => {
-            clearTimeout(timeout);
-            resolve({ stdout: stdout.trim(), stderr: stderr.trim(), code });
-        });
-        child.on('error', (err) => {
-            clearTimeout(timeout);
-            reject(err);
-        });
-    });
+    const timeoutMs = getAdbTimeout(args, options.timeout);
+    const res = await execCmd(getAdbCmd(), adbArgs, { timeout: timeoutMs, env: options.env, cwd: typeof options.cwd === 'string' ? options.cwd : undefined, shell: !!options.shell });
+    return { stdout: res.stdout, stderr: res.stderr, code: res.exitCode };
 }
 export function getDeviceInfo(deviceId, metadata = {}) {
     return {

package/dist/utils/exec.js

@@ -0,0 +1,34 @@
+import { spawn } from 'child_process';
+export async function execCmd(cmd, args, opts = {}) {
+    const { timeout = 0, env, cwd, shell } = opts;
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, { env: { ...process.env, ...(env || {}) }, cwd, shell });
+        let stdout = '';
+        let stderr = '';
+        if (child.stdout)
+            child.stdout.on('data', (d) => { stdout += d.toString(); });
+        if (child.stderr)
+            child.stderr.on('data', (d) => { stderr += d.toString(); });
+        let timedOut = false;
+        const timer = timeout && timeout > 0 ? setTimeout(() => {
+            timedOut = true;
+            try {
+                child.kill();
+            }
+            catch { }
+            resolve({ exitCode: null, stdout: stdout.trim(), stderr: stderr.trim() });
+        }, timeout) : null;
+        child.on('close', (code) => {
+            if (timer)
+                clearTimeout(timer);
+            if (timedOut)
+                return;
+            resolve({ exitCode: code, stdout: stdout.trim(), stderr: stderr.trim() });
+        });
+        child.on('error', (err) => {
+            if (timer)
+                clearTimeout(timer);
+            reject(err);
+        });
+    });
+}