clawsql 0.1.0

package/dist/cli/commands/doctor.js

@@ -0,0 +1,687 @@
+"use strict";
+/**
+ * ClawSQL CLI - Doctor Command
+ *
+ * Diagnoses system health and suggests fixes for common issues.
+ * Similar to `brew doctor` or `npm doctor`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctorCommand = void 0;
+const components_js_1 = require("../ui/components.js");
+const child_process_1 = require("child_process");
+/**
+ * Doctor command
+ */
+exports.doctorCommand = {
+    name: 'doctor',
+    description: 'Diagnose system issues and suggest fixes',
+    usage: '/doctor [--fix]',
+    handler: async (args, ctx) => {
+        const formatter = ctx.formatter;
+        const shouldFix = args.includes('--fix');
+        console.log(formatter.header('ClawSQL Doctor'));
+        console.log(components_js_1.theme.muted('Running diagnostics...\n'));
+        const results = [];
+        // Run all diagnostic checks
+        await runDiagnostics(ctx, results);
+        // Display results
+        displayResults(results);
+        // Summary
+        const errors = results.filter(r => r.severity === 'error');
+        const warnings = results.filter(r => r.severity === 'warning');
+        console.log();
+        if (errors.length === 0 && warnings.length === 0) {
+            console.log(components_js_1.theme.success(`${components_js_1.indicators.check} All systems healthy!`));
+        }
+        else {
+            console.log(components_js_1.theme.warning(`Found ${errors.length} error(s) and ${warnings.length} warning(s)`));
+            if (!shouldFix && (errors.length > 0 || warnings.length > 0)) {
+                console.log(components_js_1.theme.muted('\nSome issues may have automatic fixes available.'));
+            }
+        }
+    },
+};
+/**
+ * Run all diagnostic checks
+ */
+async function runDiagnostics(ctx, results) {
+    // Platform checks
+    await checkContainerRuntime(results);
+    await checkClawSQLAPI(ctx, results);
+    await checkOrchestrator(ctx, results);
+    await checkProxySQL(ctx, results);
+    await checkPrometheus(ctx, results);
+    // Configuration checks
+    checkConfiguration(ctx, results);
+    // MySQL checks
+    await checkMySQLInstances(ctx, results);
+    await checkReplicationTopology(ctx, results);
+    // Sync check
+    await checkProxySQLSync(ctx, results);
+}
+/**
+ * Check container runtime availability
+ */
+async function checkContainerRuntime(results) {
+    const runtimes = ['docker', 'podman'];
+    let foundRuntime = '';
+    for (const runtime of runtimes) {
+        try {
+            const result = await execCommand([runtime, 'info'], true);
+            if (result.success) {
+                foundRuntime = runtime;
+                break;
+            }
+        }
+        catch {
+            // Continue to next runtime
+        }
+    }
+    if (foundRuntime) {
+        results.push({
+            name: 'Container Runtime',
+            severity: 'ok',
+            message: `${foundRuntime} is installed and running`,
+        });
+        // Check if containers are running
+        try {
+            const psResult = await execCommand([foundRuntime, 'ps', '--filter', 'name=clawsql', '--filter', 'name=orchestrator',
+                '--filter', 'name=proxysql', '-q'], true);
+            const containerCount = psResult.stdout.trim().split('\n').filter(Boolean).length;
+            if (containerCount === 0) {
+                results.push({
+                    name: 'Platform Containers',
+                    severity: 'warning',
+                    message: 'No ClawSQL containers are running',
+                    fix: 'Start the platform with: /start',
+                    fixCommand: '/start',
+                });
+            }
+            else {
+                results.push({
+                    name: 'Platform Containers',
+                    severity: 'ok',
+                    message: `${containerCount} container(s) running`,
+                });
+            }
+        }
+        catch {
+            results.push({
+                name: 'Platform Containers',
+                severity: 'warning',
+                message: 'Could not check container status',
+            });
+        }
+    }
+    else {
+        results.push({
+            name: 'Container Runtime',
+            severity: 'error',
+            message: 'No container runtime found (docker or podman required)',
+            fix: 'Install Docker from https://docs.docker.com/get-docker/',
+        });
+    }
+}
+/**
+ * Check ClawSQL API health
+ */
+async function checkClawSQLAPI(ctx, results) {
+    try {
+        const response = await fetch(`http://localhost:${ctx.settings.api.port}/health`, {
+            signal: AbortSignal.timeout(5000),
+        });
+        if (response.ok) {
+            const data = await response.json();
+            if (data.status === 'healthy') {
+                results.push({
+                    name: 'ClawSQL API',
+                    severity: 'ok',
+                    message: `Running on port ${ctx.settings.api.port}`,
+                });
+            }
+            else {
+                results.push({
+                    name: 'ClawSQL API',
+                    severity: 'error',
+                    message: `API returned status: ${data.status}`,
+                    fix: 'Check logs: docker logs clawsql',
+                });
+            }
+        }
+        else {
+            results.push({
+                name: 'ClawSQL API',
+                severity: 'error',
+                message: `API returned HTTP ${response.status}`,
+                fix: 'Check logs: docker logs clawsql',
+            });
+        }
+    }
+    catch {
+        results.push({
+            name: 'ClawSQL API',
+            severity: 'error',
+            message: 'API is not responding',
+            detail: `Expected at http://localhost:${ctx.settings.api.port}`,
+            fix: 'Start the platform with: /start',
+            fixCommand: '/start',
+        });
+    }
+}
+/**
+ * Check Orchestrator health
+ */
+async function checkOrchestrator(ctx, results) {
+    try {
+        const isHealthy = await ctx.orchestrator.healthCheck();
+        if (isHealthy) {
+            results.push({
+                name: 'Orchestrator',
+                severity: 'ok',
+                message: `Running at ${ctx.settings.orchestrator.url}`,
+            });
+            // Check if instances are discovered
+            try {
+                const clusters = await ctx.orchestrator.getClusters();
+                if (clusters.length === 0) {
+                    results.push({
+                        name: 'MySQL Topology',
+                        severity: 'warning',
+                        message: 'No MySQL instances discovered in Orchestrator',
+                        fix: 'Register instances with: /instances register <host>',
+                        fixCommand: '/instances register <mysql-host>',
+                    });
+                }
+                else {
+                    results.push({
+                        name: 'MySQL Topology',
+                        severity: 'ok',
+                        message: `${clusters.length} cluster(s) discovered`,
+                    });
+                }
+            }
+            catch {
+                results.push({
+                    name: 'MySQL Topology',
+                    severity: 'warning',
+                    message: 'Could not retrieve topology information',
+                });
+            }
+        }
+        else {
+            results.push({
+                name: 'Orchestrator',
+                severity: 'error',
+                message: 'Health check failed',
+                fix: 'Check Orchestrator container: docker logs orchestrator',
+            });
+        }
+    }
+    catch {
+        results.push({
+            name: 'Orchestrator',
+            severity: 'error',
+            message: 'Cannot connect to Orchestrator',
+            detail: `Expected at ${ctx.settings.orchestrator.url}`,
+            fix: 'Ensure Orchestrator container is running: docker ps | grep orchestrator',
+        });
+    }
+}
+/**
+ * Check ProxySQL health
+ */
+async function checkProxySQL(ctx, results) {
+    try {
+        await ctx.proxysql.connect();
+        results.push({
+            name: 'ProxySQL',
+            severity: 'ok',
+            message: `Admin interface running on port ${ctx.settings.proxysql.adminPort}`,
+        });
+        // Check if MySQL servers are configured
+        try {
+            const servers = await ctx.proxysql.getServers();
+            if (servers.length === 0) {
+                results.push({
+                    name: 'ProxySQL Servers',
+                    severity: 'warning',
+                    message: 'No MySQL servers configured in ProxySQL',
+                    fix: 'Register MySQL instances, then sync with: /clusters sync',
+                });
+            }
+            else {
+                const onlineServers = servers.filter(s => s.status === 'ONLINE');
+                if (onlineServers.length === servers.length) {
+                    results.push({
+                        name: 'ProxySQL Servers',
+                        severity: 'ok',
+                        message: `${onlineServers.length}/${servers.length} servers online`,
+                    });
+                }
+                else {
+                    results.push({
+                        name: 'ProxySQL Servers',
+                        severity: 'warning',
+                        message: `${onlineServers.length}/${servers.length} servers online`,
+                        fix: 'Check MySQL server connectivity and credentials',
+                    });
+                }
+            }
+        }
+        catch {
+            results.push({
+                name: 'ProxySQL Servers',
+                severity: 'warning',
+                message: 'Could not retrieve server configuration',
+            });
+        }
+        await ctx.proxysql.close();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        results.push({
+            name: 'ProxySQL',
+            severity: 'error',
+            message: 'Cannot connect to ProxySQL admin interface',
+            detail: message,
+            fix: 'Ensure ProxySQL container is running: docker ps | grep proxysql',
+        });
+    }
+}
+/**
+ * Check Prometheus health
+ */
+async function checkPrometheus(ctx, results) {
+    try {
+        const response = await fetch(`${ctx.settings.prometheus.url}/-/healthy`, {
+            signal: AbortSignal.timeout(5000),
+        });
+        if (response.ok) {
+            results.push({
+                name: 'Prometheus',
+                severity: 'ok',
+                message: `Running at ${ctx.settings.prometheus.url}`,
+            });
+        }
+        else {
+            results.push({
+                name: 'Prometheus',
+                severity: 'warning',
+                message: `Health check returned status ${response.status}`,
+                fix: 'Check Prometheus container: docker logs prometheus',
+            });
+        }
+    }
+    catch {
+        results.push({
+            name: 'Prometheus',
+            severity: 'warning',
+            message: 'Cannot connect to Prometheus',
+            detail: `Expected at ${ctx.settings.prometheus.url}`,
+            fix: 'Prometheus is optional. Start with: /start',
+        });
+    }
+}
+/**
+ * Check configuration issues
+ */
+function checkConfiguration(ctx, results) {
+    // Check API token secret
+    if (ctx.settings.api.tokenSecret === 'change-me-in-production') {
+        results.push({
+            name: 'API Token Secret',
+            severity: 'warning',
+            message: 'Using default token secret (not secure for production)',
+            fix: 'Set environment variable: API_TOKEN_SECRET=<your-secret>',
+        });
+    }
+    // Check MySQL credentials
+    if (!ctx.settings.mysql.adminPassword) {
+        results.push({
+            name: 'MySQL Credentials',
+            severity: 'warning',
+            message: 'MySQL admin password not configured',
+            detail: 'Required for instance discovery and management',
+            fix: 'Set environment variable: MYSQL_ADMIN_PASSWORD=<password>',
+        });
+    }
+    // Check auto-failover
+    if (!ctx.settings.failover.autoFailoverEnabled) {
+        results.push({
+            name: 'Auto Failover',
+            severity: 'info',
+            message: 'Automatic failover is disabled',
+            fix: 'Enable with: AUTO_FAILOVER_ENABLED=true',
+        });
+    }
+    // Check metadata database
+    if (!ctx.settings.metadataDb.host) {
+        results.push({
+            name: 'Metadata Database',
+            severity: 'ok',
+            message: 'Using auto-provisioned metadata-mysql container',
+        });
+    }
+}
+/**
+ * Check MySQL instances health
+ */
+async function checkMySQLInstances(ctx, results) {
+    try {
+        const clusters = await ctx.orchestrator.getClusters();
+        for (const clusterName of clusters) {
+            const topology = await ctx.orchestrator.getTopology(clusterName);
+            if (!topology)
+                continue;
+            // Check primary
+            if (topology.primary) {
+                if (topology.primary.state !== 'online') {
+                    results.push({
+                        name: `Primary [${topology.name || clusterName}]`,
+                        severity: 'error',
+                        message: `Primary ${topology.primary.host}:${topology.primary.port} is ${topology.primary.state}`,
+                        fix: 'Check MySQL instance status and connectivity',
+                    });
+                }
+                else {
+                    results.push({
+                        name: `Primary [${topology.name || clusterName}]`,
+                        severity: 'ok',
+                        message: `${topology.primary.host}:${topology.primary.port} is online`,
+                    });
+                }
+            }
+            else {
+                results.push({
+                    name: `Primary [${topology.name || clusterName}]`,
+                    severity: 'error',
+                    message: 'No primary found for cluster',
+                    fix: 'Check replication setup or promote a replica: /failover switchover',
+                });
+            }
+            // Check replicas
+            for (const replica of topology.replicas) {
+                if (replica.state !== 'online') {
+                    results.push({
+                        name: `Replica [${topology.name || clusterName}]`,
+                        severity: 'warning',
+                        message: `Replica ${replica.host}:${replica.port} is ${replica.state}`,
+                        fix: 'Check replica MySQL status and replication connection',
+                    });
+                }
+                else if (replica.replicationLag !== undefined && replica.replicationLag > 60) {
+                    results.push({
+                        name: `Replica Lag [${topology.name || clusterName}]`,
+                        severity: 'warning',
+                        message: `Replica ${replica.host}:${replica.port} has high lag (${replica.replicationLag}s)`,
+                        fix: 'Check replica performance and network connectivity',
+                    });
+                }
+            }
+        }
+    }
+    catch {
+        // Already handled in Orchestrator check
+    }
+}
+/**
+ * Check replication topology issues
+ */
+async function checkReplicationTopology(ctx, results) {
+    try {
+        const analysis = await ctx.orchestrator.getReplicationAnalysis();
+        for (const issue of analysis) {
+            const analysisType = issue.Analysis;
+            const description = issue.Description;
+            const affectedHost = issue.Key?.Hostname;
+            if (analysisType && !analysisType.includes('NoProblem')) {
+                results.push({
+                    name: 'Replication Analysis',
+                    severity: 'warning',
+                    message: `${analysisType}: ${affectedHost || 'unknown'}`,
+                    detail: description,
+                    fix: 'Review Orchestrator UI for details: http://localhost:3000',
+                });
+            }
+        }
+    }
+    catch {
+        // Orchestrator may not be available
+    }
+}
+/**
+ * Check ProxySQL sync with Orchestrator topology
+ */
+async function checkProxySQLSync(ctx, results) {
+    try {
+        // Get topology from Orchestrator
+        const clusters = await ctx.orchestrator.getClusters();
+        if (clusters.length === 0) {
+            return; // No clusters to sync
+        }
+        // Get ProxySQL server stats and hostgroups
+        let proxysqlServers = [];
+        let hostgroups = [];
+        try {
+            await ctx.proxysql.connect();
+            proxysqlServers = await ctx.proxysql.getServers();
+            hostgroups = await ctx.proxysql.getReplicationHostgroups();
+            await ctx.proxysql.close();
+        }
+        catch {
+            // ProxySQL not available - already reported in checkProxySQL
+            return;
+        }
+        // Build expected instances from Orchestrator
+        const expectedInstances = new Map();
+        for (const clusterName of clusters) {
+            const topology = await ctx.orchestrator.getTopology(clusterName);
+            if (!topology)
+                continue;
+            if (topology.primary) {
+                const key = `${topology.primary.host}:${topology.primary.port}`;
+                expectedInstances.set(key, {
+                    host: topology.primary.host,
+                    port: topology.primary.port,
+                    role: 'primary',
+                    cluster: topology.name || clusterName,
+                });
+            }
+            for (const replica of topology.replicas) {
+                const key = `${replica.host}:${replica.port}`;
+                expectedInstances.set(key, {
+                    host: replica.host,
+                    port: replica.port,
+                    role: 'replica',
+                    cluster: topology.name || clusterName,
+                });
+            }
+        }
+        // Build actual ProxySQL instances
+        const proxysqlInstances = new Map();
+        for (const server of proxysqlServers) {
+            const key = `${server.hostname}:${server.port}`;
+            proxysqlInstances.set(key, {
+                host: server.hostname,
+                port: server.port,
+                hostgroup: server.hostgroupId,
+                status: server.status,
+            });
+        }
+        // Determine default hostgroups (coerce to numbers)
+        const defaultWriterHG = hostgroups.length > 0 ? Number(hostgroups[0].writerHostgroup) : 10;
+        const defaultReaderHG = hostgroups.length > 0 ? Number(hostgroups[0].readerHostgroup) : 20;
+        // Check for missing instances in ProxySQL
+        const missingInProxySQL = [];
+        const wrongHostgroup = [];
+        for (const [key, instance] of expectedInstances) {
+            const proxysqlInstance = proxysqlInstances.get(key);
+            if (!proxysqlInstance) {
+                missingInProxySQL.push(`${key} (${instance.role})`);
+            }
+            else {
+                // Check if hostgroup is correct (coerce both to numbers for comparison)
+                const actualHG = Number(proxysqlInstance.hostgroup);
+                const expectedHG = instance.role === 'primary' ? defaultWriterHG : defaultReaderHG;
+                // Skip if both are NaN or if they match
+                if (!isNaN(actualHG) && !isNaN(expectedHG) && actualHG !== expectedHG) {
+                    wrongHostgroup.push(`${key} is in hg:${actualHG}, expected hg:${expectedHG}`);
+                }
+            }
+        }
+        // Check for orphan instances in ProxySQL (not in Orchestrator)
+        const orphanInstances = [];
+        for (const [key, instance] of proxysqlInstances) {
+            if (!expectedInstances.has(key)) {
+                orphanInstances.push(`${key} (hg:${instance.hostgroup})`);
+            }
+        }
+        // Report findings
+        if (missingInProxySQL.length > 0) {
+            results.push({
+                name: 'ProxySQL Sync',
+                severity: 'warning',
+                message: `${missingInProxySQL.length} instance(s) from Orchestrator missing in ProxySQL`,
+                detail: missingInProxySQL.slice(0, 5).join(', ') + (missingInProxySQL.length > 5 ? '...' : ''),
+                fix: 'Sync clusters to ProxySQL with: /clusters sync',
+                fixCommand: '/clusters sync',
+            });
+        }
+        if (wrongHostgroup.length > 0) {
+            results.push({
+                name: 'ProxySQL Hostgroups',
+                severity: 'warning',
+                message: `${wrongHostgroup.length} instance(s) in wrong hostgroup`,
+                detail: wrongHostgroup.slice(0, 3).join('; '),
+                fix: 'Re-sync clusters to ProxySQL with: /clusters sync',
+                fixCommand: '/clusters sync',
+            });
+        }
+        if (orphanInstances.length > 0) {
+            results.push({
+                name: 'ProxySQL Orphans',
+                severity: 'warning',
+                message: `${orphanInstances.length} instance(s) in ProxySQL not in Orchestrator`,
+                detail: orphanInstances.slice(0, 3).join(', '),
+                fix: 'Remove orphan servers from ProxySQL or register them in Orchestrator',
+            });
+        }
+        // All synced properly
+        if (missingInProxySQL.length === 0 && wrongHostgroup.length === 0 && orphanInstances.length === 0 && expectedInstances.size > 0) {
+            results.push({
+                name: 'ProxySQL Sync',
+                severity: 'ok',
+                message: `All ${expectedInstances.size} instances properly synced`,
+            });
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        results.push({
+            name: 'ProxySQL Sync',
+            severity: 'warning',
+            message: 'Could not verify ProxySQL sync',
+            detail: message,
+        });
+    }
+}
+/**
+ * Display diagnostic results
+ */
+function displayResults(results) {
+    // Group by severity
+    const errors = results.filter(r => r.severity === 'error');
+    const warnings = results.filter(r => r.severity === 'warning');
+    const ok = results.filter(r => r.severity === 'ok');
+    const info = results.filter(r => r.severity === 'info');
+    // Display errors first
+    if (errors.length > 0) {
+        console.log(components_js_1.theme.error.bold('\n✗ Errors:\n'));
+        for (const result of errors) {
+            displayResult(result);
+        }
+    }
+    // Display warnings
+    if (warnings.length > 0) {
+        console.log(components_js_1.theme.warning.bold('\n◆ Warnings:\n'));
+        for (const result of warnings) {
+            displayResult(result);
+        }
+    }
+    // Display info
+    if (info.length > 0) {
+        console.log(components_js_1.theme.info.bold('\n○ Information:\n'));
+        for (const result of info) {
+            displayResult(result);
+        }
+    }
+    // Display healthy checks
+    if (ok.length > 0) {
+        console.log(components_js_1.theme.success.bold('\n✓ Healthy:\n'));
+        for (const result of ok) {
+            console.log(components_js_1.theme.muted(`  ${result.name}: `) + components_js_1.theme.success(result.message));
+        }
+    }
+}
+/**
+ * Display a single diagnostic result
+ */
+function displayResult(result) {
+    const severityStyles = {
+        error: components_js_1.theme.error,
+        warning: components_js_1.theme.warning,
+        ok: components_js_1.theme.success,
+        info: components_js_1.theme.info,
+    };
+    const severityIcons = {
+        error: components_js_1.theme.error(components_js_1.indicators.cross),
+        warning: components_js_1.theme.warning(components_js_1.indicators.warning),
+        ok: components_js_1.theme.success(components_js_1.indicators.check),
+        info: components_js_1.theme.info(components_js_1.indicators.info),
+    };
+    const icon = severityIcons[result.severity];
+    const nameColor = severityStyles[result.severity];
+    console.log(`  ${icon} ${nameColor.bold(result.name)}: ${result.message}`);
+    if (result.detail) {
+        console.log(components_js_1.theme.muted(`      ${result.detail}`));
+    }
+    if (result.fix) {
+        console.log(components_js_1.theme.primary(`      Fix: ${result.fix}`));
+    }
+    if (result.fixCommand) {
+        console.log(components_js_1.theme.muted(`      Command: ${result.fixCommand}`));
+    }
+    console.log();
+}
+/**
+ * Execute a shell command
+ */
+function execCommand(cmd, silent = false) {
+    return new Promise((resolve) => {
+        const proc = (0, child_process_1.spawn)(cmd[0], cmd.slice(1), {
+            stdio: silent ? 'pipe' : 'inherit',
+        });
+        let stdout = '';
+        let stderr = '';
+        if (silent) {
+            proc.stdout?.on('data', (data) => { stdout += data; });
+            proc.stderr?.on('data', (data) => { stderr += data; });
+        }
+        proc.on('close', (code) => {
+            resolve({
+                success: code === 0,
+                stdout,
+                stderr,
+            });
+        });
+        proc.on('error', () => {
+            resolve({
+                success: false,
+                stdout: '',
+                stderr: 'Failed to execute command',
+            });
+        });
+    });
+}
+exports.default = exports.doctorCommand;
+//# sourceMappingURL=doctor.js.map