@mseep/ai-tech-app-agent 1.0.0

package/scripts/pre-test-setup.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+
+/**
+ * Pre-test setup script
+ * Ensures all required services are running before executing tests
+ */
+
+const { spawn } = require('child_process');
+const axios = require('axios');
+const dotenv = require('dotenv');
+
+dotenv.config();
+
+const colors = {
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    reset: '\x1b[0m'
+};
+
+function log(message, color = 'reset') {
+    console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+async function checkOllama() {
+    const ollamaUrl = process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
+    const modelName = process.env.LLM_MODEL || 'llama3.2:3b';
+
+    log('\n1. Checking Ollama (LLM) Server...', 'yellow');
+
+    try {
+        // Check if Ollama is running
+        const response = await axios.get(`${ollamaUrl}/api/tags`, { timeout: 5000 });
+        log('✓ Ollama is running', 'green');
+
+        // Check if model is available
+        const models = response.data.models || [];
+        const modelExists = models.some(m => m.name === modelName);
+
+        if (modelExists) {
+            log(`✓ Model ${modelName} is available`, 'green');
+            return true;
+        } else {
+            log(`✗ Model ${modelName} not found`, 'red');
+            log(`  Available models: ${models.map(m => m.name).join(', ')}`, 'yellow');
+            log(`  Run: ollama pull ${modelName}`, 'yellow');
+            return false;
+        }
+    } catch (error) {
+        log('✗ Ollama is not running or not accessible', 'red');
+        log('  Start Ollama with: ollama serve', 'yellow');
+        log(`  Then pull model: ollama pull ${modelName}`, 'yellow');
+        return false;
+    }
+}
+
+async function checkAppium() {
+    const appiumUrl = process.env.APPIUM_SERVER_URL || 'http://localhost:4723';
+
+    log('\n2. Checking Appium Server...', 'yellow');
+
+    try {
+        const response = await axios.get(`${appiumUrl}/status`, { timeout: 5000 });
+        log(`✓ Appium server is running at ${appiumUrl}`, 'green');
+        log(`  Build: ${JSON.stringify(response.data.value?.build || 'unknown')}`, 'reset');
+        return true;
+    } catch (error) {
+        log(`⚠ Appium server not accessible at ${appiumUrl}`, 'yellow');
+
+        // Check if using LambdaTest
+        const ltUrl = process.env.LAMBDATEST_GRID_URL;
+        if (ltUrl && ltUrl.includes('lambdatest')) {
+            log('  Using LambdaTest remote grid - this is OK', 'green');
+            return true;
+        } else {
+            log('  If using local Appium, start with: appium', 'yellow');
+            log('  If using LambdaTest, ensure LAMBDATEST_GRID_URL is set', 'yellow');
+            return false;
+        }
+    }
+}
+
+async function checkMCPServer() {
+    const mcpPort = process.env.MCP_SERVER_PORT || 3000;
+
+    log('\n3. Checking MCP-Appium Server...', 'yellow');
+
+    try {
+        // Try to connect to MCP server
+        await axios.get(`http://localhost:${mcpPort}/health`, { timeout: 2000 });
+        log('✓ MCP-Appium server is running', 'green');
+        return true;
+    } catch (error) {
+        log('⚠ MCP-Appium server not running', 'yellow');
+        log('  MCP server starts automatically when tests run', 'green');
+        log('  Or start manually: npm run start-mcp', 'yellow');
+        return true; // Not critical, will start automatically
+    }
+}
+
+function checkEnvironmentVariables() {
+    log('\n4. Checking Environment Variables...', 'yellow');
+
+    const required = [
+        'LAMBDATEST_USERNAME',
+        'LAMBDATEST_ACCESS_KEY',
+    ];
+
+    const optional = [
+        'OLLAMA_BASE_URL',
+        'LLM_MODEL',
+        'APPIUM_SERVER_URL',
+    ];
+
+    let allPresent = true;
+
+    required.forEach(varName => {
+        if (!process.env[varName]) {
+            log(`✗ Required: ${varName} is not set`, 'red');
+            allPresent = false;
+        } else {
+            const value = varName.includes('KEY') || varName.includes('PASSWORD')
+                ? '***'
+                : process.env[varName];
+            log(`✓ ${varName}: ${value}`, 'green');
+        }
+    });
+
+    optional.forEach(varName => {
+        if (process.env[varName]) {
+            log(`✓ ${varName}: ${process.env[varName]}`, 'green');
+        }
+    });
+
+    return allPresent;
+}
+
+async function checkProjectStructure() {
+    const fs = require('fs');
+    const path = require('path');
+
+    log('\n5. Checking Project Structure...', 'yellow');
+
+    const requiredDirs = [
+        'src/config',
+        'src/mcp',
+        'src/llm',
+        'src/utils',
+        'src/orchestrator',
+        'tests/nlp-specs',
+        'logs',
+        'reports',
+    ];
+
+    let allExist = true;
+
+    requiredDirs.forEach(dir => {
+        const fullPath = path.join(process.cwd(), dir);
+        if (fs.existsSync(fullPath)) {
+            log(`✓ ${dir}`, 'green');
+        } else {
+            log(`✗ ${dir} not found`, 'red');
+            allExist = false;
+        }
+    });
+
+    // Check if build exists
+    const distPath = path.join(process.cwd(), 'dist');
+    if (fs.existsSync(distPath)) {
+        log('✓ TypeScript compiled (dist/ exists)', 'green');
+    } else {
+        log('✗ Project not built. Run: npm run build', 'red');
+        allExist = false;
+    }
+
+    return allExist;
+}
+
+async function startOllama() {
+    log('\nAttempting to start Ollama...', 'yellow');
+
+    return new Promise((resolve) => {
+        const ollama = spawn('ollama', ['serve'], {
+            detached: true,
+            stdio: 'ignore'
+        });
+
+        ollama.unref();
+
+        log('✓ Ollama server started in background', 'green');
+        log('  Waiting 3 seconds for initialization...', 'yellow');
+
+        setTimeout(() => resolve(true), 3000);
+    });
+}
+
+async function main() {
+    console.log('==========================================');
+    console.log('Pre-Test Setup Checker');
+    console.log('==========================================');
+
+    const results = {
+        ollama: false,
+        appium: false,
+        mcp: false,
+        env: false,
+        structure: false,
+    };
+
+    // Check all services
+    results.ollama = await checkOllama();
+    results.appium = await checkAppium();
+    results.mcp = await checkMCPServer();
+    results.env = checkEnvironmentVariables();
+    results.structure = await checkProjectStructure();
+
+    // Summary
+    log('\n==========================================', 'yellow');
+    log('Setup Summary', 'yellow');
+    log('==========================================', 'yellow');
+
+    const allGood = Object.values(results).every(r => r === true);
+
+    if (allGood) {
+        log('\n✓ All checks passed! Ready to run tests.', 'green');
+        log('\nRun your tests with:', 'reset');
+        log('  npm run test', 'yellow');
+        log('  or', 'reset');
+        log('  npm run test:single', 'yellow');
+        process.exit(0);
+    } else {
+        log('\n⚠ Some checks failed. Please fix the issues above.', 'yellow');
+
+        // Auto-fix attempt
+        log('\nAttempting auto-fixes...', 'yellow');
+
+        if (!results.ollama) {
+            try {
+                await startOllama();
+                // Re-check Ollama
+                const ollamaOk = await checkOllama();
+                if (ollamaOk) {
+                    log('✓ Ollama started successfully!', 'green');
+                }
+            } catch (error) {
+                log('✗ Could not auto-start Ollama', 'red');
+                log('  Please start manually: ollama serve', 'yellow');
+            }
+        }
+
+        log('\nAfter fixing issues, run this script again:', 'reset');
+        log('  node scripts/pre-test-setup.js', 'yellow');
+
+        process.exit(1);
+    }
+}
+
+// Run the checks
+main().catch(error => {
+    log(`\nError: ${error.message}`, 'red');
+    process.exit(1);
+});

package/scripts/start-mcp-server.sh

@@ -0,0 +1,76 @@
+#!/bin/bash
+
+# Start MCP-Appium server manually
+# This script is optional - MCP starts automatically during tests
+
+set -e
+
+# Color codes
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m'
+
+echo "=========================================="
+echo "Starting MCP-Appium Server"
+echo "=========================================="
+echo ""
+
+# Load environment variables
+if [ -f .env ]; then
+    export $(cat .env | grep -v '^#' | xargs)
+    echo -e "${GREEN}✓${NC} Loaded environment variables from .env"
+else
+    echo -e "${YELLOW}⚠${NC}  No .env file found, using defaults"
+fi
+
+# Set defaults
+APPIUM_SERVER_URL=${APPIUM_SERVER_URL:-http://localhost:4723}
+MCP_SERVER_PORT=${MCP_SERVER_PORT:-3000}
+
+echo "Configuration:"
+echo "  Appium URL: $APPIUM_SERVER_URL"
+echo "  MCP Port: $MCP_SERVER_PORT"
+echo ""
+
+# Check if mcp-appium is installed
+if ! command -v npx &> /dev/null; then
+    echo -e "${RED}✗${NC} npx not found. Please install Node.js"
+    exit 1
+fi
+
+# Check if already running
+if lsof -Pi :$MCP_SERVER_PORT -sTCP:LISTEN -t >/dev/null 2>&1; then
+    PID=$(lsof -Pi :$MCP_SERVER_PORT -sTCP:LISTEN -t)
+    echo -e "${YELLOW}⚠${NC}  Port $MCP_SERVER_PORT is already in use by PID: $PID"
+    read -p "Kill existing process? (y/n) " -n 1 -r
+    echo
+    if [[ $REPLY =~ ^[Yy]$ ]]; then
+        kill -9 $PID
+        echo -e "${GREEN}✓${NC} Killed existing process"
+        sleep 2
+    else
+        echo "Exiting..."
+        exit 1
+    fi
+fi
+
+# Check if Appium is accessible
+echo "Checking Appium server connectivity..."
+if curl -s "$APPIUM_SERVER_URL/status" > /dev/null 2>&1; then
+    echo -e "${GREEN}✓${NC} Appium server is accessible"
+else
+    echo -e "${YELLOW}⚠${NC}  Cannot reach Appium server at $APPIUM_SERVER_URL"
+    echo "   If using LambdaTest, this is OK"
+fi
+
+echo ""
+echo "Starting MCP-Appium server..."
+echo "Press Ctrl+C to stop"
+echo ""
+
+# Start MCP-Appium server
+npx mcp-appium
+
+# Note: The process will run in foreground
+# To run in background, use: npx mcp-appium > logs/mcp-server.log 2>&1 &

package/src/config/app.config.ts

@@ -0,0 +1,175 @@
+import dotenv from 'dotenv';
+import path from 'path';
+
+dotenv.config();
+
+export interface AppConfig {
+  env: string;
+  name: string;
+  version: string;
+  
+  // Directories
+  paths: {
+    root: string;
+    logs: string;
+    reports: string;
+    screenshots: string;
+    testSpecs: string;
+    knowledge: string;
+  };
+
+  // Test execution settings
+  execution: {
+    defaultTimeout: number;
+    maxRetryAttempts: number;
+    retryFailedSteps: boolean;
+    screenshotOnFailure: boolean;
+    continueOnFailure: boolean;
+    parallelExecution: boolean;
+    maxParallelTests: number;
+  };
+
+  // Element interaction settings
+  interaction: {
+    implicitWait: number;
+    explicitWait: number;
+    actionDelay: number;
+    tapDuration: number;
+    swipeSpeed: number;
+    scrollPercentage: number;
+  };
+
+  // Reporting
+  reporting: {
+    format: 'json' | 'html' | 'allure';
+    includeScreenshots: boolean;
+    includeStepDetails: boolean;
+    includeTimestamps: boolean;
+    verboseLogging: boolean;
+  };
+
+  // LambdaTest configuration
+  lambdatest: {
+    username: string;
+    accessKey: string;
+    gridUrl: string;
+    tunnel: boolean;
+    tunnelName?: string;
+    buildName: string;
+    projectName: string;
+    tags: string[];
+    network: boolean;
+    video: boolean;
+    console: boolean;
+    visual: boolean;
+  };
+
+  // Device preferences
+  devices: {
+    android: {
+      defaultVersion: string;
+      defaultDevice: string;
+    };
+    ios: {
+      defaultVersion: string;
+      defaultDevice: string;
+    };
+  };
+}
+
+const appConfig: AppConfig = {
+  env: process.env.NODE_ENV || 'development',
+  name: process.env.APP_NAME || 'ai-tech-app-agent',
+  version: process.env.APP_VERSION || '1.0.0',
+
+  paths: {
+    root: process.cwd(),
+    logs: path.resolve(process.cwd(), process.env.LOG_DIR || './logs'),
+    reports: path.resolve(process.cwd(), process.env.REPORT_DIR || './reports'),
+    screenshots: path.resolve(process.cwd(), process.env.SCREENSHOT_DIR || './reports/screenshots'),
+    testSpecs: path.resolve(process.cwd(), process.env.TEST_SPEC_DIR || './tests/nlp-specs'),
+    knowledge: path.resolve(process.cwd(), process.env.KNOWLEDGE_DIR || './knowledge'),
+  },
+
+  execution: {
+    defaultTimeout: parseInt(process.env.DEFAULT_TIMEOUT || '30000'),
+    maxRetryAttempts: parseInt(process.env.MAX_RETRY_ATTEMPTS || '2'),
+    retryFailedSteps: process.env.RETRY_FAILED_STEPS === 'true',
+    screenshotOnFailure: process.env.SCREENSHOT_ON_FAILURE !== 'false',
+    continueOnFailure: process.env.CONTINUE_ON_FAILURE === 'true',
+    parallelExecution: process.env.PARALLEL_EXECUTION === 'true',
+    maxParallelTests: parseInt(process.env.MAX_PARALLEL_TESTS || '3'),
+  },
+
+  interaction: {
+    implicitWait: parseInt(process.env.IMPLICIT_WAIT || '5000'),
+    explicitWait: parseInt(process.env.EXPLICIT_WAIT || '10000'),
+    actionDelay: parseInt(process.env.ACTION_DELAY || '500'),
+    tapDuration: parseInt(process.env.TAP_DURATION || '100'),
+    swipeSpeed: parseInt(process.env.SWIPE_SPEED || '1000'),
+    scrollPercentage: parseFloat(process.env.SCROLL_PERCENTAGE || '0.75'),
+  },
+
+  reporting: {
+    format: (process.env.REPORT_FORMAT as 'json' | 'html' | 'allure') || 'json',
+    includeScreenshots: process.env.INCLUDE_SCREENSHOTS !== 'false',
+    includeStepDetails: process.env.INCLUDE_STEP_DETAILS !== 'false',
+    includeTimestamps: process.env.INCLUDE_TIMESTAMPS !== 'false',
+    verboseLogging: process.env.VERBOSE_LOGGING === 'true',
+  },
+
+  lambdatest: {
+    username: process.env.LAMBDATEST_USERNAME || '',
+    accessKey: process.env.LAMBDATEST_ACCESS_KEY || '',
+    gridUrl: process.env.LAMBDATEST_GRID_URL || 'https://mobile-hub.lambdatest.com/wd/hub',
+    tunnel: process.env.LAMBDATEST_TUNNEL === 'true',
+    tunnelName: process.env.LAMBDATEST_TUNNEL_NAME,
+    buildName: process.env.LAMBDATEST_BUILD_NAME || `AI-Test-Build`,
+    projectName: process.env.LAMBDATEST_PROJECT_NAME || 'AI Mobile Test Automation',
+    tags: (process.env.LAMBDATEST_TAGS || 'ai,mcp,automation').split(','),
+    network: process.env.LAMBDATEST_NETWORK !== 'false',
+    video: process.env.LAMBDATEST_VIDEO !== 'false',
+    console: process.env.LAMBDATEST_CONSOLE !== 'false',
+    visual: process.env.LAMBDATEST_VISUAL !== 'false',
+  },
+
+  devices: {
+    android: {
+      defaultVersion: process.env.ANDROID_DEFAULT_VERSION || '13',
+      defaultDevice: process.env.ANDROID_DEFAULT_DEVICE || 'Pixel 7',
+    },
+    ios: {
+      defaultVersion: process.env.IOS_DEFAULT_VERSION || '16',
+      defaultDevice: process.env.IOS_DEFAULT_DEVICE || 'iPhone 14',
+    },
+  },
+};
+
+// Validation
+export function validateAppConfig(): void {
+  const errors: string[] = [];
+
+  // Check required LambdaTest credentials
+  if (!appConfig.lambdatest.username) {
+    errors.push('LAMBDATEST_USERNAME is required');
+  }
+  if (!appConfig.lambdatest.accessKey) {
+    errors.push('LAMBDATEST_ACCESS_KEY is required');
+  }
+
+  // Validate timeout values
+  if (appConfig.execution.defaultTimeout < 1000) {
+    errors.push('DEFAULT_TIMEOUT must be at least 1000ms');
+  }
+
+  // Validate retry attempts
+  if (appConfig.execution.maxRetryAttempts < 0 || appConfig.execution.maxRetryAttempts > 5) {
+    errors.push('MAX_RETRY_ATTEMPTS must be between 0 and 5');
+  }
+
+  if (errors.length > 0) {
+    throw new Error(`App configuration validation failed:\n${errors.join('\n')}`);
+  }
+}
+
+export default appConfig;