mobile-debug-mcp 0.4.0 → 0.5.0

package/smoke-test.js

@@ -0,0 +1,102 @@
+import { startAndroidApp, terminateAndroidApp, captureAndroidScreen, getAndroidLogs } from "./src/android.js";
+import { startIOSApp, terminateIOSApp, captureIOSScreenshot, getIOSLogs } from "./src/ios.js";
+import fs from "fs/promises";
+async function main() {
+    const args = process.argv.slice(2);
+    const platform = args[0]; // Cast to string first
+    const appId = args[1];
+    if ((platform !== "android" && platform !== "ios") || !appId) {
+        console.error("Usage: npx tsx smoke-test.ts <android|ios> <appId>");
+        process.exit(1);
+    }
+    console.log(`\n🚀 Starting smoke test for ${platform} app: ${appId}`);
+    try {
+        // 1. Start App
+        console.log(`[1/4] Starting app...`);
+        let startResult;
+        let launchTimeMs;
+        if (platform === "android") {
+            const result = await startAndroidApp(appId);
+            startResult = result.appStarted;
+            launchTimeMs = result.launchTimeMs;
+        }
+        else {
+            const result = await startIOSApp(appId);
+            startResult = result.appStarted;
+            launchTimeMs = result.launchTimeMs;
+        }
+        if (startResult) {
+            console.log(`✅ App started successfully (Launch time: ${launchTimeMs}ms)`);
+        }
+        else {
+            throw new Error("Failed to start app");
+        }
+        // Wait for app to settle
+        console.log(`⏳ Waiting 3s for app to load...`);
+        await new Promise(r => setTimeout(r, 3000));
+        // 2. Capture Screenshot
+        console.log(`[2/4] Capturing screenshot...`);
+        let screenshotBase64;
+        let resolution;
+        if (platform === "android") {
+            const result = await captureAndroidScreen(appId);
+            screenshotBase64 = result.screenshot;
+            resolution = result.resolution;
+        }
+        else {
+            const result = await captureIOSScreenshot();
+            screenshotBase64 = result.screenshot;
+            resolution = result.resolution;
+        }
+        if (screenshotBase64) {
+            const fileName = `smoke-test-${platform}.png`;
+            await fs.writeFile(fileName, Buffer.from(screenshotBase64, 'base64'));
+            console.log(`✅ Screenshot saved to ./${fileName} (${resolution.width}x${resolution.height})`);
+        }
+        else {
+            throw new Error("Failed to capture screenshot");
+        }
+        // 3. Get Logs
+        console.log(`[3/4] Fetching logs...`);
+        let logsCount = 0;
+        let logs = [];
+        if (platform === "android") {
+            const result = await getAndroidLogs(appId, 50);
+            logsCount = result.logCount;
+            logs = result.logs;
+        }
+        else {
+            const result = await getIOSLogs();
+            logsCount = result.logCount;
+            logs = result.logs;
+        }
+        console.log(`✅ Retrieved ${logsCount} log lines`);
+        // Print last log line as sample
+        if (logs.length > 0) {
+            console.log(`   Sample: "${logs[logs.length - 1].substring(0, 80)}..."`);
+        }
+        // 4. Terminate App
+        console.log(`[4/4] Terminating app...`);
+        let termResult;
+        if (platform === "android") {
+            const result = await terminateAndroidApp(appId);
+            termResult = result.appTerminated;
+        }
+        else {
+            const result = await terminateIOSApp(appId);
+            termResult = result.appTerminated;
+        }
+        if (termResult) {
+            console.log(`✅ App terminated successfully`);
+        }
+        else {
+            throw new Error("Failed to terminate app");
+        }
+        console.log(`\n✨ Smoke test COMPLETED SUCCESSFULLY! ✨\n`);
+    }
+    catch (error) {
+        console.error(`\n❌ Smoke test FAILED:`, error);
+        process.exit(1);
+    }
+}
+main();

package/smoke-test.ts

@@ -0,0 +1,115 @@
+import { startAndroidApp, terminateAndroidApp, captureAndroidScreen, getAndroidLogs } from "./src/android.js";
+import { startIOSApp, terminateIOSApp, captureIOSScreenshot, getIOSLogs } from "./src/ios.js";
+import fs from "fs/promises";
+import path from "path";
+
+async function main() {
+  const args = process.argv.slice(2);
+  const platform = args[0] as string; // Cast to string first
+  const appId = args[1];
+
+  if ((platform !== "android" && platform !== "ios") || !appId) {
+     console.error("Usage: npx tsx smoke-test.ts <android|ios> <appId>");
+     process.exit(1);
+  }
+
+  console.log(`\n🚀 Starting smoke test for ${platform} app: ${appId}`);
+
+  try {
+    // 1. Start App
+    console.log(`[1/4] Starting app...`);
+    let startResult: boolean;
+    let launchTimeMs: number;
+
+    if (platform === "android") {
+      const result = await startAndroidApp(appId);
+      startResult = result.appStarted;
+      launchTimeMs = result.launchTimeMs;
+    } else {
+      const result = await startIOSApp(appId);
+      startResult = result.appStarted;
+      launchTimeMs = result.launchTimeMs;
+    }
+    
+    if (startResult) {
+      console.log(`✅ App started successfully (Launch time: ${launchTimeMs}ms)`);
+    } else {
+      throw new Error("Failed to start app");
+    }
+
+    // Wait for app to settle
+    console.log(`⏳ Waiting 3s for app to load...`);
+    await new Promise(r => setTimeout(r, 3000));
+
+    // 2. Capture Screenshot
+    console.log(`[2/4] Capturing screenshot...`);
+    let screenshotBase64: string;
+    let resolution: { width: number; height: number };
+
+    if (platform === "android") {
+      const result = await captureAndroidScreen();
+      screenshotBase64 = result.screenshot;
+      resolution = result.resolution;
+    } else {
+      const result = await captureIOSScreenshot();
+      screenshotBase64 = result.screenshot;
+      resolution = result.resolution;
+    }
+    
+    if (screenshotBase64) {
+      const fileName = `smoke-test-${platform}.png`;
+      await fs.writeFile(fileName, Buffer.from(screenshotBase64, 'base64'));
+      console.log(`✅ Screenshot saved to ./${fileName} (${resolution.width}x${resolution.height})`);
+    } else {
+      throw new Error("Failed to capture screenshot");
+    }
+
+    // 3. Get Logs
+    console.log(`[3/4] Fetching logs...`);
+    let logsCount = 0;
+    let logs: string[] = [];
+
+    if (platform === "android") {
+       const result = await getAndroidLogs(appId, 50);
+       logsCount = result.logCount;
+       logs = result.logs;
+    } else {
+       const result = await getIOSLogs();
+       logsCount = result.logCount;
+       logs = result.logs;
+    }
+    
+    console.log(`✅ Retrieved ${logsCount} log lines`);
+    // Print last log line as sample
+    if (logs.length > 0) {
+      console.log(`   Sample: "${logs[logs.length - 1].substring(0, 80)}..."`);
+    }
+
+    // 4. Terminate App
+    console.log(`[4/4] Terminating app...`);
+    let termResult: boolean;
+    
+    if (platform === "android") {
+      const result = await terminateAndroidApp(appId);
+      termResult = result.appTerminated;
+    } else {
+      const result = await terminateIOSApp(appId);
+      termResult = result.appTerminated;
+    }
+
+    if (termResult) {
+      console.log(`✅ App terminated successfully`);
+    } else {
+      throw new Error("Failed to terminate app");
+    }
+
+    console.log(`\n✨ Smoke test COMPLETED SUCCESSFULLY! ✨\n`);
+
+  } catch (error) {
+    console.error(`\n❌ Smoke test FAILED:`, error);
+    process.exit(1);
+  }
+}
+
+main();
+

package/src/android.ts

@@ -1,48 +1,222 @@
-import { exec } from "child_process"
+import { execFile, spawn } from "child_process"
+import { StartAppResponse, GetLogsResponse, CaptureAndroidScreenResponse, TerminateAppResponse, RestartAppResponse, ResetAppDataResponse, DeviceInfo } from "./types.js"
 
 const ADB = process.env.ADB_PATH || "adb"
 
-export function startAndroidApp(pkg: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    exec(
-      `${ADB} shell monkey -p ${pkg} -c android.intent.category.LAUNCHER 1`,
-      (err, stdout, stderr) => {
-        if (err) reject(stderr)
-        else resolve(stdout)
-      }
-    )
-  })
+// Helper to construct ADB args with optional device ID
+function getAdbArgs(args: string[], deviceId?: string): string[] {
+  if (deviceId) {
+    return ['-s', deviceId, ...args]
+  }
+  return args
 }
 
-export function getAndroidLogs(pkg: string, lines = 200): Promise<string> {
+function execAdb(args: string[], deviceId?: string, options: any = {}): Promise<string> {
+  const adbArgs = getAdbArgs(args, deviceId)
   return new Promise((resolve, reject) => {
-    exec(`${ADB} shell pidof -s ${pkg}`, (pidErr, pidStdout, pidStderr) => {
-      if (pidErr || !pidStdout.trim()) {
-        reject(pidStderr || "App process not running")
-        return
-      }
+    // Use spawn instead of execFile for better stream control and to avoid potential buffering hangs
+    const child = spawn(ADB, adbArgs, options)
+    
+    let stdout = ''
+    let stderr = ''
 
-      const pid = pidStdout.trim()
+    if (child.stdout) {
+      child.stdout.on('data', (data) => {
+        stdout += data.toString()
+      })
+    }
 
-      exec(`${ADB} logcat -d --pid=${pid} -t ${lines} -v threadtime`, (err, stdout, stderr) => {
-        if (err) reject(stderr || err.message)
-        else resolve(stdout)
+    if (child.stderr) {
+      child.stderr.on('data', (data) => {
+        stderr += data.toString()
       })
+    }
+
+    const timeoutMs = args.includes('logcat') ? 10000 : 2000 // Shorter timeout for metadata queries
+    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)
     })
   })
 }
 
-export async function getAndroidCrash(pkg: string, lines = 200): Promise<string> {
+function getDeviceInfo(deviceId: string, metadata: Partial<DeviceInfo> = {}): DeviceInfo {
+  return { 
+    platform: 'android', 
+    id: deviceId || 'default', 
+    osVersion: metadata.osVersion || '', 
+    model: metadata.model || '', 
+    simulator: metadata.simulator || false 
+  }
+}
+
+export async function getAndroidDeviceMetadata(appId: string, deviceId?: string): Promise<DeviceInfo> {
   try {
-    const logs = await getAndroidLogs(pkg, lines)
-    const crashLines = logs
-      .split('\n')
-      .filter(line => line.includes('FATAL EXCEPTION'))
-    if (crashLines.length === 0) {
-      return "No crashes found."
+    // Run these in parallel to avoid sequential timeouts
+    const [osVersion, model, simOutput] = await Promise.all([
+      execAdb(['shell', 'getprop', 'ro.build.version.release'], deviceId).catch(() => ''),
+      execAdb(['shell', 'getprop', 'ro.product.model'], deviceId).catch(() => ''),
+      execAdb(['shell', 'getprop', 'ro.kernel.qemu'], deviceId).catch(() => '0')
+    ])
+    
+    const simulator = simOutput === '1'
+    return { platform: 'android', id: deviceId || 'default', osVersion, model, simulator }
+  } catch (e) {
+    return { platform: 'android', id: deviceId || 'default', osVersion: '', model: '', simulator: false }
+  }
+}
+
+export async function startAndroidApp(appId: string, deviceId?: string): Promise<StartAppResponse> {
+  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 }
+}
+
+export async function terminateAndroidApp(appId: string, deviceId?: string): Promise<TerminateAppResponse> {
+  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 }
+}
+
+export async function restartAndroidApp(appId: string, deviceId?: string): Promise<RestartAppResponse> {
+  await terminateAndroidApp(appId, deviceId)
+  const startResult = await startAndroidApp(appId, deviceId)
+  return {
+    device: startResult.device,
+    appRestarted: startResult.appStarted,
+    launchTimeMs: startResult.launchTimeMs
+  }
+}
+
+export async function resetAndroidAppData(appId: string, deviceId?: string): Promise<ResetAppDataResponse> {
+  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' }
+}
+
+export async function getAndroidLogs(appId?: string, lines = 200, deviceId?: string): Promise<GetLogsResponse> {
+  const metadata = await getAndroidDeviceMetadata(appId || "", deviceId)
+  const deviceInfo = getDeviceInfo(deviceId || 'default', metadata)
+
+  try {
+    // We'll skip PID lookup for now to avoid potential hangs with 'pidof' on some emulators
+    // and rely on robust string matching against the log line.
+    
+    // Get logs
+    const stdout = await execAdb(['logcat', '-d', '-t', lines.toString(), '-v', 'threadtime'], deviceId)
+    const allLogs = stdout.split('\n')
+    
+    let filteredLogs = allLogs
+    if (appId) {
+       // Filter by checking if the line contains the appId string.
+       const matchingLogs = allLogs.filter(line => line.includes(appId))
+       
+       if (matchingLogs.length > 0) {
+         filteredLogs = matchingLogs
+       } else {
+         // Fallback: if no logs match the appId, return the raw logs (last N lines)
+         // This matches the behavior of the "working" version provided by the user,
+         // ensuring they at least see system activity if the app is silent or crashing early.
+         filteredLogs = allLogs
+       }
     }
-    return crashLines.join('\n')
-  } catch (error) {
-    return `Error retrieving crash logs: ${error}`
+    
+    return { device: deviceInfo, logs: filteredLogs, logCount: filteredLogs.length }
+  } catch (e) {
+    console.error("Error fetching logs:", e)
+    return { device: deviceInfo, logs: [], logCount: 0 }
   }
+}
+
+export async function captureAndroidScreen(deviceId?: string): Promise<CaptureAndroidScreenResponse> {
+  const metadata = await getAndroidDeviceMetadata("", deviceId)
+  const deviceInfo: DeviceInfo = getDeviceInfo(deviceId || 'default', metadata)
+
+  return new Promise((resolve, reject) => {
+    const adbArgs = getAdbArgs(['exec-out', 'screencap', '-p'], deviceId)
+    
+    // Using spawn for screencap as well to ensure consistent process handling
+    const child = spawn(ADB, adbArgs)
+    
+    const chunks: Buffer[] = []
+    let stderr = ''
+
+    child.stdout.on('data', (chunk) => {
+      chunks.push(Buffer.from(chunk))
+    })
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString()
+    })
+
+    const timeout = setTimeout(() => {
+      child.kill()
+      reject(new Error(`ADB screencap timed out after 10s`))
+    }, 10000)
+
+    child.on('close', (code) => {
+      clearTimeout(timeout)
+      if (code !== 0) {
+        reject(new Error(stderr.trim() || `Screencap failed with code ${code}`))
+        return
+      }
+
+      const screenshotBuffer = Buffer.concat(chunks)
+      const screenshotBase64 = screenshotBuffer.toString('base64')
+
+      // Get resolution
+      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,
+            resolution: { width, height }
+          })
+        })
+        .catch(() => {
+           resolve({
+            device: deviceInfo,
+            screenshot: screenshotBase64,
+            resolution: { width: 0, height: 0 }
+          })
+        })
+    })
+
+    child.on('error', (err) => {
+      clearTimeout(timeout)
+      reject(err)
+    })
+  })
 }