mobile-debug-mcp 0.10.0 → 0.12.0

package/dist/android/run.js

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

package/dist/android/utils.js

@@ -1,7 +1,46 @@
 import { spawn } from 'child_process';
-import { createWriteStream, promises as fsPromises } from 'fs';
+import { promises as fsPromises, existsSync } from 'fs';
 import path from 'path';
-export const ADB = process.env.ADB_PATH || 'adb';
+import { detectJavaHome } from '../utils/java.js';
+export function getAdbCmd() { return process.env.ADB_PATH || 'adb'; }
+/**
+ * Prepare Gradle execution options for building an Android project.
+ * Returns execCmd (wrapper or gradle), base gradleArgs array, and spawn options including env.
+ */
+export async function prepareGradle(projectPath) {
+    const gradlewPath = path.join(projectPath, 'gradlew');
+    const gradleCmd = existsSync(gradlewPath) ? './gradlew' : 'gradle';
+    const execCmd = existsSync(gradlewPath) ? gradlewPath : gradleCmd;
+    const gradleArgs = ['assembleDebug'];
+    const detectedJavaHome = await detectJavaHome().catch(() => undefined);
+    const env = Object.assign({}, process.env);
+    if (detectedJavaHome) {
+        if (env.JAVA_HOME !== detectedJavaHome) {
+            env.JAVA_HOME = detectedJavaHome;
+            env.PATH = `${path.join(detectedJavaHome, 'bin')}${path.delimiter}${env.PATH || ''}`;
+        }
+        gradleArgs.push(`-Dorg.gradle.java.home=${detectedJavaHome}`);
+        gradleArgs.push('--no-daemon');
+        env.GRADLE_JAVA_HOME = detectedJavaHome;
+    }
+    try {
+        delete env.SHELL;
+    }
+    catch { }
+    const useWrapper = existsSync(gradlewPath);
+    const spawnOpts = { cwd: projectPath, env };
+    if (useWrapper) {
+        try {
+            await fsPromises.chmod(gradlewPath, 0o755);
+        }
+        catch { }
+        spawnOpts.shell = false;
+    }
+    else {
+        spawnOpts.shell = true;
+    }
+    return { execCmd, gradleArgs, spawnOpts };
+}
 // Helper to construct ADB args with optional device ID
 function getAdbArgs(args, deviceId) {
     if (deviceId) {
@@ -33,7 +72,7 @@ export function execAdb(args, deviceId, options = {}) {
         // 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(ADB, adbArgs, spawnOptions);
+        const child = spawn(getAdbCmd(), adbArgs, spawnOptions);
         let stdout = '';
         let stderr = '';
         if (child.stdout) {
@@ -73,7 +112,7 @@ export function spawnAdb(args, deviceId, options = {}) {
     const adbArgs = getAdbArgs(args, deviceId);
     return new Promise((resolve, reject) => {
         const { timeout: customTimeout, ...spawnOptions } = options;
-        const child = spawn(ADB, adbArgs, spawnOptions);
+        const child = spawn(getAdbCmd(), adbArgs, spawnOptions);
         let stdout = '';
         let stderr = '';
         if (child.stdout)
@@ -141,6 +180,21 @@ export async function getAndroidDeviceMetadata(appId, deviceId) {
         return { platform: 'android', id: deviceId || 'default', osVersion: '', model: '', simulator: false };
     }
 }
+export async function findApk(dir) {
+    const entries = await fsPromises.readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const e of entries) {
+        const full = path.join(dir, e.name);
+        if (e.isDirectory()) {
+            const found = await findApk(full);
+            if (found)
+                return found;
+        }
+        else if (e.isFile() && full.endsWith('.apk')) {
+            return full;
+        }
+    }
+    return undefined;
+}
 export async function listAndroidDevices(appId) {
     try {
         const devicesOutput = await execAdb(['devices', '-l']);
@@ -178,18 +232,88 @@ export async function listAndroidDevices(appId) {
         return [];
     }
 }
-// Log stream management (one stream per session)
-const activeLogStreams = new Map();
-// Test helper to register a pre-existing NDJSON file as the active stream for a session (used by unit tests)
-export function _setActiveLogStream(sessionId, file) {
-    activeLogStreams.set(sessionId, { proc: { kill: () => { } }, file });
+// UI helper utilities shared by observe/interact
+export const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+export function parseBounds(bounds) {
+    const match = bounds.match(/\[(\d+),(\d+)\]\[(\d+),(\d+)\]/);
+    if (match) {
+        return [parseInt(match[1]), parseInt(match[2]), parseInt(match[3]), parseInt(match[4])];
+    }
+    return [0, 0, 0, 0];
+}
+export function getCenter(bounds) {
+    const [x1, y1, x2, y2] = bounds;
+    return [Math.floor((x1 + x2) / 2), Math.floor((y1 + y2) / 2)];
 }
-export function _clearActiveLogStream(sessionId) {
-    activeLogStreams.delete(sessionId);
+export async function getScreenResolution(deviceId) {
+    try {
+        const output = await execAdb(['shell', 'wm', 'size'], deviceId);
+        const match = output.match(/Physical size: (\d+)x(\d+)/);
+        if (match) {
+            return { width: parseInt(match[1]), height: parseInt(match[2]) };
+        }
+    }
+    catch {
+        // ignore
+    }
+    return { width: 0, height: 0 };
+}
+export function traverseNode(node, elements, parentIndex = -1, depth = 0) {
+    if (!node)
+        return -1;
+    let currentIndex = -1;
+    if (node['@_class']) {
+        const text = node['@_text'] || null;
+        const contentDescription = node['@_content-desc'] || null;
+        const clickable = node['@_clickable'] === 'true';
+        const bounds = parseBounds(node['@_bounds'] || '[0,0][0,0]');
+        const isUseful = clickable || (text && text.length > 0) || (contentDescription && contentDescription.length > 0);
+        if (isUseful) {
+            const element = {
+                text,
+                contentDescription,
+                type: node['@_class'] || 'unknown',
+                resourceId: node['@_resource-id'] || null,
+                clickable,
+                enabled: node['@_enabled'] === 'true',
+                visible: true,
+                bounds,
+                center: getCenter(bounds),
+                depth
+            };
+            if (parentIndex !== -1) {
+                element.parentId = parentIndex;
+            }
+            elements.push(element);
+            currentIndex = elements.length - 1;
+        }
+    }
+    const nextParentIndex = currentIndex !== -1 ? currentIndex : parentIndex;
+    const nextDepth = currentIndex !== -1 ? depth + 1 : depth;
+    const childrenIndices = [];
+    if (node.node) {
+        if (Array.isArray(node.node)) {
+            node.node.forEach((child) => {
+                const childIndex = traverseNode(child, elements, nextParentIndex, nextDepth);
+                if (childIndex !== -1)
+                    childrenIndices.push(childIndex);
+            });
+        }
+        else {
+            const childIndex = traverseNode(node.node, elements, nextParentIndex, nextDepth);
+            if (childIndex !== -1)
+                childrenIndices.push(childIndex);
+        }
+    }
+    if (currentIndex !== -1 && childrenIndices.length > 0) {
+        elements[currentIndex].children = childrenIndices;
+    }
+    return currentIndex;
 }
+// Log stream management (one stream per session)
+// (Legacy active stream map removed from utils during refactor; Observe modules manage their own active streams.)
 // Robust log line parser supporting multiple logcat formats
 export function parseLogLine(line) {
-    // Collapse internal newlines so multiline stack traces are parseable as a single entry
     const rawLine = line;
     const normalizedLine = rawLine.replace(/\r?\n/g, ' ');
     const entry = { timestamp: '', level: '', tag: '', message: rawLine, _iso: null, crash: false };
@@ -292,138 +416,4 @@ export function parseLogLine(line) {
     }
     return entry;
 }
-export async function startAndroidLogStream(packageName, level = 'error', deviceId, sessionId = 'default') {
-    try {
-        // Determine PID
-        const pidOutput = await execAdb(['shell', 'pidof', packageName], deviceId).catch(() => '');
-        const pid = (pidOutput || '').trim();
-        if (!pid) {
-            return { success: false, error: 'app_not_running' };
-        }
-        // Map level to logcat filter
-        const levelMap = { error: '*:E', warn: '*:W', info: '*:I', debug: '*:D' };
-        const filter = levelMap[level] || levelMap['error'];
-        // Prevent multiple streams per session
-        if (activeLogStreams.has(sessionId)) {
-            // stop existing
-            try {
-                activeLogStreams.get(sessionId).proc.kill();
-            }
-            catch { }
-            activeLogStreams.delete(sessionId);
-        }
-        // Start logcat process
-        const args = ['logcat', `--pid=${pid}`, filter];
-        const proc = spawn(ADB, args);
-        // Prepare output file
-        const tmpDir = process.env.TMPDIR || '/tmp';
-        const file = path.join(tmpDir, `mobile-debug-log-${sessionId}.ndjson`);
-        const stream = createWriteStream(file, { flags: 'a' });
-        proc.stdout.on('data', (chunk) => {
-            const text = chunk.toString();
-            const lines = text.split(/\r?\n/).filter(Boolean);
-            for (const l of lines) {
-                const entry = parseLogLine(l);
-                stream.write(JSON.stringify(entry) + '\n');
-            }
-        });
-        proc.stderr.on('data', (chunk) => {
-            // write stderr lines as message with level 'E'
-            const text = chunk.toString();
-            const lines = text.split(/\r?\n/).filter(Boolean);
-            for (const l of lines) {
-                const entry = { timestamp: '', level: 'E', tag: 'adb', message: l };
-                stream.write(JSON.stringify(entry) + '\n');
-            }
-        });
-        proc.on('close', () => {
-            stream.end();
-            activeLogStreams.delete(sessionId);
-        });
-        activeLogStreams.set(sessionId, { proc, file });
-        return { success: true, stream_started: true };
-    }
-    catch {
-        return { success: false, error: 'log_stream_start_failed' };
-    }
-}
-export async function stopAndroidLogStream(sessionId = 'default') {
-    const entry = activeLogStreams.get(sessionId);
-    if (!entry)
-        return { success: true };
-    try {
-        entry.proc.kill();
-    }
-    catch { }
-    activeLogStreams.delete(sessionId);
-    return { success: true };
-}
-export async function readLogStreamLines(sessionId = 'default', limit = 100, since) {
-    const entry = activeLogStreams.get(sessionId);
-    if (!entry)
-        return { entries: [] };
-    try {
-        const data = await fsPromises.readFile(entry.file, 'utf8').catch(() => '');
-        if (!data)
-            return { entries: [], crash_summary: { crash_detected: false } };
-        const lines = data.split(/\r?\n/).filter(Boolean);
-        // Parse NDJSON lines into objects. Prefer fields written by parseLogLine. For backward compatibility, if _iso or crash are missing, enrich minimally here (avoid duplicating full parse logic).
-        const parsed = lines.map(l => {
-            try {
-                const obj = JSON.parse(l);
-                // Ensure _iso: if missing, try to derive using Date()
-                if (typeof obj._iso === 'undefined') {
-                    let iso = null;
-                    if (obj.timestamp) {
-                        const d = new Date(obj.timestamp);
-                        if (!isNaN(d.getTime()))
-                            iso = d.toISOString();
-                    }
-                    obj._iso = iso;
-                }
-                // Ensure crash flag: if missing, run minimal heuristic
-                if (typeof obj.crash === 'undefined') {
-                    const msg = (obj.message || '').toString();
-                    const exMatch = msg.match(/\b([A-Za-z0-9_$.]+Exception)\b/);
-                    if (/FATAL EXCEPTION/i.test(msg) || exMatch) {
-                        obj.crash = true;
-                        if (exMatch)
-                            obj.exception = exMatch[1];
-                    }
-                    else {
-                        obj.crash = false;
-                    }
-                }
-                return obj;
-            }
-            catch {
-                return { message: l, _iso: null, crash: false };
-            }
-        });
-        // Filter by since if provided (accept ISO or epoch ms)
-        let filtered = parsed;
-        if (since) {
-            let sinceMs = null;
-            // If numeric string
-            if (/^\d+$/.test(since))
-                sinceMs = Number(since);
-            else {
-                const sDate = new Date(since);
-                if (!isNaN(sDate.getTime()))
-                    sinceMs = sDate.getTime();
-            }
-            if (sinceMs !== null) {
-                filtered = parsed.filter(p => p._iso && (new Date(p._iso).getTime() >= sinceMs));
-            }
-        }
-        // Return the last `limit` entries (most recent)
-        const entries = filtered.slice(-Math.max(0, limit));
-        // Crash summary
-        const crashEntry = entries.find(e => e.crash);
-        const crash_summary = crashEntry ? { crash_detected: true, exception: crashEntry.exception, sample: crashEntry.message } : { crash_detected: false };
-        return { entries, crash_summary };
-    }
-    catch {
-        return { entries: [], crash_summary: { crash_detected: false } };
-    }
-}
+// Legacy readLogStreamLines shim removed. Use AndroidObserve.readLogStream(sessionId, limit, since) instead.