@performance-agent/mcp-server 1.0.1 → 1.0.6

package/dist/index.js

@@ -2,61 +2,43 @@
 /**
  * Performance Agent MCP Server
  *
- * This MCP server provides 3 core tools:
+ * This MCP server provides 12 core tools:
  * 1. Generate JMX scripts from Swagger/OpenAPI specifications
- * 2. Analyze code complexity in local git repositories
- * 3. Profile function execution time and identify slow functions
+ * 2. Prepare JMX for testing (workflow tool)
+ * 3. Analyze code complexity in local git repositories
+ * 4. Profile function execution time and identify slow functions
+ * 5. Provision Azure infrastructure (VMs) from natural language descriptions
+ * 6. List Azure subscriptions for user selection
+ * 7. Set active Azure subscription
+ * 8. List Azure resource groups for reuse
+ * 9. Run end-to-end cloud performance tests
+ * 10. Get VM size recommendations for JMX scripts
+ * 11. Cleanup Azure test infrastructure (Terraform destroy)
+ * 12. Analyze test results with VM metrics
+ * 13. Get Azure VM performance metrics (CPU, Memory, Network, Disk)
  *
- * Focused on local development and code quality.
+ * Focused on local development, code quality, cloud performance testing, and infrastructure monitoring.
  */
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import axios from 'axios';
 import * as dotenv from 'dotenv';
+import * as fs from 'fs';
+import * as path from 'path';
 import { analyzeCodeComplexity } from './tools/code-analyzer/index.js';
 import { profileFunctionPerformance } from './tools/function-profiler/index.js';
+import { provisionAzureVM, checkPrerequisites, getVMSizePresets, listAzureSubscriptions, setAzureSubscription, listResourceGroups, } from './tools/azure-infra/index.js';
+import { runCloudPerformanceTest, getVMRecommendation, cleanupAzureResources, analyzeTestResults, getVMMetrics, } from './tools/cloud-executor/index.js';
+import { generateJMX } from './tools/jmx-generator/index.js';
 // Load environment variables
 dotenv.config();
-// Configuration
-const API_BASE_URL = process.env.PERFORMANCE_AGENT_API_URL || 'http://localhost:8000';
-const API_KEY = process.env.PERFORMANCE_AGENT_API_KEY || '';
-/**
- * Performance Agent API Client - Minimal client for JMX generation
- */
-class PerformanceAgentClient {
-    client;
-    constructor(baseURL, apiKey) {
-        this.client = axios.create({
-            baseURL,
-            headers: {
-                'Content-Type': 'application/json',
-                ...(apiKey && { 'Authorization': `Bearer ${apiKey}` }),
-            },
-            timeout: 300000, // 5 minutes
-        });
-    }
-    /**
-     * Generate JMX script from Swagger content
-     */
-    async generateFromSwagger(repoName, swaggerContent) {
-        const response = await this.client.post('/api/orchestrator/execute', {
-            action: 'generate_from_swagger',
-            payload: {
-                repo_name: repoName,
-                swagger_content: swaggerContent,
-            },
-        });
-        return response.data;
-    }
-}
 /**
  * Define MCP Tools - Simplified to 2 core features
  */
 const TOOLS = [
     {
         name: 'generateJMXFromSwagger',
-        description: 'Generate JMeter (JMX) performance test script from Swagger/OpenAPI specification. Analyzes API endpoints and creates comprehensive load test scenarios.',
+        description: 'Generate JMeter (JMX) performance test script from Swagger/OpenAPI specification. Analyzes API endpoints and creates comprehensive load test scenarios. **IMPORTANT**: Always use this to regenerate JMX if you have updated the Swagger/OpenAPI spec, changed load parameters, or modified API definitions.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -73,6 +55,38 @@ const TOOLS = [
             required: ['swagger_content'],
         },
     },
+    {
+        name: 'prepareJMXForTest',
+        description: 'WORKFLOW TOOL: Prepare JMX script for performance testing. This tool guides you through checking if JMX exists, optionally regenerating it from Swagger, analyzing load requirements, and getting VM size recommendations. **USE THIS FIRST** before running cloud performance tests to ensure JMX is current and properly analyzed.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                jmx_file_path: {
+                    type: 'string',
+                    description: 'Path to existing JMX file to analyze',
+                },
+                swagger_file_path: {
+                    type: 'string',
+                    description: 'Path to Swagger/OpenAPI file if user wants to regenerate JMX',
+                },
+                regenerate_jmx: {
+                    type: 'boolean',
+                    description: 'Set to true if user wants to regenerate JMX from Swagger (e.g., after API changes, load changes)',
+                    default: false,
+                },
+                swagger_content: {
+                    type: 'object',
+                    description: 'Swagger/OpenAPI JSON content if regenerating JMX',
+                    additionalProperties: true,
+                },
+                repo_name: {
+                    type: 'string',
+                    description: 'Repository name for JMX generation',
+                },
+            },
+            required: ['jmx_file_path'],
+        },
+    },
     {
         name: 'analyzeCodeComplexity',
         description: 'Analyze cyclomatic complexity of code changes in local git repository. Helps identify overly complex functions that may have performance or maintainability issues. Supports Python, JavaScript, and TypeScript.',
@@ -146,6 +160,282 @@ const TOOLS = [
             required: ['repo_path'],
         },
     },
+    {
+        name: 'provisionAzureVM',
+        description: 'Provision Azure Virtual Machines from natural language descriptions or structured configuration. Supports VM size presets (small/medium/large/gpu), OS selection (Ubuntu, Windows, RHEL), networking, and generates Terraform or Azure CLI commands.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                description: {
+                    type: 'string',
+                    description: 'Natural language description of the VM you want. Example: "Create a large Ubuntu VM in East US with 4 cores, 16GB RAM, public IP, and ports 22, 80, 443 open for a web server"',
+                },
+                config: {
+                    type: 'object',
+                    description: 'Structured VM configuration (optional, can be used instead of or with description)',
+                    properties: {
+                        name: { type: 'string', description: 'VM name' },
+                        resourceGroup: { type: 'string', description: 'Azure resource group name' },
+                        subscriptionId: { type: 'string', description: 'Azure subscription ID (if user selected a specific subscription)' },
+                        useExistingResourceGroup: { type: 'boolean', description: 'Whether to use an existing resource group instead of creating new (default: false)' },
+                        sizePreset: {
+                            type: 'string',
+                            enum: ['small', 'medium', 'large', 'xlarge', 'compute-optimized', 'memory-optimized', 'gpu'],
+                            description: 'VM size preset',
+                        },
+                        customSize: { type: 'string', description: 'Custom Azure VM size (e.g., Standard_D4s_v3)' },
+                        os: {
+                            type: 'string',
+                            enum: ['ubuntu-22.04', 'ubuntu-20.04', 'debian-11', 'rhel-8', 'windows-2022', 'windows-2019'],
+                            description: 'Operating system',
+                        },
+                        region: { type: 'string', description: 'Azure region (e.g., eastus, westeurope)' },
+                        cpuCores: { type: 'number', description: 'Number of CPU cores' },
+                        memoryGB: { type: 'number', description: 'Memory in GB' },
+                        diskSizeGB: { type: 'number', description: 'OS disk size in GB' },
+                        diskType: { type: 'string', enum: ['standard', 'premium', 'ultra'], description: 'Disk type' },
+                        publicIP: { type: 'boolean', description: 'Whether to assign a public IP' },
+                        openPorts: { type: 'array', items: { type: 'number' }, description: 'Ports to open in NSG' },
+                        spotInstance: { type: 'boolean', description: 'Use spot instance for cost savings' },
+                        autoShutdown: { type: 'string', description: 'Auto-shutdown time (e.g., 19:00)' },
+                    },
+                },
+                method: {
+                    type: 'string',
+                    enum: ['dry-run', 'terraform', 'azure-cli'],
+                    description: 'Provisioning method: dry-run (generate config only), terraform (apply with Terraform), azure-cli (apply with Azure CLI)',
+                    default: 'dry-run',
+                },
+                generateTerraform: {
+                    type: 'boolean',
+                    description: 'Generate Terraform files (default: true for dry-run)',
+                    default: true,
+                },
+                outputPath: {
+                    type: 'string',
+                    description: 'Directory to save generated files (defaults to current directory)',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'listAzureSubscriptions',
+        description: 'List all Azure subscriptions the user has access to. Use this BEFORE provisioning VMs when user might have multiple subscriptions. Returns list of subscriptions with their IDs, names, and which one is currently active.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: 'setAzureSubscription',
+        description: 'Set the active Azure subscription for subsequent operations. Use this when user selects a different subscription from the list.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                subscriptionId: {
+                    type: 'string',
+                    description: 'The subscription ID to set as active',
+                },
+            },
+            required: ['subscriptionId'],
+        },
+    },
+    {
+        name: 'listAzureResourceGroups',
+        description: 'List all resource groups in the current (or specified) Azure subscription. Use this to offer users the option to reuse existing resource groups instead of creating new ones.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                subscriptionId: {
+                    type: 'string',
+                    description: 'Optional subscription ID to list resource groups from. If not provided, uses the current active subscription.',
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'runCloudPerformanceTest',
+        description: 'Run end-to-end cloud performance test. Provisions an Azure VM using Terraform, installs JMeter, uploads JMX script, executes test, downloads results, and optionally cleans up resources. This is the fully automated workflow for cloud-based performance testing.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                jmx_file_path: {
+                    type: 'string',
+                    description: 'Absolute path to the JMX test script file',
+                },
+                subscription_id: {
+                    type: 'string',
+                    description: 'Azure subscription ID (required)',
+                },
+                resource_group: {
+                    type: 'string',
+                    description: 'Azure resource group name (required)',
+                },
+                vm_name: {
+                    type: 'string',
+                    description: 'Name for the VM (optional, auto-generated if not provided)',
+                },
+                region: {
+                    type: 'string',
+                    description: 'Azure region (default: eastus)',
+                    default: 'eastus',
+                },
+                vm_size: {
+                    type: 'string',
+                    enum: ['small', 'medium', 'large', 'xlarge'],
+                    description: 'VM size preset. If not provided, will be auto-recommended based on JMX analysis.',
+                },
+                reuse_existing_vm: {
+                    type: 'boolean',
+                    description: 'Whether to reuse an existing VM instead of creating a new one',
+                    default: false,
+                },
+                existing_vm_ip: {
+                    type: 'string',
+                    description: 'IP address of existing VM to reuse (required if reuse_existing_vm is true)',
+                },
+                ssh_key_path: {
+                    type: 'string',
+                    description: 'Path to SSH private key (required if reusing existing VM)',
+                },
+                cleanup_after_test: {
+                    type: 'boolean',
+                    description: 'Whether to delete Azure resources after test completion using Terraform destroy (default: false)',
+                    default: false,
+                },
+                test_duration_minutes: {
+                    type: 'number',
+                    description: 'Maximum test duration in minutes for timeout calculation (default: 30)',
+                    default: 30,
+                },
+                output_path: {
+                    type: 'string',
+                    description: 'Local directory to save test results (default: ./.perf-output/test-results)',
+                },
+            },
+            required: ['jmx_file_path', 'subscription_id', 'resource_group'],
+        },
+    },
+    {
+        name: 'getCloudTestRecommendation',
+        description: 'Analyze a JMX file and get VM size recommendations for cloud execution. Use this before runCloudPerformanceTest to show users the recommended configuration.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                jmx_file_path: {
+                    type: 'string',
+                    description: 'Absolute path to the JMX test script file to analyze',
+                },
+            },
+            required: ['jmx_file_path'],
+        },
+    },
+    {
+        name: 'cleanupAzureResources',
+        description: 'Delete Azure resource group and all associated resources (VM, network, disks, etc.) after performance test completion. Uses Terraform destroy as primary method. Requires user confirmation before destroying resources. Use this to stop billing and clean up test infrastructure.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                resource_group: {
+                    type: 'string',
+                    description: 'Name of the Azure resource group to delete (e.g., rg-perf-test-agent)',
+                },
+                terraform_dir: {
+                    type: 'string',
+                    description: 'Path to Terraform directory (optional, will auto-detect from .perf-output if not provided)',
+                },
+                force: {
+                    type: 'boolean',
+                    description: 'If true, deletion runs asynchronously in background (faster). If false, waits for completion (default: true)',
+                    default: true,
+                },
+                confirmed: {
+                    type: 'boolean',
+                    description: 'User confirmation to proceed with resource destruction. First call returns resources to be deleted, second call with confirmed=true performs the deletion.',
+                    default: false,
+                },
+            },
+            required: ['resource_group'],
+        },
+    },
+    {
+        name: 'analyzeTestResults',
+        description: 'Analyze performance test results and generate detailed report with insights. Provides comprehensive statistics including response times (avg, min, max, percentiles), error rates, throughput, per-endpoint breakdown, and Azure VM metrics (CPU, memory, network usage during test). Use this after test completion to get actionable insights and recommendations.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                result_file_path: {
+                    type: 'string',
+                    description: 'Absolute path to the JTL results file (e.g., .perf-output/test-results/test-xxx/results.jtl)',
+                },
+                resource_group: {
+                    type: 'string',
+                    description: 'Azure resource group name (optional, for VM metrics)',
+                },
+                vm_name: {
+                    type: 'string',
+                    description: 'Azure VM name (optional, for VM metrics)',
+                },
+                test_start_time: {
+                    type: 'string',
+                    description: 'Test start time in ISO format (optional, for VM metrics)',
+                },
+                test_end_time: {
+                    type: 'string',
+                    description: 'Test end time in ISO format (optional, for VM metrics)',
+                },
+            },
+            required: ['result_file_path'],
+        },
+    },
+    {
+        name: 'getVMMetrics',
+        description: 'Fetch Azure VM performance metrics (CPU, Memory, Network, Disk) from Azure Monitor. Used to verify VM had sufficient capacity during performance tests and identify infrastructure bottlenecks. Automatically detects VM from Terraform state or accepts explicit resource group/VM name.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                resource_group: {
+                    type: 'string',
+                    description: 'Azure resource group name containing the VM',
+                },
+                vm_name: {
+                    type: 'string',
+                    description: 'VM name (optional, will auto-detect from Terraform state if not provided)',
+                },
+                time_range: {
+                    type: 'string',
+                    enum: ['1h', '6h', '24h', 'custom'],
+                    description: 'Time range for metrics (default: 1h)',
+                    default: '1h',
+                },
+                start_time: {
+                    type: 'string',
+                    description: 'Start time in ISO 8601 format (required if time_range=custom)',
+                },
+                end_time: {
+                    type: 'string',
+                    description: 'End time in ISO 8601 format (required if time_range=custom)',
+                },
+                metrics: {
+                    type: 'array',
+                    items: {
+                        type: 'string',
+                        enum: ['cpu', 'memory', 'network', 'disk', 'all'],
+                    },
+                    description: 'Specific metrics to fetch (default: ["all"])',
+                    default: ['all'],
+                },
+                terraform_dir: {
+                    type: 'string',
+                    description: 'Path to Terraform directory (optional, for auto-detection)',
+                },
+            },
+            required: ['resource_group'],
+        },
+    },
 ];
 /**
  * Create and configure MCP Server
@@ -158,8 +448,6 @@ const server = new Server({
         tools: {},
     },
 });
-// Initialize API client
-const apiClient = new PerformanceAgentClient(API_BASE_URL, API_KEY);
 /**
  * List available tools
  */
@@ -183,12 +471,42 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case 'generateJMXFromSwagger':
                 result = await handleGenerateJMX(args);
                 break;
+            case 'prepareJMXForTest':
+                result = await handlePrepareJMXForTest(args);
+                break;
             case 'analyzeCodeComplexity':
                 result = await handleCodeComplexity(args);
                 break;
             case 'profileFunctionPerformance':
                 result = await handleFunctionProfiling(args);
                 break;
+            case 'provisionAzureVM':
+                result = await handleAzureProvisioning(args);
+                break;
+            case 'listAzureSubscriptions':
+                result = await handleListSubscriptions();
+                break;
+            case 'setAzureSubscription':
+                result = await handleSetSubscription(args);
+                break;
+            case 'listAzureResourceGroups':
+                result = await handleListResourceGroups(args);
+                break;
+            case 'runCloudPerformanceTest':
+                result = await handleCloudPerformanceTest(args);
+                break;
+            case 'getCloudTestRecommendation':
+                result = await handleCloudTestRecommendation(args);
+                break;
+            case 'cleanupAzureResources':
+                result = await handleCleanupAzureResources(args);
+                break;
+            case 'analyzeTestResults':
+                result = await handleAnalyzeTestResults(args);
+                break;
+            case 'getVMMetrics':
+                result = await handleGetVMMetrics(args);
+                break;
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }
@@ -219,21 +537,147 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
 });
 /**
- * Handler for generateJMXFromSwagger tool
+ * Handler for generateJMXFromSwagger tool - Now uses local OpenAI integration
  */
 async function handleGenerateJMX(args) {
     const { repo_name = 'api-test', swagger_content } = args;
     if (!swagger_content) {
         throw new Error('Missing required field: swagger_content');
     }
-    const result = await apiClient.generateFromSwagger(repo_name, swagger_content);
+    console.error(`[generateJMXFromSwagger] Generating JMX for repo: ${repo_name}...`);
+    const result = await generateJMX(swagger_content, repo_name);
+    if (!result.success) {
+        throw new Error(result.error || 'JMX generation failed');
+    }
+    // Save JMX script to local file
+    const outputDir = path.join(process.cwd(), '.perf-output', 'jmx-scripts');
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
     return {
         success: true,
         tool: 'generateJMXFromSwagger',
         repo_name,
         jmx_script: result.jmx_script,
-        local_file: result.local_file,
-        message: result.message || 'JMX script generated successfully',
+        message: `JMX script generated successfully for repo: ${repo_name}`,
+    };
+}
+/**
+ * Handler for prepareJMXForTest tool - Workflow tool for JMX preparation
+ * This tool ALWAYS reads the latest file content and provides fresh analysis
+ */
+async function handlePrepareJMXForTest(args) {
+    const { jmx_file_path, swagger_file_path, regenerate_jmx = false, swagger_content, repo_name = 'api-test' } = args;
+    if (!jmx_file_path) {
+        throw new Error('Missing required field: jmx_file_path');
+    }
+    const jmxExists = fs.existsSync(jmx_file_path);
+    let regenerated = false;
+    // Step 1: Check if JMX exists and handle regeneration
+    if (!jmxExists) {
+        return {
+            success: false,
+            tool: 'prepareJMXForTest',
+            jmx_exists: false,
+            jmx_file_path,
+            message: `JMX file not found at: ${jmx_file_path}. Please provide swagger_content to generate a new JMX script.`,
+            next_step: 'Provide swagger_content and set regenerate_jmx=true to generate JMX',
+        };
+    }
+    // Step 2: Regenerate JMX if requested
+    if (regenerate_jmx) {
+        if (!swagger_content) {
+            return {
+                success: false,
+                tool: 'prepareJMXForTest',
+                message: 'swagger_content is required when regenerate_jmx=true',
+                next_step: 'Provide swagger_content to regenerate JMX',
+            };
+        }
+        console.error('Regenerating JMX from Swagger...');
+        const genResult = await generateJMX(swagger_content, repo_name);
+        if (!genResult.success || !genResult.jmx_script) {
+            return {
+                success: false,
+                tool: 'prepareJMXForTest',
+                message: `JMX regeneration failed: ${genResult.error}`,
+            };
+        }
+        // Save the new JMX file
+        fs.writeFileSync(jmx_file_path, genResult.jmx_script);
+        regenerated = true;
+        console.error(`JMX regenerated and saved to: ${jmx_file_path}`);
+    }
+    // Step 3: Read current JMX file content (fresh read every time)
+    console.error('Reading latest JMX file content...');
+    let jmxContent;
+    try {
+        jmxContent = fs.readFileSync(jmx_file_path, 'utf-8');
+    }
+    catch (error) {
+        return {
+            success: false,
+            tool: 'prepareJMXForTest',
+            message: `Failed to read JMX file: ${error}`,
+        };
+    }
+    // Step 4: Analyze the JMX file content
+    console.error('Analyzing current JMX configuration for resource requirements...');
+    const recommendation = getVMRecommendation(jmx_file_path);
+    // Extract actual thread counts from the file for display
+    const threadGroupMatches = jmxContent.match(/<stringProp name="ThreadGroup\.num_threads">([^<]+)<\/stringProp>/g) || [];
+    const threadCounts = threadGroupMatches.map(match => {
+        const valueMatch = match.match(/>([^<]+)</);
+        return valueMatch ? valueMatch[1] : '0';
+    });
+    const loopCountMatches = jmxContent.match(/<stringProp name="LoopController\.loops">([^<]+)<\/stringProp>/g) || [];
+    const loopCounts = loopCountMatches.map(match => {
+        const valueMatch = match.match(/>([^<]+)</);
+        return valueMatch ? valueMatch[1] : '0';
+    });
+    // Step 5: Return comprehensive analysis and recommendations with "where to run" prompt
+    return {
+        success: true,
+        tool: 'prepareJMXForTest',
+        jmx_exists: true,
+        jmx_file_path,
+        regenerated,
+        current_config: {
+            thread_groups: threadCounts.length,
+            thread_counts: threadCounts,
+            loop_counts: loopCounts,
+            detected_variables: jmxContent.includes('${ThreadCount_') ? 'Parameterized (using variables)' : 'Hardcoded',
+        },
+        analysis: {
+            threadCount: recommendation.threadCount,
+            testDurationSeconds: recommendation.duration,
+            totalVirtualUsers: recommendation.threadCount,
+            file_size_kb: Math.round(Buffer.from(jmxContent).length / 1024),
+        },
+        recommendation: {
+            vmSize: recommendation.recommendedSize,
+            estimatedCost: recommendation.estimatedCost,
+            description: recommendation.description,
+        },
+        message: regenerated
+            ? `✅ JMX regenerated and analyzed. Current config: ${recommendation.threadCount} total threads, ${recommendation.duration}s duration. Recommended VM: ${recommendation.recommendedSize} (${recommendation.estimatedCost})`
+            : `✅ JMX analyzed from latest file content. Current config: ${recommendation.threadCount} total threads, ${recommendation.duration}s duration. Recommended VM: ${recommendation.recommendedSize} (${recommendation.estimatedCost})`,
+        next_steps: {
+            option_1: {
+                name: 'Run on Azure VM (Automated)',
+                action: 'Use runCloudPerformanceTest tool',
+                requires: ['subscription_id', 'resource_group'],
+                recommended_vm: recommendation.recommendedSize,
+                will_provision: 'VM, install JMeter, execute test, download results, optional cleanup',
+            },
+            option_2: {
+                name: 'Run Locally',
+                action: 'Open JMX file in JMeter GUI',
+                requires: 'JMeter installed locally',
+                note: 'Manual execution',
+            },
+        },
+        prompt_user: '📍 Where would you like to run this performance test? (1) Azure VM (automated) or (2) Local JMeter?',
     };
 }
 /**
@@ -279,6 +723,290 @@ async function handleFunctionProfiling(args) {
         ...report,
     };
 }
+/**
+ * Handler for provisionAzureVM tool
+ */
+async function handleAzureProvisioning(args) {
+    const { description, config, method = 'dry-run', generateTerraform = true, outputPath, } = args;
+    if (!description && !config) {
+        // Return available presets and prerequisites
+        const prerequisites = checkPrerequisites();
+        const presets = getVMSizePresets();
+        return {
+            success: true,
+            tool: 'provisionAzureVM',
+            message: 'No configuration provided. Here are the available options:',
+            prerequisites,
+            availablePresets: presets,
+            exampleDescriptions: [
+                'Create a small Ubuntu VM in East US for testing',
+                'Create a large Windows 2022 VM with 4 cores, 16GB RAM, and public IP',
+                'Create a GPU VM for machine learning with 100GB disk',
+                'Create a medium web server with ports 80, 443, and auto-shutdown at 7pm',
+            ],
+        };
+    }
+    const result = await provisionAzureVM({
+        description,
+        config,
+        method,
+        generateTerraform,
+        outputPath,
+    });
+    return {
+        tool: 'provisionAzureVM',
+        ...result,
+    };
+}
+/**
+ * Handler for listAzureSubscriptions tool
+ */
+async function handleListSubscriptions() {
+    const result = await listAzureSubscriptions();
+    if (!result.success) {
+        throw new Error(result.error || 'Failed to list subscriptions');
+    }
+    return {
+        tool: 'listAzureSubscriptions',
+        success: true,
+        subscriptions: result.subscriptions,
+        currentSubscription: result.currentSubscription,
+        count: result.subscriptions?.length || 0,
+        message: result.subscriptions && result.subscriptions.length > 1
+            ? `Found ${result.subscriptions.length} subscriptions. Please select one.`
+            : 'Using current subscription.',
+    };
+}
+/**
+ * Handler for setAzureSubscription tool
+ */
+async function handleSetSubscription(args) {
+    const { subscriptionId } = args;
+    if (!subscriptionId) {
+        throw new Error('Missing required field: subscriptionId');
+    }
+    const result = await setAzureSubscription(subscriptionId);
+    if (!result.success) {
+        throw new Error(result.error || 'Failed to set subscription');
+    }
+    return {
+        tool: 'setAzureSubscription',
+        success: true,
+        subscriptionId,
+        message: result.message,
+    };
+}
+/**
+ * Handler for listAzureResourceGroups tool
+ */
+async function handleListResourceGroups(args) {
+    const { subscriptionId } = args;
+    const result = await listResourceGroups(subscriptionId);
+    if (!result.success) {
+        throw new Error(result.error || 'Failed to list resource groups');
+    }
+    return {
+        tool: 'listAzureResourceGroups',
+        success: true,
+        resourceGroups: result.resourceGroups,
+        count: result.resourceGroups?.length || 0,
+        message: result.resourceGroups && result.resourceGroups.length > 0
+            ? `Found ${result.resourceGroups.length} existing resource groups.`
+            : 'No existing resource groups found. A new one will be created.',
+    };
+}
+/**
+ * Handler for runCloudPerformanceTest tool
+ */
+async function handleCloudPerformanceTest(args) {
+    const { jmx_file_path, vm_name, resource_group, subscription_id, region = 'eastus', vm_size, reuse_existing_vm = false, existing_vm_ip, ssh_key_path, cleanup_after_test = false, test_duration_minutes = 30, output_path, } = args;
+    if (!jmx_file_path) {
+        throw new Error('Missing required field: jmx_file_path');
+    }
+    const config = {
+        jmxFilePath: jmx_file_path,
+        vmName: vm_name,
+        resourceGroup: resource_group,
+        subscriptionId: subscription_id,
+        region,
+        vmSize: vm_size,
+        reuseExistingVM: reuse_existing_vm,
+        existingVMIp: existing_vm_ip,
+        sshKeyPath: ssh_key_path,
+        cleanupAfterTest: cleanup_after_test,
+        testDurationMinutes: test_duration_minutes,
+        outputPath: output_path,
+    };
+    const result = await runCloudPerformanceTest(config);
+    return {
+        tool: 'runCloudPerformanceTest',
+        ...result,
+    };
+}
+/**
+ * Handler for getCloudTestRecommendation tool
+ */
+async function handleCloudTestRecommendation(args) {
+    const { jmx_file_path } = args;
+    if (!jmx_file_path) {
+        throw new Error('Missing required field: jmx_file_path');
+    }
+    const recommendation = getVMRecommendation(jmx_file_path);
+    return {
+        tool: 'getCloudTestRecommendation',
+        success: true,
+        jmxFile: jmx_file_path,
+        analysis: {
+            threadCount: recommendation.threadCount,
+            testDurationSeconds: recommendation.duration,
+        },
+        recommendation: {
+            vmSize: recommendation.recommendedSize,
+            estimatedCost: recommendation.estimatedCost,
+            description: recommendation.description,
+        },
+        message: `Analyzed JMX: ${recommendation.threadCount} threads, ${recommendation.duration}s duration. Recommended VM: ${recommendation.recommendedSize} (${recommendation.estimatedCost})`,
+    };
+}
+/**
+ * Handler for cleanupAzureResources tool
+ */
+async function handleCleanupAzureResources(args) {
+    const { resource_group, terraform_dir, force = true, confirmed = false } = args;
+    if (!resource_group) {
+        throw new Error('resource_group is required');
+    }
+    // Auto-detect Terraform directory by searching .perf-output/terraform/
+    let terraformDirPath = terraform_dir;
+    let detectedVmName;
+    if (!terraformDirPath) {
+        const terraformBaseDir = `${process.cwd()}/.perf-output/terraform`;
+        if (fs.existsSync(terraformBaseDir)) {
+            // Search all subdirectories for terraform state that matches the resource group
+            const subdirs = fs.readdirSync(terraformBaseDir).filter((d) => {
+                const fullPath = path.join(terraformBaseDir, d);
+                return fs.statSync(fullPath).isDirectory() && !d.startsWith('.');
+            });
+            console.error(`Searching for Terraform config matching resource group: ${resource_group}`);
+            console.error(`Found ${subdirs.length} terraform directories: ${subdirs.join(', ')}`);
+            for (const subdir of subdirs) {
+                const mainTfPath = path.join(terraformBaseDir, subdir, 'main.tf');
+                const tfStatePath = path.join(terraformBaseDir, subdir, 'terraform.tfstate');
+                // Check main.tf for resource_group (primary method)
+                if (fs.existsSync(mainTfPath)) {
+                    const content = fs.readFileSync(mainTfPath, 'utf-8');
+                    // Match patterns like: name = "rg-perf-test-agent" or name     = "rg-perf-test-agent"
+                    if (content.includes(`"${resource_group}"`)) {
+                        terraformDirPath = path.join(terraformBaseDir, subdir);
+                        detectedVmName = subdir;
+                        console.error(`✅ Auto-detected Terraform directory from main.tf: ${terraformDirPath}`);
+                        break;
+                    }
+                }
+                // Check terraform.tfstate for resource_group (backup method)
+                if (!terraformDirPath && fs.existsSync(tfStatePath)) {
+                    try {
+                        const stateContent = fs.readFileSync(tfStatePath, 'utf-8');
+                        if (stateContent.includes(`"${resource_group}"`)) {
+                            terraformDirPath = path.join(terraformBaseDir, subdir);
+                            detectedVmName = subdir;
+                            console.error(`✅ Auto-detected Terraform directory from state file: ${terraformDirPath}`);
+                            break;
+                        }
+                    }
+                    catch (e) {
+                        // State file might be corrupted or unreadable
+                    }
+                }
+            }
+            // If still not found, use the most recent terraform directory as fallback
+            if (!terraformDirPath && subdirs.length > 0) {
+                // Sort by modification time and use the most recent
+                const sortedDirs = subdirs.map((d) => {
+                    const fullPath = path.join(terraformBaseDir, d);
+                    return { name: d, mtime: fs.statSync(fullPath).mtime };
+                }).sort((a, b) => b.mtime - a.mtime);
+                terraformDirPath = path.join(terraformBaseDir, sortedDirs[0].name);
+                detectedVmName = sortedDirs[0].name;
+                console.error(`⚠️ Using most recent Terraform directory as fallback: ${terraformDirPath}`);
+            }
+        }
+        else {
+            console.error(`❌ Terraform base directory not found: ${terraformBaseDir}`);
+        }
+    }
+    // List resources that will be deleted
+    const resourcesToDelete = [
+        'Virtual Machine',
+        'Network Interface',
+        'Public IP Address',
+        'Virtual Network',
+        'Network Security Group',
+        'OS Disk',
+        'SSH Key (local file)',
+    ];
+    // If not confirmed, return preview of what will be deleted
+    if (!confirmed) {
+        return {
+            tool: 'cleanupAzureResources',
+            success: true,
+            requiresConfirmation: true,
+            message: `⚠️ CONFIRMATION REQUIRED: The following resources will be permanently deleted from resource group '${resource_group}':`,
+            resourceGroup: resource_group,
+            terraformDir: terraformDirPath,
+            detectedVmName: detectedVmName,
+            resourcesToDelete: resourcesToDelete,
+            deletionMethod: terraformDirPath ? 'Terraform destroy' : 'Azure CLI',
+            instructions: 'To proceed with deletion, call this tool again with confirmed=true',
+        };
+    }
+    // User confirmed, proceed with deletion
+    const result = await cleanupAzureResources(resource_group, terraformDirPath, force);
+    return {
+        tool: 'cleanupAzureResources',
+        ...result,
+        resourceGroup: resource_group,
+        terraformDir: terraformDirPath,
+        deletionMethod: terraformDirPath ? 'Terraform destroy' : 'Azure CLI',
+        mode: force ? 'async' : 'sync',
+    };
+}
+/**
+ * Handler for analyzeTestResults tool
+ */
+async function handleAnalyzeTestResults(args) {
+    const { result_file_path, resource_group, vm_name, test_start_time, test_end_time } = args;
+    if (!result_file_path) {
+        throw new Error('result_file_path is required');
+    }
+    const result = await analyzeTestResults(result_file_path, resource_group, vm_name, test_start_time, test_end_time);
+    return {
+        tool: 'analyzeTestResults',
+        ...result,
+    };
+}
+/**
+ * Handler for getVMMetrics tool
+ */
+async function handleGetVMMetrics(args) {
+    const { resource_group, vm_name, time_range = '1h', start_time, end_time, metrics = ['all'], terraform_dir } = args;
+    if (!resource_group) {
+        throw new Error('resource_group is required');
+    }
+    const result = await getVMMetrics({
+        resourceGroup: resource_group,
+        vmName: vm_name,
+        timeRange: time_range,
+        startTime: start_time,
+        endTime: end_time,
+        metrics,
+        terraformDir: terraform_dir
+    });
+    return {
+        tool: 'getVMMetrics',
+        ...result,
+    };
+}
 /**
  * Start the MCP server
  */
@@ -286,9 +1014,17 @@ async function main() {
     console.error('Starting Performance Agent MCP Server...');
     console.error('Available tools:');
     console.error('  1. generateJMXFromSwagger - Generate JMeter scripts from Swagger');
-    console.error('  2. analyzeCodeComplexity - Analyze code complexity in local repos');
-    console.error('  3. profileFunctionPerformance - Profile function execution time');
-    console.error(`API Base URL: ${API_BASE_URL}`);
+    console.error('  2. prepareJMXForTest - Workflow tool: Prepare and analyze JMX for testing');
+    console.error('  3. analyzeCodeComplexity - Analyze code complexity in local repos');
+    console.error('  4. profileFunctionPerformance - Profile function execution time');
+    console.error('  5. provisionAzureVM - Provision Azure VMs from natural language');
+    console.error('  6. listAzureSubscriptions - List Azure subscriptions');
+    console.error('  7. listAzureResourceGroups - List Azure resource groups');
+    console.error('  8. runCloudPerformanceTest - End-to-end cloud performance testing');
+    console.error('  9. getCloudTestRecommendation - Get VM recommendations for JMX');
+    console.error('  10. cleanupAzureResources - Cleanup Azure test infrastructure');
+    console.error('  11. analyzeTestResults - Detailed analysis of test results with VM metrics');
+    console.error('  12. getVMMetrics - Fetch Azure VM performance metrics from Azure Monitor');
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error('Performance Agent MCP Server running on stdio');