buildhive-agent 1.0.0-beta.1

package/dist/cli.js

@@ -0,0 +1,749 @@
+#!/usr/bin/env node
+/**
+ * BuildHive Agent CLI
+ *
+ * Command-line interface for managing the BuildHive agent.
+ * Provides commands for registration, starting/stopping the agent, and status checks.
+ *
+ * Requirements: MVP.4.1.1, MVP.4.1.2, MVP.4.3.3
+ */
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import { BuildHiveAgent } from './agent.js';
+import { loadConfig } from './config/index.js';
+import { AgentRegistration } from './registration/index.js';
+import { createLogger } from './utils/logger.js';
+import { promises as fs } from 'fs';
+import { join } from 'path';
+import os from 'os';
+const logger = createLogger('cli');
+const program = new Command();
+// Package info
+const VERSION = '1.0.0';
+program
+    .name('buildhive-agent')
+    .description('BuildHive CI Agent - Distributed build execution agent')
+    .version(VERSION);
+/**
+ * Init command - One-liner setup wizard (Task 2.1.1)
+ * Guides the user through full agent setup in a single interactive flow.
+ */
+program
+    .command('init')
+    .description('Initialize and set up the BuildHive agent (one-liner setup)')
+    .option('-y, --yes', 'Accept all defaults without prompting')
+    .action(async (options) => {
+    console.log('=== BuildHive Agent Setup ===\n');
+    console.log('This wizard will guide you through setting up the BuildHive agent.\n');
+    try {
+        // Step 1: Gather configuration via prompts
+        let serverUrl = 'http://localhost:3001';
+        let agentName = `agent-${os.hostname()}`;
+        if (!options.yes) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'serverUrl',
+                    message: 'BuildHive server URL:',
+                    default: serverUrl,
+                    validate: (input) => {
+                        try {
+                            new URL(input);
+                            return true;
+                        }
+                        catch {
+                            return 'Please enter a valid URL (e.g. http://localhost:3001)';
+                        }
+                    },
+                },
+                {
+                    type: 'input',
+                    name: 'agentName',
+                    message: 'Agent name:',
+                    default: agentName,
+                },
+            ]);
+            serverUrl = answers.serverUrl;
+            agentName = answers.agentName;
+        }
+        // Step 2: Scan installed SDKs
+        console.log('\n[1/5] Scanning installed SDKs...');
+        const { scanInstalledSDKs, generateTagsFromSDKs } = await import('./utils/sdkScanner.js');
+        const sdkResult = await scanInstalledSDKs();
+        const sdkTags = generateTagsFromSDKs(sdkResult);
+        const detectedTools = Object.keys(sdkResult).filter(k => sdkResult[k] !== undefined);
+        console.log(`      Detected ${detectedTools.length} tool(s): ${detectedTools.join(', ')}`);
+        if (sdkTags.length > 0) {
+            console.log(`      Generated ${sdkTags.length} capability tag(s): ${sdkTags.join(', ')}`);
+        }
+        // Step 3: Validate Docker is running
+        console.log('\n[2/5] Checking Docker...');
+        try {
+            const { execSync } = await import('child_process');
+            execSync('docker info', { stdio: 'pipe' });
+            console.log('      Docker is running.');
+        }
+        catch {
+            console.error('      Docker does not appear to be running.');
+            console.error('      Please start Docker and re-run: npx buildhive-agent init');
+            process.exit(1);
+        }
+        // Step 4: Test server connectivity
+        console.log(`\n[3/5] Connecting to server at ${serverUrl}...`);
+        const { BuildHiveApiClient } = await import('./registration/apiClient.js');
+        const apiClient = new BuildHiveApiClient(serverUrl);
+        const connected = await apiClient.testConnection();
+        if (!connected) {
+            console.error(`      Cannot reach server at ${serverUrl}.`);
+            console.error('      Please verify the server is running and the URL is correct.');
+            process.exit(1);
+        }
+        console.log('      Server is reachable.');
+        // Step 5: Register the agent (generates agentId + apiKey)
+        console.log('\n[4/5] Registering agent...');
+        const registration = new AgentRegistration(serverUrl);
+        const config = await registration.registerAgent({
+            platformUrl: serverUrl,
+            name: agentName,
+            tags: ['docker', ...sdkTags],
+            maxConcurrentJobs: 1,
+        });
+        console.log(`      Agent registered. ID: ${config.agentId}`);
+        // Step 5: Write config file
+        const configDir = join(os.homedir(), '.buildhive');
+        const configPath = join(configDir, 'config.json');
+        await fs.mkdir(configDir, { recursive: true });
+        await fs.writeFile(configPath, JSON.stringify({
+            serverUrl,
+            agentId: config.agentId,
+            apiKey: config.apiKey,
+            agentName,
+        }, null, 2), 'utf-8');
+        console.log(`      Config saved to ${configPath}`);
+        // Step 6: Send first heartbeat to verify end-to-end
+        console.log('\n[5/5] Sending first heartbeat...');
+        try {
+            await apiClient.sendHeartbeat({
+                agentId: config.agentId,
+                status: 'ONLINE',
+                currentLoad: 0,
+                activeJobs: 0,
+            }, config.apiKey);
+            console.log('      Heartbeat sent successfully.');
+        }
+        catch {
+            // Non-fatal — agent is set up, heartbeat can be retried at runtime
+            console.warn('      Heartbeat failed (non-fatal). The agent will retry on start.');
+        }
+        console.log('\n=== Setup complete! ===');
+        console.log(`  Agent name : ${agentName}`);
+        console.log(`  Agent ID   : ${config.agentId}`);
+        console.log(`  Server     : ${serverUrl}`);
+        console.log(`  Config     : ${configPath}`);
+        console.log('\nNext steps:');
+        console.log('  Start the agent  : buildhive-agent start');
+        console.log('  Check status     : buildhive-agent status');
+        console.log('  View logs        : buildhive-agent logs\n');
+    }
+    catch (error) {
+        console.error('\n[ERROR] Setup failed:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+/**
+ * Register command - Interactive agent registration
+ */
+program
+    .command('register')
+    .description('Register agent with BuildHive platform')
+    .option('-u, --url <url>', 'Platform URL')
+    .option('-n, --name <name>', 'Agent name')
+    .option('-t, --tags <tags>', 'Comma-separated tags')
+    .option('-j, --jobs <number>', 'Maximum concurrent jobs', '1')
+    .option('-c, --config <path>', 'Configuration file path')
+    .option('-y, --yes', 'Skip confirmation prompts')
+    .action(async (options) => {
+    try {
+        console.log('=== BuildHive Agent Registration ===\n');
+        let platformUrl = options.url;
+        let agentName = options.name;
+        let tags = options.tags ? options.tags.split(',').map((t) => t.trim()) : [];
+        let maxJobs = parseInt(options.jobs);
+        // Interactive prompts if options not provided
+        if (!options.yes) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'platformUrl',
+                    message: 'BuildHive Platform URL:',
+                    default: platformUrl || 'http://localhost:3001',
+                    when: !platformUrl,
+                },
+                {
+                    type: 'input',
+                    name: 'agentName',
+                    message: 'Agent name:',
+                    default: agentName || `agent-${os.hostname()}`,
+                    when: !agentName,
+                },
+                {
+                    type: 'input',
+                    name: 'tags',
+                    message: 'Tags (comma-separated):',
+                    default: tags.length > 0 ? tags.join(',') : 'docker,linux',
+                    when: tags.length === 0,
+                },
+                {
+                    type: 'number',
+                    name: 'maxJobs',
+                    message: 'Maximum concurrent jobs:',
+                    default: maxJobs || 1,
+                    when: !maxJobs,
+                },
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: 'Proceed with registration?',
+                    default: true,
+                },
+            ]);
+            if (answers.confirm === false) {
+                console.log('Registration cancelled.');
+                process.exit(0);
+            }
+            platformUrl = platformUrl || answers.platformUrl;
+            agentName = agentName || answers.agentName;
+            tags =
+                tags.length > 0
+                    ? tags
+                    : answers.tags.split(',').map((t) => t.trim());
+            maxJobs = maxJobs || answers.maxJobs;
+        }
+        // Perform registration
+        console.log('\nRegistering agent...');
+        const registration = new AgentRegistration(platformUrl);
+        const config = await registration.registerAgent({
+            platformUrl,
+            name: agentName,
+            tags,
+            maxConcurrentJobs: maxJobs,
+            configPath: options.config,
+        });
+        console.log('\n✓ Agent registered successfully!');
+        console.log(`  Agent ID: ${config.agentId}`);
+        console.log(`  Name: ${config.name}`);
+        console.log(`  Platform: ${config.platformUrl}`);
+        console.log(`  Config saved to: ${options.config ||
+            join(os.homedir(), '.buildhive', 'buildhive-agent.json')}`);
+        console.log('\nYou can now start the agent with: buildhive-agent start');
+    }
+    catch (error) {
+        console.error('\n✗ Registration failed:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+/**
+ * Start command - Start the agent
+ */
+program
+    .command('start')
+    .description('Start the BuildHive agent')
+    .option('-c, --config <path>', 'Configuration file path')
+    .option('-d, --daemon', 'Run as daemon (background process)')
+    .action(async (options) => {
+    try {
+        console.log('Starting BuildHive Agent...\n');
+        // Load configuration
+        const config = await loadConfig();
+        console.log(`Agent: ${config.name}`);
+        console.log(`Platform: ${config.platformUrl}\n`);
+        // Create PID file directory
+        const pidDir = join(os.homedir(), '.buildhive');
+        await fs.mkdir(pidDir, { recursive: true });
+        // Write PID file
+        const pidFile = join(pidDir, 'agent.pid');
+        await fs.writeFile(pidFile, process.pid.toString(), 'utf-8');
+        // Create and start agent
+        const agent = await BuildHiveAgent.create(config);
+        // Handle graceful shutdown
+        const shutdown = async (signal) => {
+            console.log(`\nReceived ${signal}, shutting down gracefully...`);
+            try {
+                await agent.stop();
+                // Remove PID file
+                try {
+                    await fs.unlink(pidFile);
+                }
+                catch (error) {
+                    logger.error('Failed to remove PID file:', error);
+                }
+                console.log('Agent stopped successfully');
+                process.exit(0);
+            }
+            catch (error) {
+                console.error('Error during shutdown:', error);
+                process.exit(1);
+            }
+        };
+        process.on('SIGINT', () => shutdown('SIGINT'));
+        process.on('SIGTERM', () => shutdown('SIGTERM'));
+        process.on('SIGQUIT', () => shutdown('SIGQUIT'));
+        // Handle uncaught exceptions
+        process.on('uncaughtException', (error) => {
+            logger.error('Uncaught exception:', error);
+            shutdown('uncaughtException').catch(() => process.exit(1));
+        });
+        process.on('unhandledRejection', (reason, promise) => {
+            logger.error('Unhandled rejection at:', promise, 'reason:', reason);
+            shutdown('unhandledRejection').catch(() => process.exit(1));
+        });
+        // Start the agent
+        await agent.start();
+        console.log('BuildHive Agent started successfully');
+        console.log(`PID: ${process.pid}`);
+        console.log('Press Ctrl+C to stop\n');
+        // Keep process alive
+        if (!options.daemon) {
+            setInterval(() => {
+                // Keep alive
+            }, 1000);
+        }
+    }
+    catch (error) {
+        console.error('\n✗ Failed to start agent:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+/**
+ * Stop command - Stop the agent (for daemon mode)
+ */
+program
+    .command('stop')
+    .description('Stop the BuildHive agent daemon')
+    .action(async () => {
+    try {
+        const pidFile = join(os.homedir(), '.buildhive', 'agent.pid');
+        // Check if PID file exists
+        try {
+            await fs.access(pidFile);
+        }
+        catch {
+            console.error('Agent is not running (PID file not found)');
+            process.exit(1);
+        }
+        // Read PID from file
+        const pidContent = await fs.readFile(pidFile, 'utf-8');
+        const pid = parseInt(pidContent.trim());
+        if (isNaN(pid)) {
+            console.error('Invalid PID file content');
+            await fs.unlink(pidFile); // Clean up invalid PID file
+            process.exit(1);
+        }
+        // Check if process exists
+        try {
+            process.kill(pid, 0); // Signal 0 checks if process exists
+        }
+        catch (error) {
+            if (error.code === 'ESRCH') {
+                console.log('Agent process not found, cleaning up PID file');
+                await fs.unlink(pidFile);
+                process.exit(0);
+            }
+            throw error;
+        }
+        // Send SIGTERM to gracefully stop the agent
+        console.log(`Stopping BuildHive Agent (PID: ${pid})...`);
+        process.kill(pid, 'SIGTERM');
+        // Wait for process to stop
+        let attempts = 0;
+        const maxAttempts = 30; // Wait up to 15 seconds
+        while (attempts < maxAttempts) {
+            try {
+                process.kill(pid, 0);
+                await new Promise(resolve => setTimeout(resolve, 500));
+                attempts++;
+            }
+            catch (error) {
+                if (error.code === 'ESRCH') {
+                    // Process stopped
+                    await fs.unlink(pidFile);
+                    console.log('✓ Agent stopped successfully');
+                    process.exit(0);
+                }
+            }
+        }
+        // If still running after timeout, force kill
+        console.warn('Agent did not stop gracefully, forcing shutdown...');
+        process.kill(pid, 'SIGKILL');
+        await fs.unlink(pidFile);
+        console.log('✓ Agent stopped (forced)');
+    }
+    catch (error) {
+        console.error('\n✗ Failed to stop agent:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+/**
+ * Status command - Show agent status
+ */
+program
+    .command('status')
+    .description('Show agent status')
+    .option('-c, --config <path>', 'Configuration file path')
+    .action(async (options) => {
+    try {
+        const config = await loadConfig();
+        console.log('=== BuildHive Agent Status ===\n');
+        console.log(`Name: ${config.name}`);
+        console.log(`Agent ID: ${config.agentId}`);
+        console.log(`Platform: ${config.platformUrl}`);
+        console.log(`Max Concurrent Jobs: ${config.maxConcurrentJobs}`);
+        console.log(`Tags: ${config.tags.join(', ')}`);
+        console.log('\nConfiguration:');
+        console.log(`  Heartbeat Interval: ${config.heartbeatInterval}s`);
+        console.log(`  Job Timeout: ${config.jobTimeoutMinutes}m`);
+        console.log(`  Log Level: ${config.logLevel}`);
+        console.log(`  Metrics Enabled: ${config.enableMetrics ? 'Yes' : 'No'}`);
+        // Check if agent is running
+        const pidFile = join(os.homedir(), '.buildhive', 'agent.pid');
+        let isRunning = false;
+        let pid = null;
+        try {
+            const pidContent = await fs.readFile(pidFile, 'utf-8');
+            pid = parseInt(pidContent.trim());
+            if (!isNaN(pid)) {
+                try {
+                    process.kill(pid, 0); // Check if process exists
+                    isRunning = true;
+                }
+                catch (error) {
+                    if (error.code === 'ESRCH') {
+                        // Process not found, clean up stale PID file
+                        await fs.unlink(pidFile);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // PID file doesn't exist or couldn't be read
+        }
+        console.log(`\nRunning: ${isRunning ? `Yes (PID: ${pid})` : 'No'}`);
+        if (!isRunning) {
+            console.log('\nTo start the agent, run: buildhive-agent start');
+        }
+    }
+    catch (error) {
+        console.error('\n✗ Failed to get status:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+/**
+ * Config command - Show or edit configuration
+ */
+program
+    .command('config')
+    .description('Show configuration')
+    .option('-c, --config <path>', 'Configuration file path')
+    .option('--show', 'Show full configuration (default)')
+    .action(async (options) => {
+    try {
+        const configPath = options.config ||
+            join(os.homedir(), '.buildhive', 'buildhive-agent.json');
+        // Check if config exists
+        try {
+            await fs.access(configPath);
+        }
+        catch {
+            console.error(`Configuration file not found: ${configPath}`);
+            console.log('\nRegister the agent first with: buildhive-agent register');
+            process.exit(1);
+        }
+        // Read and display config
+        const configContent = await fs.readFile(configPath, 'utf8');
+        const config = JSON.parse(configContent);
+        console.log('=== BuildHive Agent Configuration ===\n');
+        console.log(`Config file: ${configPath}\n`);
+        // Mask sensitive fields
+        const displayConfig = { ...config };
+        if (displayConfig.apiKey) {
+            displayConfig.apiKey = '****' + displayConfig.apiKey.slice(-4);
+        }
+        console.log(JSON.stringify(displayConfig, null, 2));
+    }
+    catch (error) {
+        console.error('\n✗ Failed to read configuration:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+/**
+ * Test command - Test connection to platform
+ */
+program
+    .command('test')
+    .description('Test connection to BuildHive platform')
+    .option('-c, --config <path>', 'Configuration file path')
+    .action(async (options) => {
+    try {
+        console.log('Testing connection to BuildHive platform...\n');
+        const config = await loadConfig();
+        const { BuildHiveApiClient } = await import('./registration/apiClient.js');
+        const apiClient = new BuildHiveApiClient(config.platformUrl);
+        const connected = await apiClient.testConnection();
+        if (connected) {
+            console.log('✓ Successfully connected to BuildHive platform');
+            console.log(`  URL: ${config.platformUrl}`);
+        }
+        else {
+            console.error('✗ Failed to connect to BuildHive platform');
+            console.error(`  URL: ${config.platformUrl}`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('\n✗ Connection test failed:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+/**
+ * Logs command - View agent logs
+ */
+program
+    .command('logs')
+    .description('View BuildHive agent logs')
+    .option('-f, --follow', 'Follow log output (like tail -f)')
+    .option('-n, --lines <number>', 'Number of lines to show', '50')
+    .action(async (options) => {
+    try {
+        const logFile = join(os.homedir(), '.buildhive', 'logs', 'buildhive-agent.log');
+        // Check if log file exists
+        try {
+            await fs.access(logFile);
+        }
+        catch {
+            console.error(`Log file not found: ${logFile}`);
+            console.log('\nThe agent may not have been started yet.');
+            process.exit(1);
+        }
+        const numLines = parseInt(options.lines);
+        if (options.follow) {
+            // Follow mode: Use tail -f equivalent
+            console.log(`Following logs from: ${logFile}`);
+            console.log('Press Ctrl+C to stop\n');
+            const { spawn } = await import('child_process');
+            const tail = spawn('tail', ['-f', '-n', numLines.toString(), logFile]);
+            tail.stdout.on('data', (data) => {
+                process.stdout.write(data);
+            });
+            tail.stderr.on('data', (data) => {
+                process.stderr.write(data);
+            });
+            tail.on('close', (code) => {
+                process.exit(code || 0);
+            });
+            // Handle Ctrl+C
+            process.on('SIGINT', () => {
+                tail.kill();
+                process.exit(0);
+            });
+        }
+        else {
+            // Show last N lines
+            const logContent = await fs.readFile(logFile, 'utf-8');
+            const lines = logContent.split('\n');
+            const displayLines = lines.slice(-numLines);
+            console.log(`Last ${numLines} lines from: ${logFile}\n`);
+            displayLines.forEach(line => {
+                if (line.trim()) {
+                    console.log(line);
+                }
+            });
+        }
+    }
+    catch (error) {
+        console.error('\n✗ Failed to read logs:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+/**
+ * Doctor command — comprehensive health check for agent readiness
+ */
+program
+    .command('doctor')
+    .description('Run diagnostic checks on the agent environment')
+    .action(async () => {
+    console.log('BuildHive Agent Doctor\n');
+    console.log('Running diagnostic checks...\n');
+    const checks = [];
+    // 1. Node.js version
+    const nodeVersion = process.versions.node;
+    const nodeMajor = parseInt(nodeVersion.split('.')[0]);
+    checks.push({
+        name: 'Node.js version',
+        status: nodeMajor >= 18 ? 'pass' : 'fail',
+        detail: nodeMajor >= 18 ? `v${nodeVersion} (>= 18 required)` : `v${nodeVersion} — upgrade to >= 18`,
+    });
+    // 2. Docker installed
+    let dockerVersion = '';
+    try {
+        const { execSync } = await import('child_process');
+        dockerVersion = execSync('docker --version', { timeout: 5000 }).toString().trim();
+        checks.push({ name: 'Docker installed', status: 'pass', detail: dockerVersion });
+    }
+    catch {
+        checks.push({ name: 'Docker installed', status: 'fail', detail: 'Docker not found. Install: https://docs.docker.com/get-docker/' });
+    }
+    // 3. Docker daemon running
+    if (dockerVersion) {
+        try {
+            const { execSync } = await import('child_process');
+            execSync('docker info', { timeout: 10000, stdio: 'pipe' });
+            checks.push({ name: 'Docker daemon running', status: 'pass', detail: 'Docker daemon is responsive' });
+        }
+        catch {
+            checks.push({ name: 'Docker daemon running', status: 'fail', detail: 'Docker daemon not running. Start Docker Desktop or run: sudo systemctl start docker' });
+        }
+    }
+    // 4. Config file exists
+    let configLoaded = false;
+    try {
+        const config = await loadConfig();
+        configLoaded = true;
+        checks.push({ name: 'Config file', status: 'pass', detail: `Loaded — agent: ${config.name || config.agentId}` });
+        // 5. Platform URL reachable
+        try {
+            const { default: axios } = await import('axios');
+            const resp = await axios.get(`${config.platformUrl}/health/live`, { timeout: 5000 });
+            checks.push({ name: 'Platform connectivity', status: 'pass', detail: `${config.platformUrl} — ${resp.data?.status || 'OK'}` });
+        }
+        catch (err) {
+            checks.push({ name: 'Platform connectivity', status: 'fail', detail: `Cannot reach ${config.platformUrl} — ${err.code || err.message}` });
+        }
+        // 6. API key configured
+        if (config.apiKey && config.apiKey.length > 10) {
+            checks.push({ name: 'API key configured', status: 'pass', detail: `Key: ****${config.apiKey.slice(-4)}` });
+        }
+        else {
+            checks.push({ name: 'API key configured', status: 'fail', detail: 'No API key. Run: buildhive-agent init' });
+        }
+        // 7. Agent ID set
+        if (config.agentId) {
+            checks.push({ name: 'Agent ID', status: 'pass', detail: config.agentId });
+        }
+        else {
+            checks.push({ name: 'Agent ID', status: 'fail', detail: 'No agent ID. Run: buildhive-agent register' });
+        }
+    }
+    catch {
+        checks.push({ name: 'Config file', status: 'fail', detail: 'No config found. Run: buildhive-agent init' });
+    }
+    // 8. Disk space
+    try {
+        const si = await import('systeminformation');
+        const disks = await si.fsSize();
+        const rootDisk = disks.find(d => d.mount === '/' || d.mount === 'C:\\') || disks[0];
+        if (rootDisk) {
+            const freeGB = rootDisk.available / (1024 ** 3);
+            checks.push({
+                name: 'Disk space',
+                status: freeGB > 10 ? 'pass' : freeGB > 5 ? 'warn' : 'fail',
+                detail: `${freeGB.toFixed(1)} GB free${freeGB < 10 ? ' (recommend > 10 GB)' : ''}`,
+            });
+        }
+    }
+    catch {
+        checks.push({ name: 'Disk space', status: 'warn', detail: 'Could not check disk space' });
+    }
+    // 9. Memory
+    const totalMemGB = os.totalmem() / (1024 ** 3);
+    const freeMemGB = os.freemem() / (1024 ** 3);
+    checks.push({
+        name: 'Memory',
+        status: freeMemGB > 2 ? 'pass' : freeMemGB > 1 ? 'warn' : 'fail',
+        detail: `${freeMemGB.toFixed(1)} GB free / ${totalMemGB.toFixed(1)} GB total`,
+    });
+    // 10. Log directory writable
+    try {
+        const logDir = join(os.homedir(), '.buildhive', 'logs');
+        await fs.mkdir(logDir, { recursive: true });
+        const testFile = join(logDir, '.doctor-test');
+        await fs.writeFile(testFile, 'test', 'utf-8');
+        await fs.unlink(testFile);
+        checks.push({ name: 'Log directory', status: 'pass', detail: logDir });
+    }
+    catch {
+        checks.push({ name: 'Log directory', status: 'fail', detail: 'Cannot write to ~/.buildhive/logs/' });
+    }
+    // 11. Agent already running?
+    try {
+        const pidFile = join(os.homedir(), '.buildhive', 'agent.pid');
+        const pidContent = await fs.readFile(pidFile, 'utf-8');
+        const pid = parseInt(pidContent.trim());
+        try {
+            process.kill(pid, 0);
+            checks.push({ name: 'Agent process', status: 'pass', detail: `Running (PID ${pid})` });
+        }
+        catch {
+            checks.push({ name: 'Agent process', status: 'warn', detail: `Stale PID file (PID ${pid} not found)` });
+        }
+    }
+    catch {
+        checks.push({ name: 'Agent process', status: 'warn', detail: 'Not running' });
+    }
+    // 12. SDK detection
+    try {
+        const { execSync } = await import('child_process');
+        const sdks = [];
+        const trySDK = (cmd, name) => {
+            try {
+                execSync(`${cmd} --version`, { timeout: 3000, stdio: 'pipe' });
+                sdks.push(name);
+            }
+            catch { /* skip */ }
+        };
+        trySDK('node', 'Node.js');
+        trySDK('java', 'Java');
+        trySDK('python3', 'Python');
+        trySDK('go', 'Go');
+        trySDK('rustc', 'Rust');
+        trySDK('dotnet', '.NET');
+        trySDK('gradle', 'Gradle');
+        trySDK('mvn', 'Maven');
+        checks.push({ name: 'SDKs detected', status: sdks.length > 0 ? 'pass' : 'warn', detail: sdks.join(', ') || 'None' });
+    }
+    catch {
+        checks.push({ name: 'SDKs detected', status: 'warn', detail: 'Could not detect SDKs' });
+    }
+    // --- Print results ---
+    const icons = { pass: '✓', fail: '✗', warn: '!' };
+    const colors = { pass: '\x1b[32m', fail: '\x1b[31m', warn: '\x1b[33m' };
+    const reset = '\x1b[0m';
+    let failures = 0;
+    let warnings = 0;
+    for (const check of checks) {
+        const icon = icons[check.status];
+        const color = colors[check.status];
+        console.log(`  ${color}${icon}${reset} ${check.name}: ${check.detail}`);
+        if (check.status === 'fail')
+            failures++;
+        if (check.status === 'warn')
+            warnings++;
+    }
+    console.log('');
+    if (failures === 0 && warnings === 0) {
+        console.log('\x1b[32m✓ All checks passed — agent is ready to run!\x1b[0m');
+    }
+    else if (failures === 0) {
+        console.log(`\x1b[33m! ${warnings} warning(s) — agent can run but review above.\x1b[0m`);
+    }
+    else {
+        console.log(`\x1b[31m✗ ${failures} check(s) failed — fix before starting agent.\x1b[0m`);
+    }
+    process.exit(failures > 0 ? 1 : 0);
+});
+// Parse command line arguments
+program.parse();
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}
+//# sourceMappingURL=cli.js.map