mcp-maestro-mobile-ai 1.1.0

package/src/mcp-server/tools/runTools.js

@@ -0,0 +1,357 @@
+/**
+ * Run Tools
+ * Execute Maestro tests and capture results
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { logger } from '../utils/logger.js';
+import { runMaestroFlow, checkDeviceConnection, checkAppInstalled, getConfig } from '../utils/maestro.js';
+import { validateMaestroYaml } from './validateTools.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PROJECT_ROOT = join(__dirname, '../../..');
+const OUTPUT_DIR = join(PROJECT_ROOT, 'output');
+const RESULTS_DIR = join(OUTPUT_DIR, 'results');
+
+// Store for test results
+let lastRunResults = null;
+let runCounter = 0;
+
+/**
+ * Run a single Maestro test with pre-flight checks
+ */
+export async function runTest(yamlContent, testName, options = {}) {
+  try {
+    logger.info(`Running test: ${testName}`);
+
+    // Pre-flight check: Device connection
+    const deviceStatus = await checkDeviceConnection();
+    if (!deviceStatus.connected) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              success: false,
+              name: testName,
+              error: 'No device connected',
+              details: deviceStatus.error,
+              hint: 'Start an Android emulator before running tests. Use check_device tool to verify.',
+            }),
+          },
+        ],
+      };
+    }
+
+    // Validate YAML first
+    const validation = await validateMaestroYaml(yamlContent);
+    const validationResult = JSON.parse(validation.content[0].text);
+
+    if (!validationResult.valid) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              success: false,
+              name: testName,
+              error: 'YAML validation failed',
+              validationErrors: validationResult.errors,
+              hint: 'Fix the YAML errors and try again. Common issues: missing appId, invalid syntax.',
+            }),
+          },
+        ],
+      };
+    }
+
+    // Pre-flight check: App installed
+    const appId = validationResult.config?.appId;
+    if (appId) {
+      const appStatus = await checkAppInstalled(appId);
+      if (!appStatus.installed) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify({
+                success: false,
+                name: testName,
+                error: `App not installed: ${appId}`,
+                hint: 'Install the app on the emulator before running tests.',
+              }),
+            },
+          ],
+        };
+      }
+    }
+
+    // Get retry count from options or environment
+    const config = getConfig();
+    const retries = options.retries ?? config.defaultRetries;
+
+    // Run the test with retry support
+    const result = await runMaestroFlow(yamlContent, testName, { retries });
+
+    // Store result
+    const runId = `run-${++runCounter}-${Date.now()}`;
+    lastRunResults = {
+      runId,
+      timestamp: new Date().toISOString(),
+      tests: [result],
+      summary: {
+        total: 1,
+        passed: result.success ? 1 : 0,
+        failed: result.success ? 0 : 1,
+      },
+    };
+
+    // Save results to file
+    await saveResults(lastRunResults);
+
+    // Auto-cleanup old results
+    await autoCleanupResults();
+
+    logger.info(`Test ${result.success ? 'passed' : 'failed'}: ${testName}`);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: result.success,
+            name: testName,
+            duration: result.duration,
+            attempts: result.attempts || 1,
+            error: result.error || null,
+            screenshot: result.screenshot || null,
+            output: result.output ? result.output.substring(0, 500) : null,
+            runId,
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    logger.error(`Test execution error: ${testName}`, { error: error.message });
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            name: testName,
+            error: error.message,
+            hint: 'Check the logs for more details.',
+          }),
+        },
+      ],
+    };
+  }
+}
+
+/**
+ * Run multiple Maestro tests with pre-flight checks
+ */
+export async function runTestSuite(tests, options = {}) {
+  try {
+    if (!Array.isArray(tests) || tests.length === 0) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              success: false,
+              error: 'No tests provided. Provide an array of test objects with "yaml" and "name" properties.',
+            }),
+          },
+        ],
+      };
+    }
+
+    logger.info(`Running test suite with ${tests.length} tests`);
+
+    // Pre-flight check: Device connection
+    const deviceStatus = await checkDeviceConnection();
+    if (!deviceStatus.connected) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify({
+              success: false,
+              error: 'No device connected',
+              details: deviceStatus.error,
+              hint: 'Start an Android emulator before running tests.',
+            }),
+          },
+        ],
+      };
+    }
+
+    const config = getConfig();
+    const retries = options.retries ?? config.defaultRetries;
+    const results = [];
+    const startTime = Date.now();
+
+    for (let i = 0; i < tests.length; i++) {
+      const test = tests[i];
+      logger.info(`Running test ${i + 1}/${tests.length}: ${test.name}`);
+
+      // Validate YAML
+      const validation = await validateMaestroYaml(test.yaml);
+      const validationResult = JSON.parse(validation.content[0].text);
+
+      if (!validationResult.valid) {
+        results.push({
+          success: false,
+          name: test.name,
+          error: 'YAML validation failed',
+          validationErrors: validationResult.errors,
+        });
+        continue;
+      }
+
+      // Run the test with retry support
+      const result = await runMaestroFlow(test.yaml, test.name, { retries });
+      results.push(result);
+    }
+
+    const totalDuration = ((Date.now() - startTime) / 1000).toFixed(2);
+    const passed = results.filter(r => r.success).length;
+    const failed = results.filter(r => !r.success).length;
+
+    // Store results
+    const runId = `suite-${++runCounter}-${Date.now()}`;
+    lastRunResults = {
+      runId,
+      timestamp: new Date().toISOString(),
+      duration: totalDuration,
+      tests: results,
+      summary: {
+        total: results.length,
+        passed,
+        failed,
+      },
+    };
+
+    // Save results to file
+    await saveResults(lastRunResults);
+
+    // Auto-cleanup old results
+    await autoCleanupResults();
+
+    logger.info(`Test suite completed: ${passed}/${results.length} passed`);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: failed === 0,
+            runId,
+            duration: totalDuration,
+            summary: {
+              total: results.length,
+              passed,
+              failed,
+            },
+            tests: results.map(r => ({
+              name: r.name,
+              success: r.success,
+              duration: r.duration,
+              attempts: r.attempts || 1,
+              error: r.error || null,
+            })),
+          }),
+        },
+      ],
+    };
+  } catch (error) {
+    logger.error('Test suite execution error', { error: error.message });
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify({
+            success: false,
+            error: error.message,
+          }),
+        },
+      ],
+    };
+  }
+}
+
+/**
+ * Save test results to file
+ */
+async function saveResults(results) {
+  try {
+    await fs.mkdir(RESULTS_DIR, { recursive: true });
+    
+    const filename = `${results.runId}.json`;
+    const filepath = join(RESULTS_DIR, filename);
+    
+    await fs.writeFile(filepath, JSON.stringify(results, null, 2), 'utf8');
+    logger.info(`Results saved: ${filepath}`);
+    
+    // Also save as latest
+    const latestPath = join(RESULTS_DIR, 'latest.json');
+    await fs.writeFile(latestPath, JSON.stringify(results, null, 2), 'utf8');
+  } catch (error) {
+    logger.error('Failed to save results', { error: error.message });
+  }
+}
+
+/**
+ * Auto-cleanup old results based on MAX_RESULTS setting
+ */
+async function autoCleanupResults() {
+  try {
+    const config = getConfig();
+    const maxResults = config.maxResults;
+
+    // Get all result files
+    const files = await fs.readdir(RESULTS_DIR);
+    const resultFiles = files.filter(f => f.endsWith('.json') && f !== 'latest.json');
+
+    // If under limit, no cleanup needed
+    if (resultFiles.length <= maxResults) {
+      return;
+    }
+
+    // Get file stats and sort by modification time
+    const filesWithStats = await Promise.all(
+      resultFiles.map(async (f) => {
+        const filepath = join(RESULTS_DIR, f);
+        const stats = await fs.stat(filepath);
+        return { name: f, path: filepath, mtime: stats.mtime };
+      })
+    );
+
+    filesWithStats.sort((a, b) => b.mtime - a.mtime);
+
+    // Delete files beyond the limit
+    const filesToDelete = filesWithStats.slice(maxResults);
+    
+    for (const file of filesToDelete) {
+      try {
+        await fs.unlink(file.path);
+        logger.info(`Auto-cleanup: deleted old result ${file.name}`);
+      } catch (e) {
+        // Ignore errors
+      }
+    }
+  } catch (error) {
+    // Ignore cleanup errors - don't fail test runs
+    logger.warn('Auto-cleanup warning', { error: error.message });
+  }
+}
+
+export default {
+  runTest,
+  runTestSuite,
+};