optimus-init/src/cli.ts

Initialization utility for Optimus Security

#!/usr/bin/env node

import { program } from 'commander';
import chalk from 'chalk';
import { OptimusAuth } from './auth';
import * as fs from 'fs';
import * as path from 'path';
import * as os from 'os';
import { execSync } from 'child_process';

// Define program version and description
program
  .version('1.0.5')
  .description('Optimus Security Initialization Tool');

// Get command - make a GET request to any endpoint
program
  .command('get <endpoint>')
  .description('Make an authenticated GET request to any endpoint')
  .option('-e, --env <path>', 'Path to optimus.env file', './optimus.env')
  .option('-u, --url <url>', 'Base URL for the API (optional, will use OPTIMUS_ENDPOINT from env file)')
  .option('-p, --params <params>', 'Query parameters in JSON format', '{}')
  .option('-o, --output <file>', 'Save response to file instead of displaying')
  .action(async (endpoint, options) => {
    try {
      const auth = new OptimusAuth(options.env, options.url);
      const params = JSON.parse(options.params);
      
      console.log(chalk.blue(`Making authenticated GET request to ${endpoint}...`));
      const response = await auth.get(endpoint, params);
      
      if (options.output) {
        fs.writeFileSync(options.output, JSON.stringify(response, null, 2));
        console.log(chalk.green(`Response saved to ${options.output}`));
      } else {
        console.log(chalk.green('Response:'));
        
        // Output the response as-is, let the shell handle formatting
        const responseStr = typeof response === 'string' ? response : JSON.stringify(response, null, 2);
        console.log(responseStr);
      }
    } catch (err) {
      console.error(chalk.red('Error:'), err);
      process.exit(1);
    }
  });

// Check command - check if this is a Unix-like system with tr available
program
  .command('is-unix')
  .description('Check if this is a Unix-like system with tr available and output true/false')
  .action(() => {
    try {
      const platform = os.platform();
      
      // Check if we're on a Unix-like system and tr is available
      const isUnixLike = ['darwin', 'linux', 'freebsd', 'openbsd'].includes(platform);
      let trAvailable = false;
      
      if (isUnixLike) {
        try {
          execSync('which tr', { stdio: 'ignore' });
          trAvailable = true;
        } catch (err) {
          // tr not available
        }
      }
      
      // Set exit code without exiting: 0 for true, 1 for false
      // On Windows, we'll use Node.js replacement instead of tr
      process.exitCode = trAvailable ? 0 : 1;
    } catch (err) {
      process.exitCode = 1;
    }
  });

// Post command - make a POST request to any endpoint
program
  .command('post <endpoint>')
  .description('Make an authenticated POST request to any endpoint')
  .option('-e, --env <path>', 'Path to optimus.env file', './optimus.env')
  .option('-u, --url <url>', 'Base URL for the API (optional, will use OPTIMUS_ENDPOINT from env file)')
  .option('-d, --data <data>', 'Request body in JSON format', '{}')
  .option('-o, --output <file>', 'Save response to file instead of displaying')
  .action(async (endpoint, options) => {
    try {
      const auth = new OptimusAuth(options.env, options.url);
      const data = JSON.parse(options.data);
      
      console.log(chalk.blue(`Making authenticated POST request to ${endpoint}...`));
      const response = await auth.post(endpoint, data);
      
      if (options.output) {
        fs.writeFileSync(options.output, JSON.stringify(response, null, 2));
        console.log(chalk.green(`Response saved to ${options.output}`));
      } else {
        console.log(chalk.green('Response:'));
        console.log(JSON.stringify(response, null, 2));
      }
    } catch (err) {
      console.error(chalk.red('Error:'), err);
      process.exit(1);
    }
  });

// Download command - download a file from any endpoint
program
  .command('download <endpoint> <outputPath>')
  .description('Download a file from an authenticated endpoint')
  .option('-e, --env <path>', 'Path to optimus.env file', './optimus.env')
  .option('-u, --url <url>', 'Base URL for the API (optional, will use OPTIMUS_ENDPOINT from env file)')
  .option('-p, --params <params>', 'Query parameters in JSON format', '{}')
  .action(async (endpoint, outputPath, options) => {
    try {
      const auth = new OptimusAuth(options.env, options.url);
      const params = JSON.parse(options.params);
      
      console.log(chalk.blue(`Downloading from ${endpoint} to ${outputPath}...`));
      await auth.downloadFile(endpoint, outputPath, params);
      console.log(chalk.green('Download complete!'));
    } catch (err) {
      console.error(chalk.red('Error:'), err);
      process.exit(1);
    }
  });

// Init command - initialize Optimus Security configuration
// This is the main command for setting up Optimus Security
program
  .command('init')
  .description('Initialize Optimus Security configuration')
  .option('-e, --env <path>', 'Path to optimus.env file', './optimus.env')
  .option('-u, --url <url>', 'Base URL for the API (optional, will use OPTIMUS_ENDPOINT from env file)')
  .option('-d, --dir <dir>', 'Directory to store config files', './.cursor')
  .action(async (options) => {
    try {
      console.log(chalk.blue('Initializing Optimus Security...'));
      
      const auth = new OptimusAuth(options.env, options.url);
      const cursorDir = options.dir;
      
      // Get server version
      console.log(chalk.blue('Checking server version...'));
      const versionData = await auth.get('/api/mcp/version/');
      console.log(chalk.green(`Server version: ${versionData.version}`));
      
      // Check local version
      let localVersion = '0';
      const mcpJsonPath = path.join(cursorDir, 'mcp.json');
      
      if (fs.existsSync(mcpJsonPath)) {
        try {
          const mcpConfig = JSON.parse(fs.readFileSync(mcpJsonPath, 'utf8'));
          localVersion = mcpConfig?.optimus_config?.version || '0';
          console.log(chalk.blue(`Local version: ${localVersion}`));
        } catch (err) {
          console.log(chalk.yellow('Error reading local version, will re-initialize'));
        }
      }
      
      // Compare versions and initialize if needed
      const needsInit = !fs.existsSync(mcpJsonPath) || parseFloat(localVersion) < parseFloat(versionData.version);
      
      if (needsInit) {
        console.log(chalk.green('Downloading configuration files...'));
        
        // Create cursor directory if needed
        if (!fs.existsSync(cursorDir)) {
          fs.mkdirSync(cursorDir, { recursive: true });
        }
        
        // Get git username
        let username;
        try {
          username = execSync('git config user.name').toString().trim();
        } catch (err) {
          username = 'unknown';
          console.warn(chalk.yellow('Warning: Could not get git username, using "unknown"'));
        }
        
        // Download all required files with consistent timestamp
        const timestamp = Math.floor(Date.now() / 1000).toString();
        
        await auth.downloadFileWithTimestamp(
          '/api/mcp/mcp.json',
          path.join(cursorDir, 'mcp.json'),
          { username },
          timestamp
        );
        console.log(chalk.green('✓ Downloaded mcp.json'));
        
        await auth.downloadFileWithTimestamp(
          '/api/mcp/chat-formatting.mdc',
          path.join(cursorDir, 'chat-formatting.md'),
          {},
          timestamp
        );
        console.log(chalk.green('✓ Downloaded chat-formatting.md'));
        
        await auth.downloadFileWithTimestamp(
          '/api/mcp/mcp_rules.md',
          path.join(cursorDir, 'mcp_rules.md'),
          {},
          timestamp
        );
        console.log(chalk.green('✓ Downloaded mcp_rules.md'));
        
        console.log(chalk.green('\nOptimus Security has been successfully initialized.'));
      } else {
        console.log(chalk.green('Optimus Security is up to date.'));
      }
    } catch (err) {
      console.error(chalk.red('Error:'), err);
      process.exit(1);
    }
  });

// Parse command line arguments
program.parse(process.argv);

// If no arguments, display help
if (!process.argv.slice(2).length) {
  program.outputHelp();
}