@testsmith/perfornium 0.1.0

package/dist/cli/commands/mock.d.ts

@@ -0,0 +1,7 @@
+interface MockOptions {
+    port?: string;
+    host?: string;
+    delay?: string;
+}
+export declare function mockCommand(options: MockOptions): Promise<void>;
+export {};

package/dist/cli/commands/mock.js

@@ -0,0 +1,281 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockCommand = mockCommand;
+const http = __importStar(require("http"));
+const logger_1 = require("../../utils/logger");
+// Sample data for mock endpoints
+const users = [
+    { id: 1, name: 'Alice Johnson', email: 'alice@example.com', role: 'admin' },
+    { id: 2, name: 'Bob Smith', email: 'bob@example.com', role: 'user' },
+    { id: 3, name: 'Charlie Brown', email: 'charlie@example.com', role: 'user' },
+    { id: 4, name: 'Diana Prince', email: 'diana@example.com', role: 'moderator' },
+    { id: 5, name: 'Eve Wilson', email: 'eve@example.com', role: 'user' },
+];
+const products = [
+    { id: 'P001', name: 'Laptop', price: 999.99, category: 'Electronics', inStock: true },
+    { id: 'P002', name: 'Smartphone', price: 599.99, category: 'Electronics', inStock: true },
+    { id: 'P003', name: 'Headphones', price: 149.99, category: 'Electronics', inStock: false },
+    { id: 'P004', name: 'Keyboard', price: 79.99, category: 'Accessories', inStock: true },
+    { id: 'P005', name: 'Mouse', price: 39.99, category: 'Accessories', inStock: true },
+];
+let requestCount = 0;
+const startTime = Date.now();
+async function mockCommand(options) {
+    const port = parseInt(options.port || '3000');
+    const host = options.host || 'localhost';
+    const delay = parseInt(options.delay || '0');
+    const server = http.createServer(async (req, res) => {
+        requestCount++;
+        const requestId = requestCount;
+        // Add artificial delay if configured
+        if (delay > 0) {
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+        // CORS headers
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+        res.setHeader('Content-Type', 'application/json');
+        // Handle OPTIONS (preflight)
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        const url = new URL(req.url || '/', `http://${host}:${port}`);
+        const path = url.pathname;
+        logger_1.logger.debug(`[${requestId}] ${req.method} ${path}`);
+        try {
+            // Route handling
+            if (path === '/status' || path === '/health') {
+                // Health check endpoint
+                res.writeHead(200);
+                res.end(JSON.stringify({
+                    status: 'ok',
+                    timestamp: new Date().toISOString(),
+                    uptime: Math.floor((Date.now() - startTime) / 1000),
+                    requests: requestCount
+                }));
+            }
+            else if (path === '/users' && req.method === 'GET') {
+                // List users
+                res.writeHead(200);
+                res.end(JSON.stringify(users));
+            }
+            else if (path.match(/^\/users\/\d+$/) && req.method === 'GET') {
+                // Get single user
+                const id = parseInt(path.split('/')[2]);
+                const user = users.find(u => u.id === id);
+                if (user) {
+                    res.writeHead(200);
+                    res.end(JSON.stringify(user));
+                }
+                else {
+                    res.writeHead(404);
+                    res.end(JSON.stringify({ error: 'User not found', id }));
+                }
+            }
+            else if (path === '/users' && req.method === 'POST') {
+                // Create user
+                let body = '';
+                req.on('data', chunk => body += chunk);
+                req.on('end', () => {
+                    try {
+                        const data = JSON.parse(body);
+                        const newUser = {
+                            id: users.length + 1,
+                            name: data.name || 'New User',
+                            email: data.email || 'new@example.com',
+                            role: data.role || 'user'
+                        };
+                        users.push(newUser);
+                        res.writeHead(201);
+                        res.end(JSON.stringify(newUser));
+                    }
+                    catch {
+                        res.writeHead(400);
+                        res.end(JSON.stringify({ error: 'Invalid JSON body' }));
+                    }
+                });
+                return;
+            }
+            else if (path === '/products' && req.method === 'GET') {
+                // List products with optional filtering
+                const category = url.searchParams.get('category');
+                const inStock = url.searchParams.get('inStock');
+                let filtered = [...products];
+                if (category) {
+                    filtered = filtered.filter(p => p.category.toLowerCase() === category.toLowerCase());
+                }
+                if (inStock !== null) {
+                    filtered = filtered.filter(p => p.inStock === (inStock === 'true'));
+                }
+                res.writeHead(200);
+                res.end(JSON.stringify(filtered));
+            }
+            else if (path.match(/^\/products\/P\d+$/) && req.method === 'GET') {
+                // Get single product
+                const id = path.split('/')[2];
+                const product = products.find(p => p.id === id);
+                if (product) {
+                    res.writeHead(200);
+                    res.end(JSON.stringify(product));
+                }
+                else {
+                    res.writeHead(404);
+                    res.end(JSON.stringify({ error: 'Product not found', id }));
+                }
+            }
+            else if (path === '/auth/login' && req.method === 'POST') {
+                // Login endpoint
+                let body = '';
+                req.on('data', chunk => body += chunk);
+                req.on('end', () => {
+                    try {
+                        const data = JSON.parse(body);
+                        if (data.username && data.password) {
+                            res.writeHead(200);
+                            res.end(JSON.stringify({
+                                token: `mock-token-${Date.now()}`,
+                                user: { username: data.username, role: 'user' },
+                                expiresIn: 3600
+                            }));
+                        }
+                        else {
+                            res.writeHead(401);
+                            res.end(JSON.stringify({ error: 'Invalid credentials' }));
+                        }
+                    }
+                    catch {
+                        res.writeHead(400);
+                        res.end(JSON.stringify({ error: 'Invalid JSON body' }));
+                    }
+                });
+                return;
+            }
+            else if (path === '/echo' && req.method === 'POST') {
+                // Echo back the request body
+                let body = '';
+                req.on('data', chunk => body += chunk);
+                req.on('end', () => {
+                    res.writeHead(200);
+                    res.end(JSON.stringify({
+                        method: req.method,
+                        path: path,
+                        headers: req.headers,
+                        body: body ? JSON.parse(body) : null,
+                        timestamp: new Date().toISOString()
+                    }));
+                });
+                return;
+            }
+            else if (path === '/delay' && req.method === 'GET') {
+                // Configurable delay endpoint
+                const ms = parseInt(url.searchParams.get('ms') || '1000');
+                await new Promise(resolve => setTimeout(resolve, ms));
+                res.writeHead(200);
+                res.end(JSON.stringify({ delayed: ms, timestamp: new Date().toISOString() }));
+            }
+            else if (path === '/error' && req.method === 'GET') {
+                // Simulate error responses
+                const code = parseInt(url.searchParams.get('code') || '500');
+                res.writeHead(code);
+                res.end(JSON.stringify({ error: `Simulated ${code} error`, code }));
+            }
+            else if (path === '/random' && req.method === 'GET') {
+                // Random data endpoint
+                res.writeHead(200);
+                res.end(JSON.stringify({
+                    id: Math.floor(Math.random() * 10000),
+                    uuid: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+                    timestamp: new Date().toISOString(),
+                    random: Math.random()
+                }));
+            }
+            else {
+                // 404 for unknown routes
+                res.writeHead(404);
+                res.end(JSON.stringify({
+                    error: 'Not found',
+                    path,
+                    availableEndpoints: [
+                        'GET  /status',
+                        'GET  /health',
+                        'GET  /users',
+                        'GET  /users/:id',
+                        'POST /users',
+                        'GET  /products',
+                        'GET  /products/:id',
+                        'POST /auth/login',
+                        'POST /echo',
+                        'GET  /delay?ms=1000',
+                        'GET  /error?code=500',
+                        'GET  /random'
+                    ]
+                }));
+            }
+        }
+        catch {
+            res.writeHead(500);
+            res.end(JSON.stringify({ error: 'Internal server error' }));
+        }
+    });
+    server.listen(port, host, () => {
+        logger_1.logger.success(`\n🚀 Mock server running at http://${host}:${port}\n`);
+        logger_1.logger.info('Available endpoints:');
+        logger_1.logger.info('  GET  /status          - Health check');
+        logger_1.logger.info('  GET  /health          - Health check (alias)');
+        logger_1.logger.info('  GET  /users           - List all users');
+        logger_1.logger.info('  GET  /users/:id       - Get user by ID');
+        logger_1.logger.info('  POST /users           - Create user');
+        logger_1.logger.info('  GET  /products        - List products (?category=X&inStock=true)');
+        logger_1.logger.info('  GET  /products/:id    - Get product by ID');
+        logger_1.logger.info('  POST /auth/login      - Login (returns token)');
+        logger_1.logger.info('  POST /echo            - Echo request body');
+        logger_1.logger.info('  GET  /delay?ms=1000   - Delayed response');
+        logger_1.logger.info('  GET  /error?code=500  - Simulate error');
+        logger_1.logger.info('  GET  /random          - Random data');
+        logger_1.logger.info('\nPress Ctrl+C to stop\n');
+    });
+    // Handle graceful shutdown
+    process.on('SIGINT', () => {
+        logger_1.logger.info('\nShutting down mock server...');
+        server.close(() => {
+            logger_1.logger.success('Mock server stopped');
+            process.exit(0);
+        });
+    });
+}

package/dist/cli/commands/report.d.ts

@@ -0,0 +1,5 @@
+export declare function reportCommand(resultsPath: string, options: {
+    output?: string;
+    template?: string;
+    title?: string;
+}): Promise<void>;

package/dist/cli/commands/report.js

@@ -0,0 +1,70 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportCommand = reportCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const enhanced_html_generator_1 = require("../../reporting/enhanced-html-generator");
+const logger_1 = require("../../utils/logger");
+async function reportCommand(resultsPath, options) {
+    try {
+        logger_1.logger.info(`📊 Generating report from: ${resultsPath}`);
+        if (!fs.existsSync(resultsPath)) {
+            logger_1.logger.error(`❌ Results file not found: ${resultsPath}`);
+            process.exit(1);
+        }
+        const resultsContent = fs.readFileSync(resultsPath, 'utf8');
+        let resultsData;
+        if (resultsPath.endsWith('.json')) {
+            resultsData = JSON.parse(resultsContent);
+        }
+        else {
+            logger_1.logger.error('❌ Only JSON results files are currently supported');
+            process.exit(1);
+        }
+        const generator = new enhanced_html_generator_1.EnhancedHTMLReportGenerator();
+        const outputPath = options.output || 'report.html';
+        await generator.generate({
+            testName: options.title || resultsData.testName || 'Performance Test',
+            summary: resultsData.summary,
+            results: resultsData.results || []
+        }, outputPath);
+        logger_1.logger.success(`✅ Report generated: ${path.resolve(outputPath)}`);
+    }
+    catch (error) {
+        logger_1.logger.error(`❌ Report generation failed: ${error.message}`);
+        process.exit(1);
+    }
+}

package/dist/cli/commands/run.d.ts

@@ -0,0 +1,12 @@
+export interface RunOptions {
+    env?: string;
+    workers?: string;
+    output?: string;
+    report?: boolean;
+    dryRun?: boolean;
+    verbose?: boolean;
+    debug?: boolean;
+    maxUsers?: string;
+    global?: string[];
+}
+export declare function runCommand(configPath: string, options: RunOptions): Promise<void>;

package/dist/cli/commands/run.js

@@ -0,0 +1,260 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = runCommand;
+const path = __importStar(require("path"));
+const http = __importStar(require("http"));
+const parser_1 = require("../../config/parser");
+const validator_1 = require("../../config/validator");
+const test_runner_1 = require("../../core/test-runner");
+const logger_1 = require("../../utils/logger");
+// Lightweight mock server for testing
+let mockServer = null;
+let mockRequestCount = 0;
+const mockStartTime = Date.now();
+function startMockServer(port = 3000) {
+    return new Promise((resolve, reject) => {
+        mockServer = http.createServer((req, res) => {
+            mockRequestCount++;
+            res.setHeader('Content-Type', 'application/json');
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            if (req.method === 'OPTIONS') {
+                res.writeHead(204);
+                res.end();
+                return;
+            }
+            // Simple /status endpoint
+            res.writeHead(200);
+            res.end(JSON.stringify({
+                status: 'ok',
+                timestamp: new Date().toISOString(),
+                uptime: Math.floor((Date.now() - mockStartTime) / 1000),
+                requests: mockRequestCount
+            }));
+        });
+        mockServer.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                logger_1.logger.warn(`Port ${port} in use, mock server not started`);
+                resolve(); // Continue without mock server
+            }
+            else {
+                reject(err);
+            }
+        });
+        mockServer.listen(port, 'localhost', () => {
+            logger_1.logger.info(`🎯 Mock server started at http://localhost:${port}/status`);
+            resolve();
+        });
+    });
+}
+function stopMockServer() {
+    if (mockServer) {
+        mockServer.close();
+        mockServer = null;
+    }
+}
+async function runCommand(configPath, options) {
+    try {
+        // Set log level: default=WARN, --verbose=INFO, --debug=DEBUG
+        if (options.debug) {
+            logger_1.logger.setLevel(logger_1.LogLevel.DEBUG);
+        }
+        else if (options.verbose) {
+            logger_1.logger.setLevel(logger_1.LogLevel.INFO);
+        }
+        logger_1.logger.info(`Loading configuration: ${configPath}`);
+        const parser = new parser_1.ConfigParser();
+        const config = await parser.parse(configPath, options.env);
+        // Apply CLI global variable overrides
+        applyGlobalOverrides(config, options);
+        // Auto-start mock server if base_url targets localhost:3000
+        const baseUrl = config.global?.base_url || '';
+        if (baseUrl.match(/^https?:\/\/localhost:3000/)) {
+            await startMockServer(3000);
+        }
+        // Apply max users override
+        if (options.maxUsers) {
+            const maxUsers = parseInt(options.maxUsers);
+            const { getPrimaryLoadPhase } = await Promise.resolve().then(() => __importStar(require('../../config/types/load-config')));
+            const primaryPhase = getPrimaryLoadPhase(config.load);
+            const currentUsers = primaryPhase.virtual_users || primaryPhase.vus;
+            if (currentUsers && currentUsers > maxUsers) {
+                logger_1.logger.warn(`Limiting virtual users from ${currentUsers} to ${maxUsers}`);
+                primaryPhase.virtual_users = maxUsers;
+            }
+        }
+        // Process templates with environment variables
+        const processedConfig = parser.processTemplates(config, {
+            env: process.env,
+            timestamp: Date.now(),
+            datetime: new Date().toISOString()
+        });
+        logger_1.logger.info(`Validating configuration...`);
+        const validator = new validator_1.ConfigValidator();
+        const validation = validator.validate(processedConfig);
+        if (!validation.valid) {
+            logger_1.logger.error('Configuration validation failed:');
+            validation.errors.forEach(error => logger_1.logger.error(`  - ${error}`));
+            process.exit(1);
+        }
+        if (validation.warnings.length > 0) {
+            logger_1.logger.warn('Configuration warnings:');
+            validation.warnings.forEach(warning => logger_1.logger.warn(`  - ${warning}`));
+        }
+        if (options.dryRun) {
+            logger_1.logger.success('Configuration is valid');
+            return;
+        }
+        // Override output directory if specified
+        if (options.output && processedConfig.outputs) {
+            processedConfig.outputs.forEach(output => {
+                if (output.file) {
+                    output.file = path.join(options.output, path.basename(output.file));
+                }
+            });
+        }
+        // Enable report generation if requested
+        if (options.report) {
+            processedConfig.report = {
+                generate: true,
+                output: options.output ? path.join(options.output, 'report.html') : 'report.html',
+                ...processedConfig.report
+            };
+        }
+        if (options.workers) {
+            const { WorkerManager } = await Promise.resolve().then(() => __importStar(require('../../workers/manager')));
+            const manager = new WorkerManager();
+            const workerAddresses = options.workers.split(',').map(w => w.trim());
+            for (const address of workerAddresses) {
+                await manager.addWorker(address);
+            }
+            await manager.distributeTest(processedConfig);
+            await manager.waitForCompletion();
+            const metrics = manager.getAggregatedMetrics();
+            const summary = metrics.getSummary();
+            logger_1.logger.success(`Distributed test completed: ${summary.success_rate.toFixed(2)}% success rate`);
+            await manager.cleanup();
+        }
+        else {
+            const runner = new test_runner_1.TestRunner(processedConfig);
+            // Set up graceful shutdown
+            process.on('SIGINT', async () => {
+                logger_1.logger.info('Received SIGINT, stopping test...');
+                await runner.stop();
+                process.exit(0);
+            });
+            await runner.run();
+        }
+    }
+    catch (error) {
+        logger_1.logger.error(`Test execution failed: ${error.message}`);
+        if (options.verbose || options.debug) {
+            console.error(error.stack);
+        }
+        process.exit(1);
+    }
+    finally {
+        // Stop mock server if it was started
+        stopMockServer();
+    }
+}
+/**
+ * Apply CLI global variable overrides to the config
+ * Supports dot notation for nested properties: browser.headless=false
+ */
+function applyGlobalOverrides(config, options) {
+    if (!options.global || options.global.length === 0) {
+        return;
+    }
+    // Ensure global config exists
+    if (!config.global) {
+        config.global = {};
+    }
+    for (const override of options.global) {
+        const eqIndex = override.indexOf('=');
+        if (eqIndex === -1) {
+            logger_1.logger.warn(`Invalid global override format: ${override} (expected key=value)`);
+            continue;
+        }
+        const key = override.substring(0, eqIndex);
+        const rawValue = override.substring(eqIndex + 1);
+        const value = parseValue(rawValue);
+        logger_1.logger.info(`Overriding global.${key} = ${JSON.stringify(value)}`);
+        setNestedValue(config.global, key, value);
+    }
+}
+/**
+ * Parse a string value to its appropriate type
+ */
+function parseValue(value) {
+    // Boolean
+    if (value.toLowerCase() === 'true')
+        return true;
+    if (value.toLowerCase() === 'false')
+        return false;
+    // Number (integer or float)
+    if (/^-?\d+$/.test(value))
+        return parseInt(value, 10);
+    if (/^-?\d+\.\d+$/.test(value))
+        return parseFloat(value);
+    // JSON object or array
+    if ((value.startsWith('{') && value.endsWith('}')) ||
+        (value.startsWith('[') && value.endsWith(']'))) {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            // Not valid JSON, return as string
+        }
+    }
+    // String (keep as-is)
+    return value;
+}
+/**
+ * Set a nested value using dot notation
+ * Example: setNestedValue(obj, 'browser.headless', false)
+ */
+function setNestedValue(obj, path, value) {
+    const parts = path.split('.');
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (!(part in current) || typeof current[part] !== 'object') {
+            current[part] = {};
+        }
+        current = current[part];
+    }
+    current[parts[parts.length - 1]] = value;
+}

package/dist/cli/commands/validate.d.ts

@@ -0,0 +1,3 @@
+export declare function validateCommand(configPath: string, options: {
+    env?: string;
+}): Promise<void>;

package/dist/cli/commands/validate.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCommand = validateCommand;
+const parser_1 = require("../../config/parser");
+const validator_1 = require("../../config/validator");
+const logger_1 = require("../../utils/logger");
+async function validateCommand(configPath, options) {
+    try {
+        logger_1.logger.info(`🔍 Validating configuration: ${configPath}`);
+        const parser = new parser_1.ConfigParser();
+        const config = await parser.parse(configPath, options.env);
+        const validator = new validator_1.ConfigValidator();
+        const result = validator.validate(config);
+        if (result.valid) {
+            logger_1.logger.success('✅ Configuration is valid');
+            if (result.warnings.length > 0) {
+                logger_1.logger.warn('⚠️  Warnings:');
+                result.warnings.forEach(warning => logger_1.logger.warn(`  - ${warning}`));
+            }
+        }
+        else {
+            logger_1.logger.error('❌ Configuration validation failed:');
+            result.errors.forEach(error => logger_1.logger.error(`  - ${error}`));
+            if (result.warnings.length > 0) {
+                logger_1.logger.warn('⚠️  Warnings:');
+                result.warnings.forEach(warning => logger_1.logger.warn(`  - ${warning}`));
+            }
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        logger_1.logger.error(`❌ Validation failed: ${error.message}`);
+        process.exit(1);
+    }
+}