@cicore/cli 1.0.0

package/dist/commands/check/index.js

@@ -0,0 +1,1316 @@
+/**
+ * CiCore CLI - Health Check & Diagnostics
+ *
+ * Comprehensive system checks for ciCore deployments
+ */
+import { log, spinner, formatTable } from '../../lib/logger.js';
+import { exec } from '../../lib/shell.js';
+import { paths, getDockerRegistry } from '../../lib/config.js';
+import { getSSHHost, buildSSHCommand, listSSHHosts } from '../../lib/ssh-config.js';
+import fs from 'fs-extra';
+import path from 'path';
+export function registerCheckCommands(program) {
+    const check = program
+        .command('check')
+        .description('Health checks and diagnostics');
+    // vu check:all
+    check
+        .command('all')
+        .description('Run all checks')
+        .option('-h, --host <host>', 'SSH host for server checks', 'cicore')
+        .option('--local', 'Only run local checks')
+        .option('--server', 'Only run server checks')
+        .action(async (options) => {
+        await runAllChecks(options);
+    });
+    // vu check:local
+    check
+        .command('local')
+        .description('Check local development environment')
+        .action(async () => {
+        await checkLocal();
+    });
+    // vu check:server
+    check
+        .command('server')
+        .description('Check server health')
+        .option('-h, --host <host>', 'SSH host name', 'cicore')
+        .action(async (options) => {
+        await checkServer(options);
+    });
+    // vu check:docker
+    check
+        .command('docker')
+        .description('Check Docker images and containers')
+        .option('-h, --host <host>', 'SSH host (or "local")', 'local')
+        .action(async (options) => {
+        await checkDocker(options);
+    });
+    // vu check:files
+    check
+        .command('files')
+        .description('Check ciCore file structure')
+        .option('-h, --host <host>', 'SSH host for server check', 'cicore')
+        .option('-c, --core <core>', 'Core name to check', 'core1')
+        .action(async (options) => {
+        await checkFiles(options);
+    });
+    // vu check:addons
+    check
+        .command('addons')
+        .description('Validate addon configurations')
+        .option('-h, --host <host>', 'SSH host (or "local")', 'local')
+        .option('-c, --core <core>', 'Core name', 'core1')
+        .action(async (options) => {
+        await checkAddons(options);
+    });
+    // vu check:ssl
+    check
+        .command('ssl')
+        .description('Check SSL certificates')
+        .option('-h, --host <host>', 'SSH host name', 'cicore')
+        .option('-d, --domain <domain>', 'Domain to check')
+        .action(async (options) => {
+        await checkSSL(options);
+    });
+    // vu check:connectivity
+    check
+        .command('connectivity')
+        .description('Check network connectivity')
+        .option('-h, --host <host>', 'SSH host name', 'cicore')
+        .action(async (options) => {
+        await checkConnectivity(options);
+    });
+    // vu check:requirements
+    check
+        .command('requirements')
+        .alias('req')
+        .description('Check server requirements for ciCore installation')
+        .option('-h, --host <host>', 'SSH host name', 'cicore')
+        .action(async (options) => {
+        await checkRequirements(options);
+    });
+    // vu check:tree
+    check
+        .command('tree')
+        .description('Show server directory structure')
+        .option('-h, --host <host>', 'SSH host name', 'cicore')
+        .option('-c, --core <core>', 'Core name to show')
+        .option('-d, --depth <depth>', 'Tree depth', '3')
+        .action(async (options) => {
+        await showTree(options);
+    });
+    // vu check:api
+    check
+        .command('api')
+        .description('Check API endpoints')
+        .option('-h, --host <host>', 'SSH host name', 'cicore')
+        .option('-d, --domain <domain>', 'Domain to check')
+        .action(async (options) => {
+        await checkAPI(options);
+    });
+    // vu check:services
+    check
+        .command('services')
+        .description('Check all ciCore services status')
+        .option('-h, --host <host>', 'SSH host name', 'cicore')
+        .action(async (options) => {
+        await checkServices(options);
+    });
+    // vu check:ports
+    check
+        .command('ports')
+        .description('Check required ports')
+        .option('-h, --host <host>', 'SSH host name', 'cicore')
+        .action(async (options) => {
+        await checkPorts(options);
+    });
+    // vu check:install
+    check
+        .command('install')
+        .alias('pre')
+        .description('Pre-installation check (all requirements)')
+        .option('-h, --host <host>', 'SSH host name', 'cicore')
+        .action(async (options) => {
+        await preInstallCheck(options);
+    });
+}
+// ============================================
+// RUN ALL CHECKS
+// ============================================
+async function runAllChecks(options) {
+    log.title('🔍 ciCore System Diagnostics');
+    log.blank();
+    const results = [];
+    if (!options.server) {
+        log.info('=== Local Environment ===');
+        const localResults = await runLocalChecks();
+        results.push(...localResults);
+        log.blank();
+    }
+    if (!options.local) {
+        log.info('=== Server Environment ===');
+        const serverResults = await runServerChecks(options.host);
+        results.push(...serverResults);
+        log.blank();
+    }
+    // Summary
+    printCheckSummary(results);
+}
+// ============================================
+// LOCAL CHECKS
+// ============================================
+async function checkLocal() {
+    log.title('🖥️ Local Environment Check');
+    log.blank();
+    const results = await runLocalChecks();
+    printCheckSummary(results);
+}
+async function runLocalChecks() {
+    const results = [];
+    // Check Node.js
+    const nodeSpinner = spinner('Checking Node.js...').start();
+    const nodeResult = await exec('node', ['--version'], { silent: true });
+    if (nodeResult.success) {
+        const version = nodeResult.stdout.trim();
+        const major = parseInt(version.replace('v', '').split('.')[0]);
+        if (major >= 18) {
+            nodeSpinner.succeed(`Node.js: ${version}`);
+            results.push({ name: 'Node.js', status: 'pass', message: version });
+        }
+        else {
+            nodeSpinner.warn(`Node.js: ${version} (recommend v18+)`);
+            results.push({ name: 'Node.js', status: 'warn', message: `${version} - recommend v18+` });
+        }
+    }
+    else {
+        nodeSpinner.fail('Node.js not found');
+        results.push({ name: 'Node.js', status: 'fail', message: 'Not installed' });
+    }
+    // Check npm
+    const npmSpinner = spinner('Checking npm...').start();
+    const npmResult = await exec('npm', ['--version'], { silent: true });
+    if (npmResult.success) {
+        npmSpinner.succeed(`npm: v${npmResult.stdout.trim()}`);
+        results.push({ name: 'npm', status: 'pass', message: `v${npmResult.stdout.trim()}` });
+    }
+    else {
+        npmSpinner.fail('npm not found');
+        results.push({ name: 'npm', status: 'fail', message: 'Not installed' });
+    }
+    // Check Docker
+    const dockerSpinner = spinner('Checking Docker...').start();
+    const dockerResult = await exec('docker', ['--version'], { silent: true });
+    if (dockerResult.success) {
+        dockerSpinner.succeed(`Docker: ${dockerResult.stdout.trim().split(' ')[2]?.replace(',', '')}`);
+        results.push({ name: 'Docker', status: 'pass', message: 'Installed' });
+        // Check if Docker is running
+        const dockerPsResult = await exec('docker', ['ps'], { silent: true });
+        if (!dockerPsResult.success) {
+            results.push({ name: 'Docker Daemon', status: 'warn', message: 'Not running' });
+        }
+    }
+    else {
+        dockerSpinner.fail('Docker not found');
+        results.push({ name: 'Docker', status: 'fail', message: 'Not installed' });
+    }
+    // Check Git
+    const gitSpinner = spinner('Checking Git...').start();
+    const gitResult = await exec('git', ['--version'], { silent: true });
+    if (gitResult.success) {
+        gitSpinner.succeed(`Git: ${gitResult.stdout.trim().split(' ')[2]}`);
+        results.push({ name: 'Git', status: 'pass', message: 'Installed' });
+    }
+    else {
+        gitSpinner.fail('Git not found');
+        results.push({ name: 'Git', status: 'fail', message: 'Not installed' });
+    }
+    // Check SSH config
+    const sshSpinner = spinner('Checking SSH config...').start();
+    const hosts = await listSSHHosts();
+    const vucoreHost = hosts.find(h => h.name === 'cicore');
+    if (vucoreHost) {
+        sshSpinner.succeed(`SSH: vucore host configured (${vucoreHost.hostname})`);
+        results.push({ name: 'SSH Config', status: 'pass', message: `vucore → ${vucoreHost.hostname}` });
+    }
+    else if (hosts.length > 0) {
+        sshSpinner.warn(`SSH: ${hosts.length} hosts found, but no 'cicore' host`);
+        results.push({ name: 'SSH Config', status: 'warn', message: 'No vucore host' });
+    }
+    else {
+        sshSpinner.fail('SSH: No hosts configured');
+        results.push({ name: 'SSH Config', status: 'fail', message: 'No hosts in ~/.ssh/config' });
+    }
+    // Check ciCore project structure
+    const projectSpinner = spinner('Checking project structure...').start();
+    const requiredFiles = [
+        'package.json',
+        'nuxt.config.ts',
+        'docker-compose.dev.yml',
+        'Dockerfile.nuxt.production',
+        'Dockerfile.php.production',
+        'addons',
+    ];
+    const missingFiles = [];
+    for (const file of requiredFiles) {
+        if (!await fs.pathExists(path.join(paths.dev.root, file))) {
+            missingFiles.push(file);
+        }
+    }
+    if (missingFiles.length === 0) {
+        projectSpinner.succeed('Project structure: OK');
+        results.push({ name: 'Project Structure', status: 'pass', message: 'All files present' });
+    }
+    else {
+        projectSpinner.warn(`Project structure: Missing ${missingFiles.length} files`);
+        results.push({
+            name: 'Project Structure',
+            status: 'warn',
+            message: `Missing: ${missingFiles.join(', ')}`
+        });
+    }
+    // Check local containers
+    const containerSpinner = spinner('Checking local containers...').start();
+    const psResult = await exec('docker', ['ps', '--filter', 'name=vucore_dev', '--format', '{{.Names}}'], { silent: true });
+    if (psResult.success && psResult.stdout.trim()) {
+        const containers = psResult.stdout.trim().split('\n').length;
+        containerSpinner.succeed(`Local containers: ${containers} running`);
+        results.push({ name: 'Local Containers', status: 'pass', message: `${containers} running` });
+    }
+    else {
+        containerSpinner.warn('Local containers: None running');
+        results.push({ name: 'Local Containers', status: 'warn', message: 'None running' });
+    }
+    return results;
+}
+// ============================================
+// SERVER CHECKS
+// ============================================
+async function checkServer(options) {
+    log.title('🌐 Server Health Check');
+    log.blank();
+    const results = await runServerChecks(options.host);
+    printCheckSummary(results);
+}
+async function runServerChecks(hostName) {
+    const results = [];
+    const host = await getSSHHost(hostName);
+    if (!host) {
+        results.push({ name: 'SSH Connection', status: 'fail', message: `Host "${hostName}" not found` });
+        return results;
+    }
+    // Test SSH connection
+    const sshSpinner = spinner(`Connecting to ${host.hostname}...`).start();
+    const sshResult = await runSSH(host, 'echo "OK"');
+    if (!sshResult.success) {
+        sshSpinner.fail('SSH connection failed');
+        results.push({ name: 'SSH Connection', status: 'fail', message: 'Connection failed' });
+        return results;
+    }
+    sshSpinner.succeed(`Connected to ${host.hostname}`);
+    results.push({ name: 'SSH Connection', status: 'pass', message: host.hostname });
+    // Check Docker
+    const dockerSpinner = spinner('Checking Docker...').start();
+    const dockerResult = await runSSH(host, 'docker --version');
+    if (dockerResult.success) {
+        dockerSpinner.succeed('Docker: Installed');
+        results.push({ name: 'Docker', status: 'pass', message: 'Installed' });
+    }
+    else {
+        dockerSpinner.fail('Docker: Not installed');
+        results.push({ name: 'Docker', status: 'fail', message: 'Not installed' });
+    }
+    // Check containers
+    const containerSpinner = spinner('Checking containers...').start();
+    const psResult = await runSSH(host, 'docker ps --format "{{.Names}}:{{.Status}}" | grep vucore');
+    if (psResult.success && psResult.stdout.trim()) {
+        const containers = psResult.stdout.trim().split('\n');
+        const running = containers.filter(c => c.includes('Up')).length;
+        const total = containers.length;
+        if (running === total) {
+            containerSpinner.succeed(`Containers: ${running}/${total} running`);
+            results.push({ name: 'Containers', status: 'pass', message: `${running}/${total} running` });
+        }
+        else {
+            containerSpinner.warn(`Containers: ${running}/${total} running`);
+            results.push({ name: 'Containers', status: 'warn', message: `${running}/${total} running` });
+        }
+    }
+    else {
+        containerSpinner.fail('Containers: None found');
+        results.push({ name: 'Containers', status: 'fail', message: 'No ciCore containers' });
+    }
+    // Check disk space
+    const diskSpinner = spinner('Checking disk space...').start();
+    const diskResult = await runSSH(host, "df -h / | tail -1 | awk '{print $5}'");
+    if (diskResult.success) {
+        const usage = parseInt(diskResult.stdout.trim().replace('%', ''));
+        if (usage < 80) {
+            diskSpinner.succeed(`Disk: ${usage}% used`);
+            results.push({ name: 'Disk Space', status: 'pass', message: `${usage}% used` });
+        }
+        else if (usage < 90) {
+            diskSpinner.warn(`Disk: ${usage}% used`);
+            results.push({ name: 'Disk Space', status: 'warn', message: `${usage}% used - consider cleanup` });
+        }
+        else {
+            diskSpinner.fail(`Disk: ${usage}% used`);
+            results.push({ name: 'Disk Space', status: 'fail', message: `${usage}% used - CRITICAL` });
+        }
+    }
+    // Check memory
+    const memSpinner = spinner('Checking memory...').start();
+    const memResult = await runSSH(host, "free | grep Mem | awk '{printf \"%.0f\", $3/$2 * 100}'");
+    if (memResult.success) {
+        const usage = parseInt(memResult.stdout.trim());
+        if (usage < 80) {
+            memSpinner.succeed(`Memory: ${usage}% used`);
+            results.push({ name: 'Memory', status: 'pass', message: `${usage}% used` });
+        }
+        else if (usage < 90) {
+            memSpinner.warn(`Memory: ${usage}% used`);
+            results.push({ name: 'Memory', status: 'warn', message: `${usage}% used` });
+        }
+        else {
+            memSpinner.fail(`Memory: ${usage}% used`);
+            results.push({ name: 'Memory', status: 'fail', message: `${usage}% used - CRITICAL` });
+        }
+    }
+    // Check Nginx
+    const nginxSpinner = spinner('Checking Nginx...').start();
+    const nginxResult = await runSSH(host, 'systemctl is-active nginx');
+    if (nginxResult.success && nginxResult.stdout.trim() === 'active') {
+        nginxSpinner.succeed('Nginx: Active');
+        results.push({ name: 'Nginx', status: 'pass', message: 'Active' });
+    }
+    else {
+        nginxSpinner.fail('Nginx: Not active');
+        results.push({ name: 'Nginx', status: 'fail', message: 'Not active' });
+    }
+    // Check API health
+    const apiSpinner = spinner('Checking API health...').start();
+    const apiResult = await runSSH(host, 'curl -s -o /dev/null -w "%{http_code}" http://localhost:3000/api/health 2>/dev/null || echo "000"');
+    const statusCode = apiResult.stdout.trim();
+    if (statusCode === '200') {
+        apiSpinner.succeed('API: Healthy');
+        results.push({ name: 'API Health', status: 'pass', message: 'HTTP 200' });
+    }
+    else if (statusCode === '000') {
+        apiSpinner.fail('API: Not responding');
+        results.push({ name: 'API Health', status: 'fail', message: 'Not responding' });
+    }
+    else {
+        apiSpinner.warn(`API: HTTP ${statusCode}`);
+        results.push({ name: 'API Health', status: 'warn', message: `HTTP ${statusCode}` });
+    }
+    return results;
+}
+// ============================================
+// DOCKER CHECKS
+// ============================================
+async function checkDocker(options) {
+    log.title('🐳 Docker Check');
+    log.blank();
+    const results = [];
+    const registry = getDockerRegistry();
+    if (options.host === 'local') {
+        // Local Docker check
+        const imagesSpinner = spinner('Checking local images...').start();
+        const imagesResult = await exec('docker', ['images', '--format', '{{.Repository}}:{{.Tag}}\t{{.Size}}', '--filter', `reference=${registry}/vucore-*`], { silent: true });
+        if (imagesResult.success && imagesResult.stdout.trim()) {
+            const images = imagesResult.stdout.trim().split('\n');
+            imagesSpinner.succeed(`Found ${images.length} ciCore images`);
+            log.blank();
+            images.forEach(img => {
+                const [name, size] = img.split('\t');
+                log.item(`${name} (${size})`);
+            });
+            results.push({ name: 'Local Images', status: 'pass', message: `${images.length} images` });
+        }
+        else {
+            imagesSpinner.warn('No ciCore images found');
+            results.push({ name: 'Local Images', status: 'warn', message: 'None found' });
+        }
+    }
+    else {
+        // Remote Docker check
+        const host = await getSSHHost(options.host);
+        if (!host) {
+            log.error(`SSH host "${options.host}" not found`);
+            return;
+        }
+        const imagesSpinner = spinner('Checking server images...').start();
+        const imagesResult = await runSSH(host, `docker images --format "{{.Repository}}:{{.Tag}}\t{{.Size}}" | grep vucore`);
+        if (imagesResult.success && imagesResult.stdout.trim()) {
+            const images = imagesResult.stdout.trim().split('\n');
+            imagesSpinner.succeed(`Found ${images.length} ciCore images`);
+            log.blank();
+            images.forEach(img => {
+                const [name, size] = img.split('\t');
+                log.item(`${name} (${size})`);
+            });
+            results.push({ name: 'Server Images', status: 'pass', message: `${images.length} images` });
+        }
+        else {
+            imagesSpinner.warn('No ciCore images found');
+            results.push({ name: 'Server Images', status: 'warn', message: 'None found' });
+        }
+    }
+    log.blank();
+    printCheckSummary(results);
+}
+// ============================================
+// FILE STRUCTURE CHECKS
+// ============================================
+async function checkFiles(options) {
+    log.title('📁 File Structure Check');
+    log.blank();
+    const results = [];
+    const host = await getSSHHost(options.host);
+    if (!host) {
+        log.error(`SSH host "${options.host}" not found`);
+        return;
+    }
+    const coreName = options.core;
+    const requiredDirs = [
+        `/home/cores/${coreName}`,
+        `/home/cores/${coreName}/addons`,
+        `/home/cores/${coreName}/storage`,
+        '/home/services',
+        '/home/scripts',
+        '/home/nginx/conf.d',
+    ];
+    const requiredFiles = [
+        `/home/cores/${coreName}/.env`,
+        '/home/services/docker-core-nuxt.yml',
+        '/home/services/docker-core-php.yml',
+        '/home/scripts/cleanup-and-rebuild-nuxt.sh',
+        '/home/scripts/cleanup-and-rebuild-php.sh',
+    ];
+    // Check directories
+    for (const dir of requiredDirs) {
+        const checkSpinner = spinner(`Checking ${dir}...`).start();
+        const result = await runSSH(host, `test -d "${dir}" && echo "OK" || echo "MISSING"`);
+        if (result.stdout.trim() === 'OK') {
+            checkSpinner.succeed(`${dir}: OK`);
+            results.push({ name: dir, status: 'pass', message: 'Exists' });
+        }
+        else {
+            checkSpinner.fail(`${dir}: MISSING`);
+            results.push({ name: dir, status: 'fail', message: 'Missing' });
+        }
+    }
+    // Check files
+    for (const file of requiredFiles) {
+        const checkSpinner = spinner(`Checking ${file}...`).start();
+        const result = await runSSH(host, `test -f "${file}" && echo "OK" || echo "MISSING"`);
+        if (result.stdout.trim() === 'OK') {
+            checkSpinner.succeed(`${file}: OK`);
+            results.push({ name: file, status: 'pass', message: 'Exists' });
+        }
+        else {
+            checkSpinner.fail(`${file}: MISSING`);
+            results.push({ name: file, status: 'fail', message: 'Missing' });
+        }
+    }
+    log.blank();
+    printCheckSummary(results);
+}
+// ============================================
+// ADDON CHECKS
+// ============================================
+async function checkAddons(options) {
+    log.title('🧩 Addon Validation');
+    log.blank();
+    const results = [];
+    if (options.host === 'local') {
+        // Local addon check
+        const addonsPath = paths.dev.addons;
+        if (!await fs.pathExists(addonsPath)) {
+            log.error('Addons directory not found');
+            return;
+        }
+        const entries = await fs.readdir(addonsPath, { withFileTypes: true });
+        const addons = entries.filter(e => e.isDirectory() && !e.name.startsWith('.'));
+        for (const addon of addons) {
+            const addonPath = path.join(addonsPath, addon.name);
+            const addonSpinner = spinner(`Checking ${addon.name}...`).start();
+            const issues = [];
+            // Check addon.json
+            const addonJsonPath = path.join(addonPath, 'addon.json');
+            if (!await fs.pathExists(addonJsonPath)) {
+                issues.push('Missing addon.json');
+            }
+            else {
+                try {
+                    const config = await fs.readJson(addonJsonPath);
+                    if (!config.name)
+                        issues.push('addon.json: missing name');
+                    if (!config.version)
+                        issues.push('addon.json: missing version');
+                }
+                catch {
+                    issues.push('addon.json: invalid JSON');
+                }
+            }
+            // Check Backend
+            if (!await fs.pathExists(path.join(addonPath, 'Backend'))) {
+                issues.push('Missing Backend/');
+            }
+            // Check entry point
+            const hasEntry = await fs.pathExists(path.join(addonPath, 'ui', 'entry.js')) ||
+                await fs.pathExists(path.join(addonPath, 'ui', 'entry.ts'));
+            if (!hasEntry) {
+                issues.push('Missing ui/entry.js or entry.ts');
+            }
+            if (issues.length === 0) {
+                addonSpinner.succeed(`${addon.name}: Valid`);
+                results.push({ name: addon.name, status: 'pass', message: 'Valid' });
+            }
+            else {
+                addonSpinner.warn(`${addon.name}: ${issues.length} issue(s)`);
+                results.push({ name: addon.name, status: 'warn', message: issues.join(', ') });
+            }
+        }
+    }
+    else {
+        // Server addon check
+        const host = await getSSHHost(options.host);
+        if (!host) {
+            log.error(`SSH host "${options.host}" not found`);
+            return;
+        }
+        const addonsResult = await runSSH(host, `ls -1 /home/cores/${options.core}/addons/ 2>/dev/null`);
+        if (!addonsResult.success || !addonsResult.stdout.trim()) {
+            log.info('No addons found on server');
+            return;
+        }
+        const addons = addonsResult.stdout.trim().split('\n');
+        for (const addon of addons) {
+            const addonSpinner = spinner(`Checking ${addon}...`).start();
+            const addonPath = `/home/cores/${options.core}/addons/${addon}`;
+            const issues = [];
+            // Check addon.json
+            const jsonResult = await runSSH(host, `test -f "${addonPath}/addon.json" && echo "OK"`);
+            if (jsonResult.stdout.trim() !== 'OK') {
+                issues.push('Missing addon.json');
+            }
+            // Check ui-manifest.json
+            const manifestResult = await runSSH(host, `test -f "${addonPath}/ui-manifest.json" && echo "OK"`);
+            if (manifestResult.stdout.trim() !== 'OK') {
+                issues.push('Missing ui-manifest.json');
+            }
+            // Check Backend
+            const backendResult = await runSSH(host, `test -d "${addonPath}/Backend" && echo "OK"`);
+            if (backendResult.stdout.trim() !== 'OK') {
+                issues.push('Missing Backend/');
+            }
+            if (issues.length === 0) {
+                addonSpinner.succeed(`${addon}: Valid`);
+                results.push({ name: addon, status: 'pass', message: 'Valid' });
+            }
+            else {
+                addonSpinner.warn(`${addon}: ${issues.length} issue(s)`);
+                results.push({ name: addon, status: 'warn', message: issues.join(', ') });
+            }
+        }
+    }
+    log.blank();
+    printCheckSummary(results);
+}
+// ============================================
+// SSL CHECKS
+// ============================================
+async function checkSSL(options) {
+    log.title('🔒 SSL Certificate Check');
+    log.blank();
+    const host = await getSSHHost(options.host);
+    if (!host) {
+        log.error(`SSH host "${options.host}" not found`);
+        return;
+    }
+    const results = [];
+    // List certificates
+    const certSpinner = spinner('Checking certificates...').start();
+    const certResult = await runSSH(host, 'certbot certificates 2>/dev/null | grep -E "(Certificate Name|Expiry Date|Domains)"');
+    if (certResult.success && certResult.stdout.trim()) {
+        certSpinner.succeed('Certificates found');
+        log.blank();
+        console.log(certResult.stdout);
+        results.push({ name: 'SSL Certificates', status: 'pass', message: 'Found' });
+    }
+    else {
+        certSpinner.warn('No certificates found');
+        results.push({ name: 'SSL Certificates', status: 'warn', message: 'None found' });
+    }
+    // Check specific domain if provided
+    if (options.domain) {
+        const domainSpinner = spinner(`Checking ${options.domain}...`).start();
+        const domainResult = await runSSH(host, `openssl s_client -connect ${options.domain}:443 -servername ${options.domain} </dev/null 2>/dev/null | openssl x509 -noout -dates 2>/dev/null`);
+        if (domainResult.success && domainResult.stdout.trim()) {
+            domainSpinner.succeed(`${options.domain}: Valid`);
+            log.blank();
+            console.log(domainResult.stdout);
+            results.push({ name: options.domain, status: 'pass', message: 'Valid' });
+        }
+        else {
+            domainSpinner.fail(`${options.domain}: Invalid or not found`);
+            results.push({ name: options.domain, status: 'fail', message: 'Invalid' });
+        }
+    }
+    log.blank();
+    printCheckSummary(results);
+}
+// ============================================
+// CONNECTIVITY CHECKS
+// ============================================
+async function checkConnectivity(options) {
+    log.title('🌐 Connectivity Check');
+    log.blank();
+    const host = await getSSHHost(options.host);
+    if (!host) {
+        log.error(`SSH host "${options.host}" not found`);
+        return;
+    }
+    const results = [];
+    // Check internet
+    const internetSpinner = spinner('Checking internet...').start();
+    const internetResult = await runSSH(host, 'curl -s -o /dev/null -w "%{http_code}" https://google.com');
+    if (internetResult.stdout.trim() === '200' || internetResult.stdout.trim() === '301') {
+        internetSpinner.succeed('Internet: Connected');
+        results.push({ name: 'Internet', status: 'pass', message: 'Connected' });
+    }
+    else {
+        internetSpinner.fail('Internet: Not connected');
+        results.push({ name: 'Internet', status: 'fail', message: 'Not connected' });
+    }
+    // Check Docker Hub
+    const dockerHubSpinner = spinner('Checking Docker Hub...').start();
+    const dockerHubResult = await runSSH(host, 'curl -s -o /dev/null -w "%{http_code}" https://hub.docker.com');
+    if (dockerHubResult.stdout.trim() === '200') {
+        dockerHubSpinner.succeed('Docker Hub: Accessible');
+        results.push({ name: 'Docker Hub', status: 'pass', message: 'Accessible' });
+    }
+    else {
+        dockerHubSpinner.fail('Docker Hub: Not accessible');
+        results.push({ name: 'Docker Hub', status: 'fail', message: 'Not accessible' });
+    }
+    // Check CDN
+    const cdnSpinner = spinner('Checking CDN...').start();
+    const cdnResult = await runSSH(host, 'curl -s -o /dev/null -w "%{http_code}" https://cdn.cicore.com.tr');
+    if (cdnResult.stdout.trim() === '200') {
+        cdnSpinner.succeed('CDN: Accessible');
+        results.push({ name: 'CDN', status: 'pass', message: 'Accessible' });
+    }
+    else {
+        cdnSpinner.warn('CDN: Not accessible');
+        results.push({ name: 'CDN', status: 'warn', message: 'Not accessible' });
+    }
+    log.blank();
+    printCheckSummary(results);
+}
+// ============================================
+// HELPER FUNCTIONS
+// ============================================
+async function runSSH(host, command) {
+    const args = buildSSHCommand(host, command);
+    return await exec('ssh', args, { silent: true });
+}
+function printCheckSummary(results) {
+    const passed = results.filter(r => r.status === 'pass').length;
+    const warned = results.filter(r => r.status === 'warn').length;
+    const failed = results.filter(r => r.status === 'fail').length;
+    log.blank();
+    log.info('=== Summary ===');
+    if (failed > 0) {
+        log.error(`❌ ${failed} failed`);
+    }
+    if (warned > 0) {
+        log.warn(`⚠️  ${warned} warnings`);
+    }
+    if (passed > 0) {
+        log.success(`✅ ${passed} passed`);
+    }
+    log.blank();
+    if (failed > 0) {
+        log.info('Failed checks:');
+        results.filter(r => r.status === 'fail').forEach(r => {
+            log.item(`${r.name}: ${r.message}`);
+        });
+    }
+    if (warned > 0) {
+        log.info('Warnings:');
+        results.filter(r => r.status === 'warn').forEach(r => {
+            log.item(`${r.name}: ${r.message}`);
+        });
+    }
+}
+// ============================================
+// SERVER REQUIREMENTS CHECK
+// ============================================
+async function checkRequirements(options) {
+    log.title('📋 Server Requirements Check');
+    log.blank();
+    const host = await getSSHHost(options.host);
+    if (!host) {
+        log.error(`SSH host "${options.host}" not found`);
+        return;
+    }
+    log.kv('Server', `${host.name} (${host.hostname})`);
+    log.blank();
+    const results = [];
+    // Required programs with minimum versions
+    const programs = [
+        { name: 'docker', cmd: 'docker --version', minVersion: '20.0.0', required: true },
+        { name: 'docker-compose', cmd: 'docker compose version 2>/dev/null || docker-compose --version', minVersion: '2.0.0', required: true },
+        { name: 'curl', cmd: 'curl --version | head -1', minVersion: null, required: true },
+        { name: 'tree', cmd: 'tree --version 2>/dev/null || echo "not installed"', minVersion: null, required: false },
+        { name: 'git', cmd: 'git --version', minVersion: null, required: false },
+        { name: 'openssl', cmd: 'openssl version', minVersion: null, required: true },
+        { name: 'certbot', cmd: 'certbot --version 2>/dev/null || echo "not installed"', minVersion: null, required: false },
+    ];
+    log.info('=== Required Programs ===');
+    for (const prog of programs) {
+        const progSpinner = spinner(`Checking ${prog.name}...`).start();
+        const result = await runSSH(host, prog.cmd);
+        if (result.success && !result.stdout.includes('not installed') && !result.stdout.includes('not found')) {
+            const version = result.stdout.trim().split('\n')[0];
+            progSpinner.succeed(`${prog.name}: ${version}`);
+            results.push({ name: prog.name, status: 'pass', message: version });
+        }
+        else {
+            if (prog.required) {
+                progSpinner.fail(`${prog.name}: NOT INSTALLED (required)`);
+                results.push({ name: prog.name, status: 'fail', message: 'Not installed (required)' });
+            }
+            else {
+                progSpinner.warn(`${prog.name}: not installed (optional)`);
+                results.push({ name: prog.name, status: 'warn', message: 'Not installed (optional)' });
+            }
+        }
+    }
+    log.blank();
+    log.info('=== System Resources ===');
+    // Check CPU
+    const cpuSpinner = spinner('Checking CPU...').start();
+    const cpuResult = await runSSH(host, 'nproc');
+    if (cpuResult.success) {
+        const cores = parseInt(cpuResult.stdout.trim());
+        if (cores >= 2) {
+            cpuSpinner.succeed(`CPU: ${cores} cores`);
+            results.push({ name: 'CPU', status: 'pass', message: `${cores} cores` });
+        }
+        else {
+            cpuSpinner.warn(`CPU: ${cores} core (recommend 2+)`);
+            results.push({ name: 'CPU', status: 'warn', message: `${cores} core - recommend 2+` });
+        }
+    }
+    // Check RAM
+    const ramSpinner = spinner('Checking RAM...').start();
+    const ramResult = await runSSH(host, "free -g | grep Mem | awk '{print $2}'");
+    if (ramResult.success) {
+        const gb = parseInt(ramResult.stdout.trim());
+        if (gb >= 4) {
+            ramSpinner.succeed(`RAM: ${gb}GB`);
+            results.push({ name: 'RAM', status: 'pass', message: `${gb}GB` });
+        }
+        else if (gb >= 2) {
+            ramSpinner.warn(`RAM: ${gb}GB (recommend 4GB+)`);
+            results.push({ name: 'RAM', status: 'warn', message: `${gb}GB - recommend 4GB+` });
+        }
+        else {
+            ramSpinner.fail(`RAM: ${gb}GB (minimum 2GB required)`);
+            results.push({ name: 'RAM', status: 'fail', message: `${gb}GB - minimum 2GB required` });
+        }
+    }
+    // Check Disk
+    const diskSpinner = spinner('Checking disk space...').start();
+    const diskResult = await runSSH(host, "df -BG / | tail -1 | awk '{print $4}' | tr -d 'G'");
+    if (diskResult.success) {
+        const freeGB = parseInt(diskResult.stdout.trim());
+        if (freeGB >= 20) {
+            diskSpinner.succeed(`Disk: ${freeGB}GB free`);
+            results.push({ name: 'Disk', status: 'pass', message: `${freeGB}GB free` });
+        }
+        else if (freeGB >= 10) {
+            diskSpinner.warn(`Disk: ${freeGB}GB free (recommend 20GB+)`);
+            results.push({ name: 'Disk', status: 'warn', message: `${freeGB}GB free - recommend 20GB+` });
+        }
+        else {
+            diskSpinner.fail(`Disk: ${freeGB}GB free (minimum 10GB required)`);
+            results.push({ name: 'Disk', status: 'fail', message: `${freeGB}GB free - minimum 10GB required` });
+        }
+    }
+    // Check OS
+    const osSpinner = spinner('Checking OS...').start();
+    const osResult = await runSSH(host, 'cat /etc/os-release | grep PRETTY_NAME | cut -d= -f2 | tr -d \'"\'');
+    if (osResult.success) {
+        osSpinner.succeed(`OS: ${osResult.stdout.trim()}`);
+        results.push({ name: 'OS', status: 'pass', message: osResult.stdout.trim() });
+    }
+    log.blank();
+    log.info('=== Docker Status ===');
+    // Check Docker daemon
+    const dockerDaemonSpinner = spinner('Checking Docker daemon...').start();
+    const dockerDaemonResult = await runSSH(host, 'docker info >/dev/null 2>&1 && echo "running" || echo "not running"');
+    if (dockerDaemonResult.stdout.trim() === 'running') {
+        dockerDaemonSpinner.succeed('Docker daemon: Running');
+        results.push({ name: 'Docker Daemon', status: 'pass', message: 'Running' });
+    }
+    else {
+        dockerDaemonSpinner.fail('Docker daemon: Not running');
+        results.push({ name: 'Docker Daemon', status: 'fail', message: 'Not running' });
+    }
+    // Check Docker networks
+    const networkSpinner = spinner('Checking Docker networks...').start();
+    const networkResult = await runSSH(host, 'docker network ls --format "{{.Name}}" | grep -E "vucore" || echo "none"');
+    if (networkResult.stdout.trim() !== 'none') {
+        const networks = networkResult.stdout.trim().split('\n');
+        networkSpinner.succeed(`Docker networks: ${networks.length} ciCore networks`);
+        results.push({ name: 'Docker Networks', status: 'pass', message: networks.join(', ') });
+    }
+    else {
+        networkSpinner.warn('Docker networks: No ciCore networks found');
+        results.push({ name: 'Docker Networks', status: 'warn', message: 'None found - will be created during install' });
+    }
+    log.blank();
+    printCheckSummary(results);
+    // Print installation commands if needed
+    const failed = results.filter(r => r.status === 'fail');
+    if (failed.length > 0) {
+        log.blank();
+        log.info('=== Installation Commands ===');
+        if (failed.some(r => r.name === 'docker')) {
+            log.item('Docker: curl -fsSL https://get.docker.com | sh');
+        }
+        if (failed.some(r => r.name === 'tree')) {
+            log.item('Tree: apt-get install -y tree');
+        }
+        if (failed.some(r => r.name === 'certbot')) {
+            log.item('Certbot: apt-get install -y certbot');
+        }
+    }
+}
+// ============================================
+// SHOW TREE
+// ============================================
+async function showTree(options) {
+    log.title('🌳 Server Directory Structure');
+    log.blank();
+    const host = await getSSHHost(options.host);
+    if (!host) {
+        log.error(`SSH host "${options.host}" not found`);
+        return;
+    }
+    const depth = options.depth || '3';
+    // Check if tree is installed
+    const treeCheck = await runSSH(host, 'which tree 2>/dev/null || echo "not found"');
+    const hasTree = !treeCheck.stdout.includes('not found');
+    if (options.core) {
+        // Show specific core structure
+        log.info(`Core: ${options.core}`);
+        log.blank();
+        const corePath = `/home/cores/${options.core}`;
+        if (hasTree) {
+            const result = await runSSH(host, `tree -L ${depth} --dirsfirst ${corePath} 2>/dev/null || echo "Directory not found"`);
+            console.log(result.stdout);
+        }
+        else {
+            const result = await runSSH(host, `find ${corePath} -maxdepth ${depth} -type d 2>/dev/null | head -50`);
+            console.log(result.stdout);
+        }
+    }
+    else {
+        // Show full /home structure
+        log.info('Full /home structure:');
+        log.blank();
+        if (hasTree) {
+            const result = await runSSH(host, `tree -L ${depth} --dirsfirst /home 2>/dev/null || echo "Directory not found"`);
+            console.log(result.stdout);
+        }
+        else {
+            log.warn('tree command not installed. Using find instead...');
+            log.info('Install tree: apt-get install -y tree');
+            log.blank();
+            const result = await runSSH(host, `find /home -maxdepth ${depth} -type d 2>/dev/null | head -100`);
+            console.log(result.stdout);
+        }
+    }
+    // Show expected structure
+    log.blank();
+    log.info('=== Expected ciCore Structure ===');
+    console.log(`
+/home/
+├── cores/
+│   ├── core1/
+│   │   ├── .env
+│   │   ├── addons/
+│   │   │   └── AddonName/
+│   │   │       ├── Backend/
+│   │   │       └── ui/
+│   │   ├── shared/
+│   │   └── storage/
+│   └── core2/
+│       └── ...
+├── services/
+│   ├── docker-core-nuxt.yml
+│   ├── docker-core-php.yml
+│   ├── docker-postgresql.yml
+│   ├── docker-redis.yml
+│   ├── docker-server-nginx.yml
+│   ├── .env
+│   ├── nginx/
+│   │   ├── conf.d/
+│   │   │   └── vucore-global-router.conf
+│   │   └── ssl/
+│   │       ├── domain.crt
+│   │       └── domain.key
+│   ├── postgres/
+│   │   ├── backups/
+│   │   ├── data/
+│   │   └── init/
+│   ├── redis/
+│   │   └── data/
+│   └── scripts/
+│       ├── clear-all-cache.sh
+│       └── addons/
+│           └── build-addon-esm-master.sh
+`);
+}
+// ============================================
+// CHECK API ENDPOINTS
+// ============================================
+async function checkAPI(options) {
+    log.title('🔌 API Endpoint Check');
+    log.blank();
+    const host = await getSSHHost(options.host);
+    if (!host) {
+        log.error(`SSH host "${options.host}" not found`);
+        return;
+    }
+    const results = [];
+    const domain = options.domain;
+    // Internal endpoints (via localhost)
+    log.info('=== Internal Endpoints ===');
+    const internalEndpoints = [
+        { name: 'Nuxt Health', url: 'http://localhost:3000', expected: 200 },
+        { name: 'PHP Health', url: 'http://localhost:9000/health', expected: null }, // FPM doesn't respond to HTTP
+        { name: 'Nginx', url: 'http://localhost:80', expected: [200, 301, 302] },
+    ];
+    for (const endpoint of internalEndpoints) {
+        const epSpinner = spinner(`Checking ${endpoint.name}...`).start();
+        const result = await runSSH(host, `curl -s -o /dev/null -w "%{http_code}" ${endpoint.url} 2>/dev/null || echo "000"`);
+        const status = parseInt(result.stdout.trim());
+        if (endpoint.expected === null) {
+            epSpinner.warn(`${endpoint.name}: N/A (FPM)`);
+            results.push({ name: endpoint.name, status: 'warn', message: 'FPM - use docker logs' });
+        }
+        else if (Array.isArray(endpoint.expected) ? endpoint.expected.includes(status) : status === endpoint.expected) {
+            epSpinner.succeed(`${endpoint.name}: HTTP ${status}`);
+            results.push({ name: endpoint.name, status: 'pass', message: `HTTP ${status}` });
+        }
+        else if (status === 0) {
+            epSpinner.fail(`${endpoint.name}: Not responding`);
+            results.push({ name: endpoint.name, status: 'fail', message: 'Not responding' });
+        }
+        else {
+            epSpinner.warn(`${endpoint.name}: HTTP ${status}`);
+            results.push({ name: endpoint.name, status: 'warn', message: `HTTP ${status}` });
+        }
+    }
+    // External endpoints (if domain provided)
+    if (domain) {
+        log.blank();
+        log.info(`=== External Endpoints (${domain}) ===`);
+        const externalEndpoints = [
+            { name: 'Main Site', url: `https://${domain}`, expected: 200 },
+            { name: 'WWW', url: `https://www.${domain}`, expected: [200, 301] },
+            { name: 'API Health', url: `https://api.${domain}/api/health`, expected: 200 },
+            { name: 'API System', url: `https://api.${domain}/api/system/health`, expected: 200 },
+        ];
+        for (const endpoint of externalEndpoints) {
+            const epSpinner = spinner(`Checking ${endpoint.name}...`).start();
+            const result = await runSSH(host, `curl -sk -o /dev/null -w "%{http_code}" ${endpoint.url} 2>/dev/null || echo "000"`);
+            const status = parseInt(result.stdout.trim());
+            if (Array.isArray(endpoint.expected) ? endpoint.expected.includes(status) : status === endpoint.expected) {
+                epSpinner.succeed(`${endpoint.name}: HTTP ${status}`);
+                results.push({ name: `${endpoint.name} (${domain})`, status: 'pass', message: `HTTP ${status}` });
+            }
+            else if (status === 0) {
+                epSpinner.fail(`${endpoint.name}: Not responding`);
+                results.push({ name: `${endpoint.name} (${domain})`, status: 'fail', message: 'Not responding' });
+            }
+            else {
+                epSpinner.warn(`${endpoint.name}: HTTP ${status}`);
+                results.push({ name: `${endpoint.name} (${domain})`, status: 'warn', message: `HTTP ${status}` });
+            }
+        }
+    }
+    log.blank();
+    printCheckSummary(results);
+}
+// ============================================
+// CHECK SERVICES
+// ============================================
+async function checkServices(options) {
+    log.title('🐳 ciCore Services Status');
+    log.blank();
+    const host = await getSSHHost(options.host);
+    if (!host) {
+        log.error(`SSH host "${options.host}" not found`);
+        return;
+    }
+    const results = [];
+    // Expected containers
+    const expectedContainers = [
+        { name: 'cicore_global_nginx', port: '80, 443', critical: true },
+        { name: 'cicore_nuxt', port: '3000', critical: true },
+        { name: 'cicore_php', port: '9000', critical: true },
+        { name: 'cicore_global_postgres', port: '5432', critical: true },
+        { name: 'cicore_global_redis', port: '6379', critical: true },
+    ];
+    // Get all container statuses
+    const psResult = await runSSH(host, 'docker ps -a --format "{{.Names}}|{{.Status}}|{{.Ports}}" | grep vucore');
+    const runningContainers = new Map();
+    if (psResult.success && psResult.stdout.trim()) {
+        psResult.stdout.trim().split('\n').forEach(line => {
+            const [name, status, ports] = line.split('|');
+            runningContainers.set(name, { status, ports: ports || '' });
+        });
+    }
+    log.info('=== Container Status ===');
+    formatTable(['Container', 'Status', 'Ports', 'Health'], expectedContainers.map(c => {
+        const container = runningContainers.get(c.name);
+        if (container) {
+            const isUp = container.status.includes('Up');
+            const health = isUp ? '✅' : '⚠️';
+            results.push({
+                name: c.name,
+                status: isUp ? 'pass' : 'warn',
+                message: container.status
+            });
+            return [c.name, container.status.substring(0, 20), container.ports.substring(0, 30), health];
+        }
+        else {
+            results.push({
+                name: c.name,
+                status: c.critical ? 'fail' : 'warn',
+                message: 'Not found'
+            });
+            return [c.name, 'NOT FOUND', '-', '❌'];
+        }
+    }));
+    // Check Docker networks
+    log.blank();
+    log.info('=== Docker Networks ===');
+    const networkResult = await runSSH(host, 'docker network ls --format "{{.Name}}\t{{.Driver}}" | grep vucore');
+    if (networkResult.success && networkResult.stdout.trim()) {
+        console.log(networkResult.stdout);
+        results.push({ name: 'Docker Networks', status: 'pass', message: 'Found' });
+    }
+    else {
+        log.warn('No ciCore networks found');
+        results.push({ name: 'Docker Networks', status: 'warn', message: 'None found' });
+    }
+    // Check Docker volumes
+    log.blank();
+    log.info('=== Docker Volumes ===');
+    const volumeResult = await runSSH(host, 'docker volume ls --format "{{.Name}}" | grep -E "postgres|redis" | head -10');
+    if (volumeResult.success && volumeResult.stdout.trim()) {
+        volumeResult.stdout.trim().split('\n').forEach(v => log.item(v));
+        results.push({ name: 'Docker Volumes', status: 'pass', message: 'Found' });
+    }
+    else {
+        log.warn('No data volumes found');
+        results.push({ name: 'Docker Volumes', status: 'warn', message: 'None found' });
+    }
+    log.blank();
+    printCheckSummary(results);
+}
+// ============================================
+// CHECK PORTS
+// ============================================
+async function checkPorts(options) {
+    log.title('🔌 Port Check');
+    log.blank();
+    const host = await getSSHHost(options.host);
+    if (!host) {
+        log.error(`SSH host "${options.host}" not found`);
+        return;
+    }
+    const results = [];
+    const requiredPorts = [
+        { port: 22, name: 'SSH', required: true },
+        { port: 80, name: 'HTTP', required: true },
+        { port: 443, name: 'HTTPS', required: true },
+        { port: 3000, name: 'Nuxt (internal)', required: false },
+        { port: 9000, name: 'PHP-FPM (internal)', required: false },
+        { port: 5432, name: 'PostgreSQL (internal)', required: false },
+        { port: 6379, name: 'Redis (internal)', required: false },
+    ];
+    log.info('=== Listening Ports ===');
+    for (const p of requiredPorts) {
+        const portSpinner = spinner(`Checking port ${p.port} (${p.name})...`).start();
+        const result = await runSSH(host, `ss -tlnp | grep ":${p.port} " | head -1`);
+        if (result.success && result.stdout.trim()) {
+            portSpinner.succeed(`Port ${p.port} (${p.name}): LISTENING`);
+            results.push({ name: `Port ${p.port}`, status: 'pass', message: `${p.name} - Listening` });
+        }
+        else {
+            if (p.required) {
+                portSpinner.fail(`Port ${p.port} (${p.name}): NOT LISTENING`);
+                results.push({ name: `Port ${p.port}`, status: 'fail', message: `${p.name} - Not listening` });
+            }
+            else {
+                portSpinner.warn(`Port ${p.port} (${p.name}): not listening`);
+                results.push({ name: `Port ${p.port}`, status: 'warn', message: `${p.name} - Not listening (internal)` });
+            }
+        }
+    }
+    // Check firewall
+    log.blank();
+    log.info('=== Firewall Status ===');
+    const ufwResult = await runSSH(host, 'ufw status 2>/dev/null || echo "ufw not installed"');
+    if (ufwResult.stdout.includes('not installed')) {
+        log.info('UFW: Not installed');
+    }
+    else {
+        console.log(ufwResult.stdout);
+    }
+    log.blank();
+    printCheckSummary(results);
+}
+// ============================================
+// PRE-INSTALLATION CHECK
+// ============================================
+async function preInstallCheck(options) {
+    log.title('🚀 Pre-Installation Check');
+    log.blank();
+    const host = await getSSHHost(options.host);
+    if (!host) {
+        log.error(`SSH host "${options.host}" not found`);
+        return;
+    }
+    log.kv('Server', `${host.name} (${host.hostname})`);
+    log.blank();
+    const results = [];
+    // 1. SSH Connection
+    log.info('=== 1. SSH Connection ===');
+    const sshSpinner = spinner('Testing SSH connection...').start();
+    const sshResult = await runSSH(host, 'echo "OK"');
+    if (sshResult.success) {
+        sshSpinner.succeed('SSH: Connected');
+        results.push({ name: 'SSH Connection', status: 'pass', message: 'Connected' });
+    }
+    else {
+        sshSpinner.fail('SSH: Connection failed');
+        results.push({ name: 'SSH Connection', status: 'fail', message: 'Failed' });
+        printCheckSummary(results);
+        return;
+    }
+    // 2. OS Check
+    log.blank();
+    log.info('=== 2. Operating System ===');
+    const osSpinner = spinner('Checking OS...').start();
+    const osResult = await runSSH(host, 'cat /etc/os-release | grep -E "^(NAME|VERSION)=" | head -2');
+    if (osResult.success) {
+        osSpinner.succeed('OS: ' + osResult.stdout.trim().replace(/\n/g, ' '));
+        results.push({ name: 'Operating System', status: 'pass', message: 'Linux' });
+    }
+    // 3. Docker
+    log.blank();
+    log.info('=== 3. Docker ===');
+    const dockerSpinner = spinner('Checking Docker...').start();
+    const dockerResult = await runSSH(host, 'docker --version 2>/dev/null');
+    if (dockerResult.success) {
+        dockerSpinner.succeed('Docker: ' + dockerResult.stdout.trim());
+        results.push({ name: 'Docker', status: 'pass', message: 'Installed' });
+        // Check Docker daemon
+        const daemonResult = await runSSH(host, 'docker info >/dev/null 2>&1 && echo "running"');
+        if (daemonResult.stdout.includes('running')) {
+            log.item('Docker daemon: Running');
+            results.push({ name: 'Docker Daemon', status: 'pass', message: 'Running' });
+        }
+        else {
+            log.warn('Docker daemon: Not running');
+            results.push({ name: 'Docker Daemon', status: 'fail', message: 'Not running' });
+        }
+    }
+    else {
+        dockerSpinner.fail('Docker: NOT INSTALLED');
+        results.push({ name: 'Docker', status: 'fail', message: 'Not installed' });
+        log.item('Install: curl -fsSL https://get.docker.com | sh');
+    }
+    // 4. Resources
+    log.blank();
+    log.info('=== 4. System Resources ===');
+    // CPU
+    const cpuResult = await runSSH(host, 'nproc');
+    const cores = parseInt(cpuResult.stdout.trim()) || 0;
+    log.item(`CPU: ${cores} cores ${cores >= 2 ? '✅' : '⚠️'}`);
+    results.push({ name: 'CPU', status: cores >= 2 ? 'pass' : 'warn', message: `${cores} cores` });
+    // RAM
+    const ramResult = await runSSH(host, "free -g | grep Mem | awk '{print $2}'");
+    const ram = parseInt(ramResult.stdout.trim()) || 0;
+    log.item(`RAM: ${ram}GB ${ram >= 4 ? '✅' : ram >= 2 ? '⚠️' : '❌'}`);
+    results.push({ name: 'RAM', status: ram >= 4 ? 'pass' : ram >= 2 ? 'warn' : 'fail', message: `${ram}GB` });
+    // Disk
+    const diskResult = await runSSH(host, "df -BG / | tail -1 | awk '{print $4}' | tr -d 'G'");
+    const disk = parseInt(diskResult.stdout.trim()) || 0;
+    log.item(`Disk Free: ${disk}GB ${disk >= 20 ? '✅' : disk >= 10 ? '⚠️' : '❌'}`);
+    results.push({ name: 'Disk', status: disk >= 20 ? 'pass' : disk >= 10 ? 'warn' : 'fail', message: `${disk}GB free` });
+    // 5. Network
+    log.blank();
+    log.info('=== 5. Network ===');
+    // Internet
+    const internetResult = await runSSH(host, 'curl -s -o /dev/null -w "%{http_code}" https://google.com');
+    const hasInternet = internetResult.stdout.trim() === '200' || internetResult.stdout.trim() === '301';
+    log.item(`Internet: ${hasInternet ? '✅ Connected' : '❌ Not connected'}`);
+    results.push({ name: 'Internet', status: hasInternet ? 'pass' : 'fail', message: hasInternet ? 'Connected' : 'Not connected' });
+    // Docker Hub
+    const dockerHubResult = await runSSH(host, 'curl -s -o /dev/null -w "%{http_code}" https://hub.docker.com');
+    const hasDockerHub = dockerHubResult.stdout.trim() === '200';
+    log.item(`Docker Hub: ${hasDockerHub ? '✅ Accessible' : '⚠️ Not accessible'}`);
+    results.push({ name: 'Docker Hub', status: hasDockerHub ? 'pass' : 'warn', message: hasDockerHub ? 'Accessible' : 'Not accessible' });
+    // 6. Ports
+    log.blank();
+    log.info('=== 6. Required Ports ===');
+    const portsToCheck = [80, 443];
+    for (const port of portsToCheck) {
+        const portResult = await runSSH(host, `ss -tlnp | grep ":${port} " | head -1 || echo "free"`);
+        const isFree = portResult.stdout.includes('free') || !portResult.stdout.trim();
+        const isVucore = portResult.stdout.includes('vucore') || portResult.stdout.includes('nginx');
+        if (isFree) {
+            log.item(`Port ${port}: ✅ Available`);
+            results.push({ name: `Port ${port}`, status: 'pass', message: 'Available' });
+        }
+        else if (isVucore) {
+            log.item(`Port ${port}: ✅ Used by VuCore`);
+            results.push({ name: `Port ${port}`, status: 'pass', message: 'VuCore' });
+        }
+        else {
+            log.item(`Port ${port}: ⚠️ In use by another service`);
+            results.push({ name: `Port ${port}`, status: 'warn', message: 'In use' });
+        }
+    }
+    // Summary
+    log.blank();
+    printCheckSummary(results);
+    // Final verdict
+    const failed = results.filter(r => r.status === 'fail').length;
+    const warned = results.filter(r => r.status === 'warn').length;
+    log.blank();
+    if (failed === 0) {
+        log.box('✅ Server Ready for Installation', [
+            'All critical requirements met.',
+            `Run: vu server install --host ${host.name} --core core1 --domain yourdomain.com`,
+        ]);
+    }
+    else {
+        log.box('❌ Server Not Ready', [
+            `${failed} critical issue(s) must be resolved.`,
+            'Fix the issues above and run this check again.',
+        ]);
+    }
+}
+//# sourceMappingURL=index.js.map