@edgible-team/cli 1.0.1

package/dist/detection/ToolDetector.js

@@ -0,0 +1,305 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolDetector = void 0;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+class ToolDetector {
+    static async detectTools() {
+        const detectedTools = [];
+        for (const tool of this.tools) {
+            try {
+                const version = this.getToolVersion(tool.command);
+                if (version !== null) {
+                    detectedTools.push({
+                        ...tool,
+                        available: true,
+                        version: version
+                    });
+                }
+                else {
+                    detectedTools.push({
+                        ...tool,
+                        available: false
+                    });
+                }
+            }
+            catch (error) {
+                // Tool not available
+                detectedTools.push({
+                    ...tool,
+                    available: false
+                });
+            }
+        }
+        return detectedTools;
+    }
+    static getToolVersion(command) {
+        try {
+            // Special handling for different tools
+            if (command === 'docker') {
+                const output = (0, child_process_1.execSync)('docker --version', { encoding: 'utf8', timeout: 5000 });
+                return output.trim().replace('Docker version ', '');
+            }
+            if (command === 'kubectl') {
+                const output = (0, child_process_1.execSync)('kubectl version --client', { encoding: 'utf8', timeout: 5000 });
+                const lines = output.split('\n');
+                const versionLine = lines.find(line => line.includes('Client Version:'));
+                return versionLine ? versionLine.trim().replace('Client Version: ', '') : 'Unknown';
+            }
+            if (command === 'aws') {
+                const output = (0, child_process_1.execSync)('aws --version', { encoding: 'utf8', timeout: 5000 });
+                return output.trim().replace('aws-cli/', '');
+            }
+            if (command === 'az') {
+                const output = (0, child_process_1.execSync)('az --version', { encoding: 'utf8', timeout: 5000 });
+                const lines = output.split('\n');
+                const versionLine = lines.find(line => line.includes('azure-cli'));
+                return versionLine ? versionLine.trim().replace('azure-cli ', '') : 'Unknown';
+            }
+            if (command === 'gcloud') {
+                const output = (0, child_process_1.execSync)('gcloud --version', { encoding: 'utf8', timeout: 5000 });
+                const lines = output.split('\n');
+                const versionLine = lines.find(line => line.includes('Google Cloud SDK'));
+                return versionLine ? versionLine.trim().replace('Google Cloud SDK ', '') : 'Unknown';
+            }
+            if (command === 'terraform') {
+                const output = (0, child_process_1.execSync)('terraform --version', { encoding: 'utf8', timeout: 5000 });
+                const lines = output.split('\n');
+                const versionLine = lines.find(line => line.includes('Terraform v'));
+                return versionLine ? versionLine.trim().replace('Terraform v', '') : 'Unknown';
+            }
+            if (command === 'powershell') {
+                // Check if we're on Windows and PowerShell is available
+                if (process.platform === 'win32') {
+                    const output = (0, child_process_1.execSync)('powershell -Command "$PSVersionTable.PSVersion"', { encoding: 'utf8', timeout: 5000 });
+                    return output.trim();
+                }
+                return null;
+            }
+            // Generic version detection
+            const output = (0, child_process_1.execSync)(`${command} --version`, { encoding: 'utf8', timeout: 5000 });
+            const lines = output.split('\n');
+            const versionLine = lines[0];
+            return versionLine ? versionLine.trim() : 'Unknown';
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    static displayDetectedTools(tools) {
+        const availableTools = tools.filter(tool => tool.available);
+        const unavailableTools = tools.filter(tool => !tool.available);
+        if (availableTools.length === 0) {
+            console.log(chalk_1.default.yellow('⚠ No container/VM/workload management tools detected'));
+            return;
+        }
+        console.log(chalk_1.default.blue.bold('\n🔧 Detected Infrastructure Tools:\n'));
+        // Group tools by category
+        const categories = {
+            container: availableTools.filter(tool => tool.category === 'container'),
+            vm: availableTools.filter(tool => tool.category === 'vm'),
+            orchestration: availableTools.filter(tool => tool.category === 'orchestration'),
+            cloud: availableTools.filter(tool => tool.category === 'cloud'),
+            other: availableTools.filter(tool => tool.category === 'other')
+        };
+        Object.entries(categories).forEach(([category, categoryTools]) => {
+            if (categoryTools.length > 0) {
+                console.log(chalk_1.default.cyan.bold(`📦 ${category.charAt(0).toUpperCase() + category.slice(1)}:`));
+                categoryTools.forEach(tool => {
+                    const versionText = tool.version ? ` (${tool.version})` : '';
+                    console.log(chalk_1.default.green(`  ✓ ${tool.name}${versionText}`));
+                    console.log(chalk_1.default.gray(`    ${tool.description}`));
+                });
+                console.log('');
+            }
+        });
+        if (unavailableTools.length > 0) {
+            console.log(chalk_1.default.gray(`💡 ${unavailableTools.length} additional tools not detected (${unavailableTools.map(t => t.name).join(', ')})`));
+        }
+    }
+    static getToolSummary(tools) {
+        const availableTools = tools.filter(tool => tool.available);
+        const categories = new Set(availableTools.map(tool => tool.category));
+        return `${availableTools.length} tools detected across ${categories.size} categories`;
+    }
+}
+exports.ToolDetector = ToolDetector;
+ToolDetector.tools = [
+    // Container runtimes
+    {
+        name: 'Docker',
+        command: 'docker',
+        category: 'container',
+        description: 'Container runtime and platform',
+        available: false
+    },
+    {
+        name: 'Podman',
+        command: 'podman',
+        category: 'container',
+        description: 'Daemonless container engine',
+        available: false
+    },
+    {
+        name: 'Containerd',
+        command: 'ctr',
+        category: 'container',
+        description: 'Container runtime',
+        available: false
+    },
+    {
+        name: 'LXC',
+        command: 'lxc',
+        category: 'container',
+        description: 'Linux containers',
+        available: false
+    },
+    // VM Management
+    {
+        name: 'VirtualBox',
+        command: 'vboxmanage',
+        category: 'vm',
+        description: 'Virtual machine management',
+        available: false
+    },
+    {
+        name: 'VMware',
+        command: 'vmrun',
+        category: 'vm',
+        description: 'VMware virtualization',
+        available: false
+    },
+    {
+        name: 'QEMU',
+        command: 'qemu-system-x86_64',
+        category: 'vm',
+        description: 'Machine emulator and virtualizer',
+        available: false
+    },
+    {
+        name: 'KVM',
+        command: 'kvm',
+        category: 'vm',
+        description: 'Kernel-based Virtual Machine',
+        available: false
+    },
+    {
+        name: 'Hyper-V',
+        command: 'powershell',
+        category: 'vm',
+        description: 'Windows virtualization platform',
+        available: false
+    },
+    // Orchestration
+    {
+        name: 'Kubernetes',
+        command: 'kubectl',
+        category: 'orchestration',
+        description: 'Container orchestration platform',
+        available: false
+    },
+    {
+        name: 'Docker Compose',
+        command: 'docker-compose',
+        category: 'orchestration',
+        description: 'Multi-container Docker applications',
+        available: false
+    },
+    {
+        name: 'Docker Swarm',
+        command: 'docker',
+        category: 'orchestration',
+        description: 'Docker native clustering',
+        available: false
+    },
+    {
+        name: 'Nomad',
+        command: 'nomad',
+        category: 'orchestration',
+        description: 'Workload orchestrator',
+        available: false
+    },
+    {
+        name: 'Mesos',
+        command: 'mesos-master',
+        category: 'orchestration',
+        description: 'Distributed systems kernel',
+        available: false
+    },
+    // Cloud CLI Tools
+    {
+        name: 'AWS CLI',
+        command: 'aws',
+        category: 'cloud',
+        description: 'Amazon Web Services CLI',
+        available: false
+    },
+    {
+        name: 'Azure CLI',
+        command: 'az',
+        category: 'cloud',
+        description: 'Microsoft Azure CLI',
+        available: false
+    },
+    {
+        name: 'Google Cloud CLI',
+        command: 'gcloud',
+        category: 'cloud',
+        description: 'Google Cloud Platform CLI',
+        available: false
+    },
+    {
+        name: 'DigitalOcean CLI',
+        command: 'doctl',
+        category: 'cloud',
+        description: 'DigitalOcean CLI',
+        available: false
+    },
+    {
+        name: 'Terraform',
+        command: 'terraform',
+        category: 'cloud',
+        description: 'Infrastructure as Code',
+        available: false
+    },
+    {
+        name: 'Ansible',
+        command: 'ansible',
+        category: 'cloud',
+        description: 'Configuration management',
+        available: false
+    },
+    // Other Infrastructure Tools
+    {
+        name: 'Vagrant',
+        command: 'vagrant',
+        category: 'other',
+        description: 'Development environment management',
+        available: false
+    },
+    {
+        name: 'Packer',
+        command: 'packer',
+        category: 'other',
+        description: 'Machine image creation',
+        available: false
+    },
+    {
+        name: 'Helm',
+        command: 'helm',
+        category: 'other',
+        description: 'Kubernetes package manager',
+        available: false
+    },
+    {
+        name: 'Istio',
+        command: 'istioctl',
+        category: 'other',
+        description: 'Service mesh platform',
+        available: false
+    }
+];
+//# sourceMappingURL=ToolDetector.js.map

package/dist/detection/WorkloadDetector.js

@@ -0,0 +1,314 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkloadDetector = void 0;
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+class WorkloadDetector {
+    /**
+     * Detect all running workloads from various sources
+     */
+    static async detectWorkloads() {
+        const workloads = [];
+        try {
+            // Detect Docker workloads
+            const dockerWorkloads = await this.detectDockerWorkloads();
+            workloads.push(...dockerWorkloads);
+            // Detect Kubernetes workloads
+            const k8sWorkloads = await this.detectKubernetesWorkloads();
+            workloads.push(...k8sWorkloads);
+            // Detect VM workloads
+            const vmWorkloads = await this.detectVMWorkloads();
+            workloads.push(...vmWorkloads);
+            // Detect process-based workloads
+            const processWorkloads = await this.detectProcessWorkloads();
+            workloads.push(...processWorkloads);
+        }
+        catch (error) {
+            console.error(chalk_1.default.red('Error detecting workloads:'), error);
+        }
+        return workloads;
+    }
+    /**
+     * Detect Docker containers
+     */
+    static async detectDockerWorkloads() {
+        const workloads = [];
+        try {
+            // Check if Docker is available
+            (0, child_process_1.execSync)('docker --version', { encoding: 'utf8', timeout: 5000 });
+            // Get running containers
+            const output = (0, child_process_1.execSync)('docker ps --format "{{.ID}}|{{.Names}}|{{.Image}}|{{.Status}}|{{.Ports}}"', {
+                encoding: 'utf8',
+                timeout: 10000
+            });
+            const lines = output.trim().split('\n').filter(line => line.trim());
+            for (const line of lines) {
+                const [id, name, image, status, ports] = line.split('|');
+                // Parse port mappings
+                const portMappings = [];
+                if (ports && ports !== '') {
+                    const portStrings = ports.split(',');
+                    for (const portString of portStrings) {
+                        const match = portString.match(/(\d+\.\d+\.\d+\.\d+:)?(\d+)->(\d+)\/(tcp|udp)/);
+                        if (match) {
+                            portMappings.push({
+                                hostIp: match[1] ? match[1].slice(0, -1) : undefined,
+                                hostPort: parseInt(match[2]),
+                                containerPort: parseInt(match[3]),
+                                protocol: match[4]
+                            });
+                        }
+                    }
+                }
+                // Get container IP
+                let containerIp;
+                try {
+                    const inspectOutput = (0, child_process_1.execSync)(`docker inspect ${id} --format "{{.NetworkSettings.IPAddress}}"`, {
+                        encoding: 'utf8',
+                        timeout: 5000
+                    });
+                    containerIp = inspectOutput.trim() || undefined;
+                }
+                catch (error) {
+                    // Ignore errors getting IP
+                }
+                workloads.push({
+                    id: id.substring(0, 12), // Short ID
+                    name: name,
+                    type: 'docker',
+                    status: status.includes('Up') ? 'running' : 'stopped',
+                    image: image,
+                    ports: portMappings,
+                    ipAddress: containerIp,
+                    labels: {},
+                    description: `Docker container running ${image}`
+                });
+            }
+        }
+        catch (error) {
+            // Docker not available or error
+        }
+        return workloads;
+    }
+    /**
+     * Detect Kubernetes workloads
+     */
+    static async detectKubernetesWorkloads() {
+        const workloads = [];
+        try {
+            // Check if kubectl is available
+            (0, child_process_1.execSync)('kubectl version --client', { encoding: 'utf8', timeout: 5000 });
+            // Get pods
+            const output = (0, child_process_1.execSync)('kubectl get pods --all-namespaces -o json', {
+                encoding: 'utf8',
+                timeout: 15000
+            });
+            const data = JSON.parse(output);
+            for (const item of data.items || []) {
+                const pod = item;
+                const status = pod.status?.phase?.toLowerCase() || 'unknown';
+                // Get pod IP
+                const podIp = pod.status?.podIP;
+                // Parse container ports
+                const portMappings = [];
+                if (pod.spec?.containers) {
+                    for (const container of pod.spec.containers) {
+                        if (container.ports) {
+                            for (const port of container.ports) {
+                                portMappings.push({
+                                    containerPort: port.containerPort,
+                                    protocol: (port.protocol || 'tcp').toLowerCase(),
+                                    hostPort: port.hostPort
+                                });
+                            }
+                        }
+                    }
+                }
+                workloads.push({
+                    id: pod.metadata.uid.substring(0, 12),
+                    name: pod.metadata.name,
+                    type: 'kubernetes',
+                    status: status === 'running' ? 'running' : 'stopped',
+                    image: pod.spec?.containers?.[0]?.image,
+                    ports: portMappings,
+                    ipAddress: podIp,
+                    namespace: pod.metadata.namespace,
+                    labels: pod.metadata.labels || {},
+                    createdAt: pod.metadata.creationTimestamp,
+                    description: `Kubernetes pod in namespace ${pod.metadata.namespace}`
+                });
+            }
+        }
+        catch (error) {
+            // kubectl not available or error
+        }
+        return workloads;
+    }
+    /**
+     * Detect VM workloads
+     */
+    static async detectVMWorkloads() {
+        const workloads = [];
+        try {
+            // Check for VirtualBox VMs
+            try {
+                const output = (0, child_process_1.execSync)('vboxmanage list runningvms', { encoding: 'utf8', timeout: 10000 });
+                const lines = output.trim().split('\n').filter(line => line.trim());
+                for (const line of lines) {
+                    const match = line.match(/^"([^"]+)"\s+\(([^)]+)\)$/);
+                    if (match) {
+                        const [, name, uuid] = match;
+                        workloads.push({
+                            id: uuid.substring(0, 12),
+                            name: name,
+                            type: 'vm',
+                            status: 'running',
+                            description: 'VirtualBox virtual machine'
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                // VirtualBox not available
+            }
+            // Check for VMware VMs
+            try {
+                const output = (0, child_process_1.execSync)('vmrun list', { encoding: 'utf8', timeout: 10000 });
+                const lines = output.trim().split('\n').filter(line => line.trim() && !line.includes('Total running VMs'));
+                for (const line of lines) {
+                    const vmPath = line.trim();
+                    const vmName = vmPath.split('/').pop()?.replace('.vmx', '') || 'Unknown';
+                    workloads.push({
+                        id: vmPath.substring(0, 12),
+                        name: vmName,
+                        type: 'vm',
+                        status: 'running',
+                        description: 'VMware virtual machine'
+                    });
+                }
+            }
+            catch (error) {
+                // VMware not available
+            }
+        }
+        catch (error) {
+            // VM tools not available
+        }
+        return workloads;
+    }
+    /**
+     * Detect process-based workloads (web servers, databases, etc.)
+     */
+    static async detectProcessWorkloads() {
+        const workloads = [];
+        try {
+            // Common web server and database processes
+            const commonProcesses = [
+                { name: 'nginx', port: 80, description: 'Nginx web server' },
+                { name: 'apache2', port: 80, description: 'Apache web server' },
+                { name: 'httpd', port: 80, description: 'Apache HTTP server' },
+                { name: 'node', port: 3000, description: 'Node.js application' },
+                { name: 'python', port: 8000, description: 'Python web application' },
+                { name: 'mysqld', port: 3306, description: 'MySQL database' },
+                { name: 'postgres', port: 5432, description: 'PostgreSQL database' },
+                { name: 'redis-server', port: 6379, description: 'Redis server' },
+                { name: 'mongod', port: 27017, description: 'MongoDB database' }
+            ];
+            for (const process of commonProcesses) {
+                try {
+                    const output = (0, child_process_1.execSync)(`pgrep -f ${process.name}`, { encoding: 'utf8', timeout: 5000 });
+                    if (output.trim()) {
+                        const pid = output.trim().split('\n')[0];
+                        // Try to get the port the process is listening on
+                        let port;
+                        try {
+                            const netstatOutput = (0, child_process_1.execSync)(`netstat -tlnp 2>/dev/null | grep ${pid}`, { encoding: 'utf8', timeout: 5000 });
+                            const portMatch = netstatOutput.match(/:(\d+)/);
+                            if (portMatch) {
+                                port = parseInt(portMatch[1]);
+                            }
+                        }
+                        catch (error) {
+                            // Use default port
+                            port = process.port;
+                        }
+                        workloads.push({
+                            id: pid,
+                            name: `${process.name}-${pid}`,
+                            type: 'process',
+                            status: 'running',
+                            ports: port ? [{ containerPort: port, protocol: 'tcp' }] : undefined,
+                            description: process.description
+                        });
+                    }
+                }
+                catch (error) {
+                    // Process not running
+                }
+            }
+        }
+        catch (error) {
+            // Error detecting processes
+        }
+        return workloads;
+    }
+    /**
+     * Display detected workloads
+     */
+    static displayWorkloads(workloads) {
+        if (workloads.length === 0) {
+            console.log(chalk_1.default.yellow('⚠ No running workloads detected'));
+            return;
+        }
+        console.log(chalk_1.default.blue.bold('\n🚀 Detected Running Workloads:\n'));
+        // Group workloads by type
+        const types = {
+            docker: workloads.filter(w => w.type === 'docker'),
+            kubernetes: workloads.filter(w => w.type === 'kubernetes'),
+            vm: workloads.filter(w => w.type === 'vm'),
+            process: workloads.filter(w => w.type === 'process')
+        };
+        Object.entries(types).forEach(([type, typeWorkloads]) => {
+            if (typeWorkloads.length > 0) {
+                console.log(chalk_1.default.cyan.bold(`📦 ${type.charAt(0).toUpperCase() + type.slice(1)}:`));
+                typeWorkloads.forEach(workload => {
+                    const statusColor = workload.status === 'running' ? chalk_1.default.green : chalk_1.default.red;
+                    const statusIcon = workload.status === 'running' ? '●' : '○';
+                    console.log(chalk_1.default.white(`  ${statusIcon} ${workload.name}`));
+                    console.log(chalk_1.default.gray(`    ID: ${workload.id}`));
+                    console.log(chalk_1.default.gray(`    Status: ${statusColor(workload.status)}`));
+                    if (workload.image) {
+                        console.log(chalk_1.default.gray(`    Image: ${workload.image}`));
+                    }
+                    if (workload.ipAddress) {
+                        console.log(chalk_1.default.gray(`    IP: ${workload.ipAddress}`));
+                    }
+                    if (workload.ports && workload.ports.length > 0) {
+                        const portInfo = workload.ports.map(p => p.hostPort ? `${p.hostPort}:${p.containerPort}` : `${p.containerPort}`).join(', ');
+                        console.log(chalk_1.default.gray(`    Ports: ${portInfo}`));
+                    }
+                    if (workload.namespace) {
+                        console.log(chalk_1.default.gray(`    Namespace: ${workload.namespace}`));
+                    }
+                    if (workload.description) {
+                        console.log(chalk_1.default.gray(`    ${workload.description}`));
+                    }
+                    console.log('');
+                });
+            }
+        });
+    }
+    /**
+     * Get workload summary
+     */
+    static getWorkloadSummary(workloads) {
+        const runningWorkloads = workloads.filter(w => w.status === 'running');
+        const types = new Set(workloads.map(w => w.type));
+        return `${runningWorkloads.length} running workloads across ${types.size} types`;
+    }
+}
+exports.WorkloadDetector = WorkloadDetector;
+//# sourceMappingURL=WorkloadDetector.js.map