@sensaiorg/adapter-android 0.1.0

package/dist/android-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"android-adapter.d.ts","sourceRoot":"","sources":["../src/android-adapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EACV,gBAAgB,EAChB,WAAW,EACX,YAAY,EACZ,oBAAoB,EACpB,gBAAgB,EAChB,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,EACjB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAGtE,MAAM,WAAW,oBAAoB;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,qBAAa,cAAe,YAAW,gBAAgB;IACrD,QAAQ,CAAC,QAAQ,EAAG,SAAS,CAAU;IACvC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,oBAAoB,CAUzC;IAEF,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAoB;IACtD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;IAGxD,QAAQ,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI,CAAQ;IACvC,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAQ;IAC1C,QAAQ,CAAC,WAAW,EAAE,oBAAoB,GAAG,IAAI,CAAQ;IACzD,QAAQ,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAAQ;IACjD,QAAQ,CAAC,WAAW,EAAE,oBAAoB,GAAG,IAAI,CAAQ;IACzD,QAAQ,CAAC,UAAU,EAAE,mBAAmB,GAAG,IAAI,CAAQ;IACvD,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAQ;gBAEvC,MAAM,GAAE,oBAAyB;IAiBvC,UAAU,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAsB7C,QAAQ,IAAI,IAAI;IAIhB,WAAW,IAAI,OAAO;IAItB;;;OAGG;IACH,oBAAoB,IAAI,iBAAiB;IAIzC;;;OAGG;IACH,qBAAqB,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;CAM/C"}

package/dist/android-adapter.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * AndroidAdapter — implements IPlatformAdapter for Android devices/emulators.
+ *
+ * Phase 1: All tools work via ADB commands (uiautomator, logcat, input, dumpsys)
+ * Phase 2: On-device agent provides faster UI tree, React Native inspection, network capture
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidAdapter = void 0;
+const connection_manager_js_1 = require("./transport/connection-manager.js");
+const index_js_1 = require("./tools/index.js");
+class AndroidAdapter {
+    platform = "android";
+    displayName;
+    capabilities = {
+        uiTree: true,
+        logs: true,
+        interaction: true,
+        network: false, // Phase 2 (agent needed)
+        performance: true,
+        screenshot: true,
+        appState: false, // Phase 2 (agent needed)
+        hotReload: true,
+        evalCode: false,
+    };
+    connectionManager;
+    config;
+    // Providers — implemented inline for now, will be extracted to separate classes
+    ui = null; // TODO: Extract from tools/ui-tree.ts
+    logs = null; // TODO: Extract from tools/logcat.ts
+    interaction = null; // TODO: Extract from tools/interaction.ts
+    network = null;
+    performance = null;
+    screenshot = null;
+    appState = null;
+    constructor(config = {}) {
+        this.config = {
+            adbDevice: config.adbDevice ?? process.env.ADB_DEVICE ?? "emulator-5554",
+            adbPath: config.adbPath ?? process.env.ADB_PATH ?? "adb",
+            agentPort: config.agentPort ?? parseInt(process.env.DEBUG_AGENT_PORT ?? "8463", 10),
+            targetPackage: config.targetPackage ?? process.env.TARGET_PACKAGE ?? "com.chronocrew",
+        };
+        this.displayName = `Android (${this.config.adbDevice})`;
+        this.connectionManager = new connection_manager_js_1.ConnectionManager(this.config.adbPath, this.config.adbDevice, this.config.agentPort);
+    }
+    async initialize() {
+        const status = await this.connectionManager.initialize();
+        // Update capabilities if agent is available
+        if (status.agent) {
+            this.capabilities.network = true;
+            this.capabilities.appState = true;
+        }
+        return {
+            platform: "android",
+            device: status.device,
+            connected: status.adb,
+            capabilities: this.capabilities,
+            details: {
+                adb: status.adb,
+                agent: status.agent,
+                targetPackage: this.config.targetPackage,
+            },
+        };
+    }
+    shutdown() {
+        this.connectionManager.shutdown();
+    }
+    isConnected() {
+        return this.connectionManager.getStatus().adb;
+    }
+    /**
+     * Get the ConnectionManager for direct tool access.
+     * Used during the migration period before full provider extraction.
+     */
+    getConnectionManager() {
+        return this.connectionManager;
+    }
+    /**
+     * Register Android-only MCP tools.
+     * These have no cross-platform equivalent.
+     */
+    registerPlatformTools(server) {
+        const cm = this.connectionManager;
+        // Register all 22 Android debugging tools
+        (0, index_js_1.registerAllTools)(server, cm);
+    }
+}
+exports.AndroidAdapter = AndroidAdapter;
+//# sourceMappingURL=android-adapter.js.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * @sensai/adapter-android — Android platform adapter for SensAI.
+ *
+ * Provides 22 debugging tools via ADB (Phase 1) and on-device agent (Phase 2).
+ * This adapter wraps the original EmuDebug MCP server tools.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidAdapter = void 0;
+var android_adapter_js_1 = require("./android-adapter.js");
+Object.defineProperty(exports, "AndroidAdapter", { enumerable: true, get: function () { return android_adapter_js_1.AndroidAdapter; } });
+//# sourceMappingURL=index.js.map

package/dist/tools/accessibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessibility.d.ts","sourceRoot":"","sources":["../../src/tools/accessibility.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AA8B5E,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,iBAAiB,GAAG,IAAI,CAuDzF"}

package/dist/tools/accessibility.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * Accessibility Tool - Retrieve the Android accessibility tree.
+ *
+ * Uses `adb shell dumpsys accessibility` to get the accessibility service's
+ * view of the screen, which is richer than uiautomator for a11y auditing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAccessibilityTools = registerAccessibilityTools;
+// A11yNode type reserved for Phase 2 structured accessibility tree parsing.
+/**
+ * Parse the raw accessibility dump into a structured tree.
+ * The dump format is indentation-based with key: value pairs.
+ */
+function parseAccessibilityDump(raw) {
+    const lines = raw.split("\n");
+    const services = [];
+    let nodeCount = 0;
+    for (const line of lines) {
+        if (line.includes("Service[")) {
+            const match = line.match(/Service\[(.+?)]/);
+            if (match)
+                services.push(match[1]);
+        }
+        if (line.includes("className:") || line.includes("class:")) {
+            nodeCount++;
+        }
+    }
+    return {
+        services,
+        windows: raw,
+        nodeCount,
+    };
+}
+function registerAccessibilityTools(server, cm) {
+    server.tool("get_accessibility", "Get the Android accessibility tree for the current screen. Shows which elements are accessible, their roles, states, and actions. Useful for auditing screen reader compatibility.", {}, async () => {
+        try {
+            // Try the agent first for a richer accessibility tree
+            if (cm.agent.isConnected()) {
+                try {
+                    const result = await cm.agent.call("getAccessibilityTree");
+                    return {
+                        content: [{ type: "text", text: JSON.stringify(result) }],
+                    };
+                }
+                catch {
+                    // Fall through to ADB
+                }
+            }
+            // ADB fallback: use accessibility dumpsys
+            const dump = await cm.adb.shell("dumpsys accessibility");
+            const parsed = parseAccessibilityDump(dump);
+            // Also get window info for additional context
+            let windowInfo = "";
+            try {
+                windowInfo = await cm.adb.shell("dumpsys window windows | head -50");
+            }
+            catch {
+                // Non-critical
+            }
+            const result = {
+                accessibilityServices: parsed.services,
+                estimatedNodeCount: parsed.nodeCount,
+                currentWindow: windowInfo.trim(),
+                rawDump: parsed.windows,
+                note: "For a structured accessibility tree, install the EmuDebug on-device agent (Phase 2).",
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(result) }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error getting accessibility tree: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=accessibility.js.map

package/dist/tools/adb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adb.d.ts","sourceRoot":"","sources":["../../src/tools/adb.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAG5E,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,iBAAiB,GAAG,IAAI,CA8D/E"}

package/dist/tools/adb.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * ADB Passthrough Tool - Execute safe ADB commands on the connected device.
+ *
+ * Commands are validated against an allowlist before execution to prevent
+ * destructive operations. See util/safety.ts for the allowlist.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAdbTools = registerAdbTools;
+const zod_1 = require("zod");
+const safety_js_1 = require("../util/safety.js");
+function registerAdbTools(server, cm) {
+    server.tool("run_adb", "Execute an ADB command on the connected device. Commands are validated against a safety allowlist. Allowed: shell, pull, push, install, uninstall, logcat, bugreport, devices, forward, reverse. Blocked: root, remount, reboot-bootloader, sideload, and destructive shell commands.", {
+        command: zod_1.z
+            .string()
+            .describe("ADB command to execute (without the leading 'adb -s <device>' prefix). " +
+            "Example: 'shell ls /sdcard' or 'logcat -d -t 50'"),
+        timeoutMs: zod_1.z.number().optional().describe("Timeout in milliseconds (default: 30000, max: 60000)"),
+    }, async (params) => {
+        try {
+            const args = (0, safety_js_1.parseCommandString)(params.command);
+            // Validate against safety allowlist
+            const validation = (0, safety_js_1.validateAdbCommand)(args);
+            if (!validation.allowed) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                success: false,
+                                error: "Command blocked by safety check",
+                                reason: validation.reason,
+                            }),
+                        },
+                    ],
+                };
+            }
+            const timeoutMs = Math.min(params.timeoutMs ?? 30_000, 60_000);
+            const output = await cm.adb.exec(args, timeoutMs);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            command: `adb ${args.join(" ")}`,
+                            output: output.trim(),
+                        }),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `ADB command error: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=adb.js.map

package/dist/tools/app-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-state.d.ts","sourceRoot":"","sources":["../../src/tools/app-state.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAe5E,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,iBAAiB,GAAG,IAAI,CAqKpF"}

package/dist/tools/app-state.js

@@ -0,0 +1,173 @@
+"use strict";
+/**
+ * App State Tool - Inspect the target application's internal state.
+ *
+ * Retrieves AsyncStorage, React Query cache, navigation state, auth tokens,
+ * theme, feature flags, and offline queue data from the running app.
+ *
+ * Requires the on-device agent for full data. In Phase 1, reads what is
+ * accessible via ADB (SharedPreferences, app data files).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAppStateTools = registerAppStateTools;
+const zod_1 = require("zod");
+/** State categories that can be requested. */
+const STATE_CATEGORIES = [
+    "asyncStorage",
+    "queryCache",
+    "navigation",
+    "auth",
+    "theme",
+    "featureFlags",
+    "offlineQueue",
+];
+function registerAppStateTools(server, cm) {
+    server.tool("get_app_state", "Inspect the target app's internal state including AsyncStorage, React Query cache, navigation state, auth info, theme, feature flags, and offline queue. Select specific categories or get all.", {
+        categories: zod_1.z
+            .array(zod_1.z.enum(STATE_CATEGORIES))
+            .optional()
+            .describe("Which state categories to retrieve (default: all)"),
+        asyncStorageKeys: zod_1.z
+            .array(zod_1.z.string())
+            .optional()
+            .describe("Specific AsyncStorage keys to read (default: all)"),
+        queryCacheFilter: zod_1.z.string().optional().describe("Filter query cache by key prefix"),
+    }, async (params) => {
+        const categories = (params.categories ?? [...STATE_CATEGORIES]);
+        const targetPackage = process.env.TARGET_PACKAGE ?? "com.emudebug.target";
+        // Phase 2: agent provides full app state
+        if (cm.agent.isConnected()) {
+            try {
+                const result = await cm.agent.call("getAppState", {
+                    categories,
+                    asyncStorageKeys: params.asyncStorageKeys,
+                    queryCacheFilter: params.queryCacheFilter,
+                });
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result) }],
+                };
+            }
+            catch (err) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Agent error getting app state: ${err instanceof Error ? err.message : String(err)}. Falling back to ADB.`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        // Phase 1: limited state via ADB
+        try {
+            const state = {
+                _phase1Note: "Limited app state available via ADB. Install the on-device agent for full " +
+                    "AsyncStorage, React Query cache, navigation, and auth state inspection.",
+            };
+            // AsyncStorage: RN stores in SQLite database (accessible if debuggable or rooted)
+            if (categories.includes("asyncStorage")) {
+                try {
+                    const dbPath = `/data/data/${targetPackage}/databases/RKStorage`;
+                    const output = await cm.adb.shell(`run-as ${targetPackage} sqlite3 ${dbPath} "SELECT key, value FROM catalystLocalStorage LIMIT 50;"`);
+                    const rows = {};
+                    for (const line of output.trim().split("\n")) {
+                        const sep = line.indexOf("|");
+                        if (sep > 0) {
+                            rows[line.slice(0, sep)] = line.slice(sep + 1);
+                        }
+                    }
+                    state.asyncStorage = {
+                        entries: rows,
+                        count: Object.keys(rows).length,
+                        note: "Retrieved via run-as + sqlite3 (requires debuggable app).",
+                    };
+                }
+                catch {
+                    state.asyncStorage = {
+                        error: "Cannot read AsyncStorage via ADB. App may not be debuggable.",
+                        hint: "Use the on-device agent or ensure the app has android:debuggable=true.",
+                    };
+                }
+            }
+            // SharedPreferences: accessible via run-as
+            if (categories.includes("featureFlags") || categories.includes("theme")) {
+                try {
+                    const prefsDir = `/data/data/${targetPackage}/shared_prefs/`;
+                    const files = await cm.adb.shell(`run-as ${targetPackage} ls ${prefsDir}`);
+                    const prefsFiles = files.trim().split("\n").filter(Boolean);
+                    const prefs = {};
+                    for (const file of prefsFiles.slice(0, 5)) {
+                        try {
+                            const content = await cm.adb.shell(`run-as ${targetPackage} cat ${prefsDir}${file}`);
+                            prefs[file] = content.trim();
+                        }
+                        catch {
+                            prefs[file] = "(unreadable)";
+                        }
+                    }
+                    if (categories.includes("featureFlags")) {
+                        state.featureFlags = { sharedPreferences: prefs };
+                    }
+                    if (categories.includes("theme")) {
+                        state.theme = { sharedPreferences: prefs };
+                    }
+                }
+                catch {
+                    if (categories.includes("featureFlags")) {
+                        state.featureFlags = { error: "Cannot read SharedPreferences via ADB." };
+                    }
+                    if (categories.includes("theme")) {
+                        state.theme = { error: "Cannot read SharedPreferences via ADB." };
+                    }
+                }
+            }
+            // Navigation: infer from activity stack
+            if (categories.includes("navigation")) {
+                try {
+                    const activityDump = await cm.adb.shell(`dumpsys activity activities | grep -A5 "mResumedActivity\\|topResumedActivity"`);
+                    state.navigation = {
+                        currentActivity: activityDump.trim(),
+                        note: "Full React Navigation state requires the on-device agent.",
+                    };
+                }
+                catch {
+                    state.navigation = { error: "Cannot determine current activity." };
+                }
+            }
+            // Auth: check for token files (surface-level only)
+            if (categories.includes("auth")) {
+                state.auth = {
+                    note: "Auth token inspection requires the on-device agent. " +
+                        "Check AsyncStorage for token keys or use get_logcat with auth-related tags.",
+                };
+            }
+            // Query cache and offline queue require the agent
+            if (categories.includes("queryCache")) {
+                state.queryCache = {
+                    note: "React Query cache inspection requires the on-device agent.",
+                };
+            }
+            if (categories.includes("offlineQueue")) {
+                state.offlineQueue = {
+                    note: "Offline queue inspection requires the on-device agent.",
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(state) }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error getting app state: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=app-state.js.map

package/dist/tools/diagnose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnose.d.ts","sourceRoot":"","sources":["../../src/tools/diagnose.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAM5E,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,iBAAiB,GAAG,IAAI,CA+HpF"}

package/dist/tools/diagnose.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * Diagnose Tool - Composite screen diagnosis.
+ *
+ * Combines multiple data sources into a single comprehensive report:
+ * screen name, all visible text, interactive elements, recent errors,
+ * and app state summary. Ideal for understanding the current app state
+ * in one call.
+ *
+ * Optimized: runs independent ADB calls in parallel to minimize latency.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDiagnoseTools = registerDiagnoseTools;
+const ui_tree_parser_js_1 = require("../util/ui-tree-parser.js");
+const text_extractor_js_1 = require("../util/text-extractor.js");
+const logcat_parser_js_1 = require("../util/logcat-parser.js");
+const ui_tree_js_1 = require("./ui-tree.js");
+function registerDiagnoseTools(server, cm) {
+    server.tool("diagnose_screen", "Comprehensive screen diagnosis: returns the current screen/activity name, all visible text, interactive elements (buttons, inputs), recent errors from logcat, and a summary of app state. One-stop tool for understanding what's on screen.", {}, async () => {
+        const targetPackage = process.env.TARGET_PACKAGE ?? "com.emudebug.target";
+        const diagnosis = {};
+        // Run independent data fetches in PARALLEL for speed
+        const [activityResult, treeResult, logcatResult, processResult] = await Promise.allSettled([
+            // 1. Current activity
+            cm.adb.shell("dumpsys activity activities | grep mResumedActivity"),
+            // 2. UI tree (uses cache if fresh)
+            (0, ui_tree_js_1.getCachedTree)(cm, { visibleOnly: true, includeSystemUI: false }),
+            // 3. Recent logcat + PID lookup (chained)
+            (async () => {
+                const [raw, pidOutput] = await Promise.allSettled([
+                    cm.adb.shell("logcat -d -v threadtime -t 500", 10_000),
+                    cm.adb.shell(`pidof ${targetPackage}`),
+                ]);
+                return {
+                    raw: raw.status === "fulfilled" ? raw.value : "",
+                    pid: pidOutput.status === "fulfilled" ? pidOutput.value.trim() : null,
+                };
+            })(),
+            // 4. Process state
+            cm.adb.shell(`ps -A | grep ${targetPackage}`),
+        ]);
+        // Process activity result
+        if (activityResult.status === "fulfilled") {
+            const match = activityResult.value.match(/u0\s+(.+?)\s+\w+/);
+            diagnosis.currentActivity = match ? match[1].trim() : activityResult.value.trim();
+        }
+        else {
+            diagnosis.currentActivity = "unknown";
+        }
+        // Process UI tree result
+        if (treeResult.status === "fulfilled") {
+            const tree = treeResult.value;
+            const flat = (0, ui_tree_parser_js_1.flattenTree)(tree);
+            diagnosis.screenText = (0, text_extractor_js_1.extractTextStrings)(tree);
+            diagnosis.interactiveElements = flat
+                .filter((n) => n.clickable || n.focusable || n.scrollable)
+                .map((n) => ({
+                type: n.className.split(".").pop(),
+                text: n.text || n.contentDescription || n.resourceId || "(unnamed)",
+                resourceId: n.resourceId,
+                clickable: n.clickable,
+                enabled: n.enabled,
+                bounds: n.bounds,
+                center: n.bounds
+                    ? {
+                        x: Math.round((n.bounds.left + n.bounds.right) / 2),
+                        y: Math.round((n.bounds.top + n.bounds.bottom) / 2),
+                    }
+                    : null,
+            }));
+            diagnosis.uiSummary = {
+                totalNodes: flat.length,
+                textNodes: flat.filter((n) => n.text).length,
+                clickableNodes: flat.filter((n) => n.clickable).length,
+                inputFields: flat.filter((n) => n.className.includes("EditText") || n.className.includes("TextInput")).length,
+                scrollableContainers: flat.filter((n) => n.scrollable).length,
+            };
+        }
+        else {
+            diagnosis.uiError = `Failed to get UI tree: ${treeResult.reason}`;
+        }
+        // Process logcat result
+        if (logcatResult.status === "fulfilled") {
+            const { raw, pid } = logcatResult.value;
+            if (raw) {
+                const entries = (0, logcat_parser_js_1.parseLogcat)(raw);
+                const errors = (0, logcat_parser_js_1.filterByLevel)(entries, "E");
+                const appErrors = pid
+                    ? errors.filter((e) => e.pid === pid)
+                    : errors.filter((e) => e.tag.includes("ReactNativeJS") ||
+                        e.tag.includes("ReactNative") ||
+                        e.tag.includes(targetPackage));
+                diagnosis.recentErrors = appErrors.slice(-10).map((e) => ({
+                    timestamp: e.timestamp,
+                    tag: e.tag,
+                    message: e.message,
+                }));
+                diagnosis.errorCount = appErrors.length;
+            }
+            else {
+                diagnosis.recentErrors = [];
+                diagnosis.errorCount = 0;
+            }
+        }
+        else {
+            diagnosis.recentErrors = [];
+            diagnosis.errorCount = 0;
+        }
+        // Process state result
+        if (processResult.status === "fulfilled") {
+            diagnosis.processInfo = processResult.value.trim() || "App not running";
+        }
+        else {
+            diagnosis.processInfo = "Unable to determine process state";
+        }
+        // Agent status (synchronous)
+        diagnosis.agentConnected = cm.agent.isConnected();
+        if (!cm.agent.isConnected()) {
+            diagnosis.agentNote =
+                "On-device agent not connected. Some data (RN components, app state, network) " +
+                    "is limited to ADB-based inspection.";
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(diagnosis) }],
+        };
+    });
+}
+//# sourceMappingURL=diagnose.js.map

package/dist/tools/hot-reload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hot-reload.d.ts","sourceRoot":"","sources":["../../src/tools/hot-reload.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAK5E,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,iBAAiB,GAAG,IAAI,CAwFrF"}