vaultace-cli/src/commands/server.js

AI-powered security scanner that detects vulnerabilities in AI-generated code. Proactive scanning, autonomous fixing, and emergency response for modern development teams.

/**
 * Server Command - Local development server for testing backend integration
 */

const { Command } = require('commander')
const chalk = require('chalk')
const ora = require('ora')
const { getAPIClient } = require('../services/api-client')
const logger = require('../utils/logger')

const serverCommand = new Command('server')
  .description('🌐 Local development and testing utilities')

// Test connection to your FastAPI backend
serverCommand
  .command('test')
  .description('Test connection to Vaultace API')
  .option('--api-url <url>', 'API endpoint to test', 'https://api.vaultace.co')
  .action(async (options) => {
    const spinner = ora('Testing connection to Vaultace API...').start()

    try {
      const apiClient = getAPIClient({ baseURL: options.apiUrl })

      // Test health endpoint
      const healthResult = await apiClient.healthCheck()

      if (healthResult.success) {
        spinner.succeed('API connection successful')
        console.log(chalk.green('\n✅ Vaultace API Health Check'))
        console.log(`Endpoint: ${options.apiUrl}`)
        console.log(`Status: ${healthResult.data.status}`)

        if (healthResult.data.version) {
          console.log(`Version: ${healthResult.data.version}`)
        }

        if (healthResult.data.timestamp) {
          console.log(`Server Time: ${healthResult.data.timestamp}`)
        }
      } else {
        spinner.fail('API connection failed')
        console.error(chalk.red(`\n❌ Connection Error: ${healthResult.error}`))
        process.exit(1)
      }

    } catch (error) {
      spinner.fail('API connection failed')
      logger.error('API test error:', error)
      console.error(chalk.red(`\nError: ${error.message}`))
      process.exit(1)
    }
  })

// Test authentication flow
serverCommand
  .command('auth-test')
  .description('Test authentication flow')
  .option('--api-url <url>', 'API endpoint to test')
  .action(async (options) => {
    const spinner = ora('Testing authentication flow...').start()

    try {
      const apiClient = getAPIClient(options.apiUrl ? { baseURL: options.apiUrl } : {})

      // Check if already authenticated
      if (apiClient.isAuthenticated()) {
        spinner.succeed('Already authenticated')

        // Test authenticated endpoint
        const userResult = await apiClient.getCurrentUser()

        if (userResult.success) {
          console.log(chalk.green('\n✅ Authentication Valid'))
          console.log(`User: ${userResult.user.email}`)
          console.log(`Role: ${userResult.user.role}`)
        } else {
          console.log(chalk.yellow('\n⚠️  Authentication token invalid'))
          console.log('Please login again with: vaultace auth login')
        }
      } else {
        spinner.succeed('No active authentication')
        console.log(chalk.yellow('\n⚠️  Not authenticated'))
        console.log('Login with: vaultace auth login')
      }

    } catch (error) {
      spinner.fail('Authentication test failed')
      logger.error('Auth test error:', error)
      console.error(chalk.red(`\nError: ${error.message}`))
      process.exit(1)
    }
  })

// Test AI intelligence endpoints
serverCommand
  .command('intelligence-test')
  .description('Test AI intelligence endpoints')
  .option('--api-url <url>', 'API endpoint to test')
  .action(async (options) => {
    const spinner = ora('Testing AI intelligence endpoints...').start()

    try {
      const apiClient = getAPIClient(options.apiUrl ? { baseURL: options.apiUrl } : {})

      if (!apiClient.isAuthenticated()) {
        spinner.fail('Authentication required')
        console.log(chalk.yellow('Please login first: vaultace auth login'))
        process.exit(1)
      }

      // Test vulnerability analysis
      const testVulnData = {
        vulnerability_id: 'test-vuln-001',
        threat_category: 'vibe_coding',
        severity: 'medium',
        context: 'Testing AI intelligence integration'
      }

      const analysisResult = await apiClient.analyzeVulnerability(testVulnData)

      if (analysisResult.success) {
        spinner.succeed('AI intelligence endpoints working')
        console.log(chalk.green('\n✅ AI Intelligence Test Successful'))
        console.log('Risk assessment capabilities are operational')
      } else {
        spinner.warn('AI intelligence endpoints not fully operational')
        console.log(chalk.yellow('\n⚠️  Some intelligence features may not be available'))
        console.log(`Details: ${analysisResult.error}`)
      }

    } catch (error) {
      spinner.fail('Intelligence test failed')
      logger.error('Intelligence test error:', error)
      console.error(chalk.red(`\nError: ${error.message}`))
    }
  })

// Development info
serverCommand
  .command('info')
  .description('Show development environment info')
  .action(async () => {
    console.log(chalk.bold.cyan('\n🔧 Vaultace Development Environment\n'))

    const apiClient = getAPIClient()
    const config = apiClient.config

    console.log('CLI Configuration:')
    console.log(`  API Endpoint: ${apiClient.baseURL}`)
    console.log(`  Config Path: ${config.path}`)
    console.log(`  Authenticated: ${apiClient.isAuthenticated() ? '✅' : '❌'}`)

    if (apiClient.isAuthenticated()) {
      const authData = config.get('auth')
      console.log(`  User: ${authData.user?.email || 'Unknown'}`)
      console.log(`  Login Time: ${authData.loginTime || 'Unknown'}`)
    }

    console.log('\nBackend Integration:')
    console.log('  FastAPI Backend: AWS Lambda')
    console.log('  Database: PostgreSQL + Redis')
    console.log('  AI Models: GPT-4, Claude, Custom Risk Models')
    console.log('  Security Features: FAIR Risk Engine, GBM Simulation')

    console.log(chalk.blue('\nQuick Commands:'))
    console.log('  vaultace server test              # Test API connection')
    console.log('  vaultace intelligence vibe-coding # Test AI risk assessment')
    console.log('  vaultace scan --remote            # Test full integration')
  })

module.exports = serverCommand