@edgible-team/cli 1.0.1

package/dist/services/AgentStatusManager.js

@@ -0,0 +1,299 @@
+"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.AgentStatusManager = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const events_1 = require("events");
+const crypto_1 = require("crypto");
+const UnifiedAgentStatus_1 = require("../types/UnifiedAgentStatus");
+const FileIntegrityManager_1 = require("../utils/FileIntegrityManager");
+const PathResolver_1 = require("../utils/PathResolver");
+const config_1 = require("../state/config");
+class AgentStatusManager extends events_1.EventEmitter {
+    constructor() {
+        super();
+        this.isWatching = false;
+        this.lastStatus = null;
+        this.watchIntervalMs = 1000; // 1 second
+        this.maxRetries = 3;
+        this.retryDelay = 500; // 500ms
+        // Get user config to determine installation type
+        const configManager = new config_1.ConfigManager();
+        const userConfig = configManager.getConfig();
+        // Resolve agent config paths based on installation type
+        const useSystemPath = userConfig.agentInstallationType === 'systemd' ||
+            userConfig.agentInstallationType === 'launchd' ||
+            userConfig.agentInstallationType === 'windows-service' ||
+            userConfig.agentInstallationType === 'docker' ||
+            userConfig.agentInstallationType === 'podman';
+        this.statusFile = PathResolver_1.PathResolver.getAgentStatusPath(useSystemPath);
+        this.configFile = PathResolver_1.PathResolver.getAgentConfigFilePath(useSystemPath);
+    }
+    async getStatus() {
+        const startTime = Date.now();
+        try {
+            // Check if status file exists
+            if (!await this.fileExists(this.statusFile)) {
+                return {
+                    status: null,
+                    isValid: false,
+                    error: 'Status file not found - agent may not be running',
+                    lastChecked: new Date()
+                };
+            }
+            // Use file integrity manager for safe reading
+            const result = await FileIntegrityManager_1.FileIntegrityManager.readJsonFileSafely(this.statusFile);
+            if (!result.isValid) {
+                // Try to cleanup corrupted files
+                await FileIntegrityManager_1.FileIntegrityManager.cleanupCorruptedFiles(path.dirname(this.statusFile));
+                return {
+                    status: null,
+                    isValid: false,
+                    error: result.error || 'Status file validation failed',
+                    lastChecked: new Date()
+                };
+            }
+            const statusData = result.data;
+            // Convert agent-v2 status to unified status
+            const status = (0, UnifiedAgentStatus_1.convertAgentV2Status)(statusData);
+            // Check if status is stale (older than 1 minute for more responsive detection)
+            const age = Date.now() - status.timestamp;
+            if (age > 60000) { // 1 minute instead of 2 minutes
+                return {
+                    status,
+                    isValid: false,
+                    error: 'Status is stale - agent may not be responding',
+                    lastChecked: new Date()
+                };
+            }
+            this.lastStatus = status;
+            return {
+                status,
+                isValid: true,
+                lastChecked: new Date()
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            return {
+                status: this.lastStatus, // Return last known status if available
+                isValid: false,
+                error: `Failed to read status: ${errorMessage}`,
+                lastChecked: new Date()
+            };
+        }
+    }
+    async updateConfig(config) {
+        try {
+            // Ensure directory exists
+            const configDir = path.dirname(this.configFile);
+            await fs.mkdir(configDir, { recursive: true });
+            // Use file integrity manager for safe writing
+            const result = await FileIntegrityManager_1.FileIntegrityManager.writeJsonFileSafely(this.configFile, config);
+            if (!result.success) {
+                throw new Error(result.error || 'Failed to write config file');
+            }
+            this.emit('configUpdated', config);
+        }
+        catch (error) {
+            console.error('Failed to update agent config:', error);
+            throw error;
+        }
+    }
+    startWatching(callback) {
+        if (this.isWatching) {
+            console.warn('Already watching agent status');
+            return;
+        }
+        this.isWatching = true;
+        // Watch for status file changes
+        this.watchInterval = setInterval(async () => {
+            try {
+                const result = await this.getStatus();
+                callback(result);
+            }
+            catch (error) {
+                console.error('Error in status watch callback:', error);
+            }
+        }, this.watchIntervalMs);
+        console.log('Started watching agent status');
+    }
+    stopWatching() {
+        if (this.watchInterval) {
+            clearInterval(this.watchInterval);
+            this.watchInterval = undefined;
+        }
+        this.isWatching = false;
+        console.log('Stopped watching agent status');
+    }
+    async fileExists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async readStatusFileWithRetry() {
+        let lastError = null;
+        for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+            try {
+                const data = await fs.readFile(this.statusFile, 'utf8');
+                return JSON.parse(data);
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error('Unknown error');
+                if (attempt < this.maxRetries) {
+                    // Wait before retry
+                    await new Promise(resolve => setTimeout(resolve, this.retryDelay * attempt));
+                }
+            }
+        }
+        throw lastError || new Error('Failed to read status file');
+    }
+    async validateStatusFile(statusData) {
+        try {
+            // Check if metadata exists
+            if (!statusData.metadata) {
+                console.warn('Status file missing metadata');
+                return false;
+            }
+            const metadata = statusData.metadata;
+            // Verify checksum
+            const statusWithoutMetadata = { ...statusData };
+            delete statusWithoutMetadata.metadata;
+            const expectedChecksum = this.calculateChecksum(statusWithoutMetadata);
+            if (metadata.checksum !== expectedChecksum) {
+                console.warn('Status file checksum mismatch');
+                return false;
+            }
+            // Check if file is too old (more than 1 hour)
+            const age = Date.now() - metadata.lastModified;
+            if (age > 3600000) { // 1 hour
+                console.warn('Status file is too old');
+                return false;
+            }
+            // Check required fields
+            const requiredFields = ['running', 'health', 'timestamp', 'pid'];
+            for (const field of requiredFields) {
+                if (statusWithoutMetadata[field] === undefined) {
+                    console.warn(`Status file missing required field: ${field}`);
+                    return false;
+                }
+            }
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to validate status file:', error);
+            return false;
+        }
+    }
+    calculateChecksum(status) {
+        const statusString = JSON.stringify(status);
+        return (0, crypto_1.createHash)('sha256').update(statusString).digest('hex').substring(0, 16);
+    }
+    // Public method to get status file path
+    getStatusFilePath() {
+        return this.statusFile;
+    }
+    // Public method to get config file path
+    getConfigFilePath() {
+        return this.configFile;
+    }
+    // Public method to check if agent is running based on file existence and content
+    async isAgentRunning() {
+        try {
+            const result = await this.getStatus();
+            return result.isValid && result.status?.running === true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // Public method to get agent PID
+    async getAgentPID() {
+        try {
+            const result = await this.getStatus();
+            return result.status?.pid || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    // Public method to get agent uptime
+    async getAgentUptime() {
+        try {
+            const result = await this.getStatus();
+            return result.status?.uptime || 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+    // Public method to get agent version
+    async getAgentVersion() {
+        try {
+            const result = await this.getStatus();
+            return result.status?.version || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    // Public method to get agent health
+    async getAgentHealth() {
+        try {
+            const result = await this.getStatus();
+            return result.status?.health || 'unknown';
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    // Public method to get current status
+    async getCurrentStatus() {
+        try {
+            const result = await this.getStatus();
+            return result.status;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.AgentStatusManager = AgentStatusManager;
+//# sourceMappingURL=AgentStatusManager.js.map

package/dist/services/ConnectivityTester.js

@@ -0,0 +1,271 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectivityTester = void 0;
+const network_utils_1 = require("../utils/network-utils");
+const health_checker_1 = require("../utils/health-checker");
+class ConnectivityTester {
+    /**
+     * Test TCP/UDP port connectivity
+     */
+    async testPortConnectivity(host, port, protocol, timeout = 5000) {
+        const startTime = Date.now();
+        let result;
+        if (protocol === 'tcp') {
+            result = await network_utils_1.NetworkUtils.testTcpPort(host, port, timeout);
+        }
+        else {
+            result = await network_utils_1.NetworkUtils.testUdpPort(host, port, timeout);
+        }
+        return {
+            success: result.success,
+            latency: result.latency,
+            error: result.error,
+            timestamp: new Date(),
+            host,
+            port,
+            protocol
+        };
+    }
+    /**
+     * Test HTTP/HTTPS endpoint health
+     */
+    async testHttpEndpoint(url, expectedStatus, timeout = 5000) {
+        const config = {
+            enabled: true,
+            interval: 30,
+            timeout: timeout / 1000,
+            retries: 1,
+            expectedStatus
+        };
+        const options = {
+            timeout,
+            expectedStatus
+        };
+        return await health_checker_1.HealthChecker.checkHttpHealth(url, config, options);
+    }
+    /**
+     * Test application-specific endpoints
+     */
+    async testApplicationEndpoint(application, gatewayIp) {
+        const protocol = application.protocol === 'https' ? 'https' : 'http';
+        const url = `${protocol}://${gatewayIp}:${application.port}`;
+        const httpResult = await this.testHttpEndpoint(url, 200, 10000);
+        return {
+            ...httpResult,
+            applicationId: application.id,
+            gatewayIp,
+            workloadIp: application.servingIp,
+            port: application.port,
+            protocol: application.protocol,
+            testType: 'http'
+        };
+    }
+    /**
+     * Comprehensive connectivity test from gateway to workload
+     */
+    async testGatewayToWorkloadConnectivity(gateway, workload, port) {
+        const startTime = Date.now();
+        const tests = [];
+        const recommendations = [];
+        // Test 1: Basic port connectivity
+        const portTest = await this.testPortConnectivity(workload.ipAddress || 'localhost', port, 'tcp', 5000);
+        tests.push({
+            success: portTest.success,
+            applicationId: 'test',
+            gatewayIp: gateway.publicIp,
+            workloadIp: workload.ipAddress || 'localhost',
+            port,
+            protocol: 'tcp',
+            testType: 'connectivity',
+            host: workload.ipAddress || 'localhost',
+            latency: portTest.latency,
+            error: portTest.error,
+            timestamp: portTest.timestamp,
+            url: `tcp://${workload.ipAddress || 'localhost'}:${port}`,
+            method: 'CONNECT'
+        });
+        // Test 2: HTTP endpoint test (if applicable)
+        if (port === 80 || port === 443 || port === 8080 || port === 3000) {
+            const protocol = port === 443 ? 'https' : 'http';
+            const url = `${protocol}://${workload.ipAddress || 'localhost'}:${port}`;
+            const httpTest = await this.testHttpEndpoint(url, 200, 5000);
+            tests.push({
+                ...httpTest,
+                applicationId: 'test',
+                gatewayIp: gateway.publicIp,
+                workloadIp: workload.ipAddress || 'localhost',
+                port,
+                protocol: protocol,
+                testType: 'http'
+            });
+        }
+        // Test 3: Gateway to workload connectivity
+        if (workload.ipAddress && workload.ipAddress !== 'localhost') {
+            const gatewayToWorkloadTest = await this.testPortConnectivity(workload.ipAddress, port, 'tcp', 10000);
+            tests.push({
+                success: gatewayToWorkloadTest.success,
+                applicationId: 'test',
+                gatewayIp: gateway.publicIp,
+                workloadIp: workload.ipAddress,
+                port,
+                protocol: 'tcp',
+                testType: 'connectivity',
+                host: workload.ipAddress,
+                latency: gatewayToWorkloadTest.latency,
+                error: gatewayToWorkloadTest.error,
+                timestamp: gatewayToWorkloadTest.timestamp,
+                url: `tcp://${workload.ipAddress}:${port}`,
+                method: 'CONNECT'
+            });
+        }
+        // Generate diagnostics
+        const diagnostics = await this.generateDiagnostics(tests, gateway, workload);
+        // Generate recommendations
+        if (!tests.every(t => t.success)) {
+            recommendations.push('Check firewall settings on both gateway and workload');
+            recommendations.push('Verify the workload service is running and listening on the correct port');
+            recommendations.push('Ensure network connectivity between gateway and workload');
+        }
+        if (tests.some(t => t.latency && t.latency > 1000)) {
+            recommendations.push('High latency detected - check network performance');
+        }
+        const overall = tests.length > 0 && tests.every(t => t.success);
+        return {
+            overall,
+            tests,
+            diagnostics,
+            recommendations,
+            timestamp: new Date(),
+            duration: Date.now() - startTime
+        };
+    }
+    /**
+     * Network diagnostics and troubleshooting
+     */
+    async diagnoseConnectivityIssues(application) {
+        const networkIssues = [];
+        const configurationIssues = [];
+        const serviceIssues = [];
+        const suggestions = [];
+        // Test basic connectivity
+        const portTest = await this.testPortConnectivity(application.servingIp, application.port, 'tcp', 5000);
+        if (!portTest.success) {
+            if (portTest.error?.includes('ECONNREFUSED')) {
+                serviceIssues.push({
+                    type: 'service_down',
+                    severity: 'critical',
+                    description: 'Service is not running or not accepting connections',
+                    affectedServices: [application.name],
+                    suggestedFix: 'Start the service or check if it\'s listening on the correct port'
+                });
+            }
+            else if (portTest.error?.includes('ETIMEDOUT')) {
+                networkIssues.push({
+                    type: 'timeout',
+                    severity: 'high',
+                    description: 'Connection timeout - service may be overloaded or unreachable',
+                    affectedHosts: [application.servingIp],
+                    suggestedFix: 'Check network connectivity and service performance'
+                });
+            }
+            else if (portTest.error?.includes('ENOTFOUND')) {
+                networkIssues.push({
+                    type: 'dns',
+                    severity: 'high',
+                    description: 'Host not found - DNS resolution failed',
+                    affectedHosts: [application.servingIp],
+                    suggestedFix: 'Check DNS configuration and hostname resolution'
+                });
+            }
+        }
+        // Test HTTP endpoint if applicable
+        if (application.protocol === 'http' || application.protocol === 'https') {
+            const url = `${application.protocol}://${application.servingIp}:${application.port}`;
+            const httpTest = await this.testHttpEndpoint(url, 200, 5000);
+            if (!httpTest.success) {
+                if (httpTest.statusCode && httpTest.statusCode >= 500) {
+                    serviceIssues.push({
+                        type: 'service_error',
+                        severity: 'high',
+                        description: `Service returned error status ${httpTest.statusCode}`,
+                        affectedServices: [application.name],
+                        suggestedFix: 'Check service logs and application health'
+                    });
+                }
+                else if (httpTest.statusCode && httpTest.statusCode >= 400) {
+                    configurationIssues.push({
+                        type: 'service_not_running',
+                        severity: 'medium',
+                        description: `Service returned client error ${httpTest.statusCode}`,
+                        affectedServices: [application.name],
+                        suggestedFix: 'Check application configuration and request format'
+                    });
+                }
+            }
+        }
+        // Generate suggestions based on issues found
+        if (networkIssues.length > 0) {
+            suggestions.push('Check network connectivity and firewall rules');
+        }
+        if (configurationIssues.length > 0) {
+            suggestions.push('Review application configuration and service settings');
+        }
+        if (serviceIssues.length > 0) {
+            suggestions.push('Check service status and application logs');
+        }
+        return {
+            networkIssues,
+            configurationIssues,
+            serviceIssues,
+            suggestions
+        };
+    }
+    /**
+     * Generate diagnostics from test results
+     */
+    async generateDiagnostics(tests, gateway, workload) {
+        const networkIssues = [];
+        const configurationIssues = [];
+        const serviceIssues = [];
+        const suggestions = [];
+        for (const test of tests) {
+            if (!test.success) {
+                if (test.error?.includes('ECONNREFUSED')) {
+                    serviceIssues.push({
+                        type: 'service_down',
+                        severity: 'critical',
+                        description: 'Service is not running or not accepting connections',
+                        affectedServices: [workload.name],
+                        suggestedFix: 'Start the service or check if it\'s listening on the correct port'
+                    });
+                }
+                else if (test.error?.includes('ETIMEDOUT')) {
+                    networkIssues.push({
+                        type: 'timeout',
+                        severity: 'high',
+                        description: 'Connection timeout - service may be overloaded or unreachable',
+                        affectedHosts: [test.host],
+                        suggestedFix: 'Check network connectivity and service performance'
+                    });
+                }
+                else if (test.error?.includes('ENOTFOUND')) {
+                    networkIssues.push({
+                        type: 'dns',
+                        severity: 'high',
+                        description: 'Host not found - DNS resolution failed',
+                        affectedHosts: [test.host],
+                        suggestedFix: 'Check DNS configuration and hostname resolution'
+                    });
+                }
+            }
+        }
+        return {
+            networkIssues,
+            configurationIssues,
+            serviceIssues,
+            suggestions
+        };
+    }
+}
+exports.ConnectivityTester = ConnectivityTester;
+//# sourceMappingURL=ConnectivityTester.js.map