cli.ts

#!/usr/bin/env node

import { program } from 'commander';
import {
  checkAction,
  configBackupAction,
  configGetAction,
  configListAction,
  configMigrateAction,
  configRestoreAction,
  configSetAction,
  configValidateAction,
  copyAction,
  delAction,
  editAction,
  exportAction,
  getAction,
  initAction,
  listAction,
  migrateAction,
  setAction,
  showAction,
  templateAction,
} from './commands';

import { info, LogTag, verbose, warn } from './utils/logger';

const version = '0.1.0';

// Set up the main program
program
  .name('envg')
  .description('Local-first secret management for developers')
  .version(version)
  .option('-v, --verbose', 'Enable verbose logging')
  .hook('preAction', (thisCommand) => {
    const options: { verbose?: boolean } = thisCommand.opts();
    verbose(
      options.verbose === true,
      LogTag.LOG,
      `[EnvGuard v${version}] Running command: ${thisCommand.name()}`
    );
  });

// Init command
program
  .command('init')
  .description('Initialize EnvGuard in the current directory')
  .option(
    '-t, --template <path>',
    'Path to template file (relative or absolute)'
  )
  .option('-p, --package <name>', 'Package name (skips auto-detection)')
  .option('-f, --force', 'Reinitialize if already initialized')
  .action(async (options) => {
    await initAction(options);
  });

/**
 * Store a secret in the OS keychain
 * @command set <key> <value>
 * @param key - The key of the secret to store
 * @param value - The value of the secret to store
 * @option -v, --verbose - Enable verbose logging
 * @option -o, --optional - Mark this secret as optional (default: required)
 * @example
 * ```bash
 * envg set API_KEY abc123 --verbose
 * envg set OPTIONAL_KEY value --optional
 * ```
 * @remarks
 * This command stores a secret in the OS keychain using the package name from config.
 * By default, secrets are marked as required. Use --optional to mark them as optional.
 *
 * @see {@link SystemKeychain} for the underlying keychain implementation.
 */
program
  .command('set <key> <value>')
  .description('Store a secret in the OS keychain')
  .option('-v, --verbose', 'Enable verbose logging', false)
  .option(
    '-o, --optional',
    'Mark this secret as optional (default: required)',
    false
  )
  .option('-e, --env <environment>', 'Environment name (default: development)')
  .action(
    async (
      key: string,
      value: string,
      options: { verbose?: boolean; optional?: boolean; env?: string }
    ) => {
      await setAction(key, value, options);
    }
  );

/**
 * Retrieve a secret from the OS keychain
 * @command get <key>
 * @param key - The key of the secret to retrieve
 * @option -v, --verbose - Enable verbose logging
 * @option -df, --defaultFallback <value> - Default value if secret not found
 * @example
 * ```bash
 * envg get API_KEY --verbose --defaultFallback "default_value"
 * ```
 * @remarks
 * This command retrieves a secret stored in the OS keychain using the package name from config.
 * If the secret is not found, it can return a default fallback value if provided.
 *
 * @see {@link SystemKeychain} for the underlying keychain implementation.
 */
program
  .command('get <key>')
  .description('Retrieve a secret from the OS keychain')
  .option('-v, --verbose', 'Enable verbose logging', false)
  .option('-df, --defaultFallback <value>', 'Default value if secret not found')
  .option('-e, --env <environment>', 'Environment name (default: development)')
  .action(
    async (
      key: string,
      options: { verbose?: boolean; defaultFallback?: unknown; env?: string }
    ) => {
      await getAction(key, options);
    }
  );

program
  .command('del <key>')
  .description('Delete a secret from the OS keychain')
  .option('-v, --verbose', 'Enable verbose logging', false)
  .option('-e, --env <environment>', 'Environment name (default: development)')
  .action(async (key: string, options: { verbose?: boolean; env?: string }) => {
    await delAction(key, options);
  });

program
  .command('list')
  .description('List all stored secrets (keys only)')
  .option('-v, --verbose', 'Enable verbose logging', false)
  .action(async (options: { verbose: boolean }) => {
    await listAction(options);
  });

program
  .command('check')
  .description('Check secrets and security issues')
  .option('-v, --verbose', 'Enable verbose logging', false)
  .option('--secrets', 'Only check secrets')
  .option('--security', 'Only check security issues')
  .action(
    async (options: {
      verbose?: boolean;
      secrets?: boolean;
      security?: boolean;
    }) => {
      await checkAction(options);
    }
  );

program
  .command('migrate')
  .description('Migrate from .env files to EnvGuard')
  .option('-v, --verbose', 'Enable verbose logging', false)
  .option('--auto', 'Auto-accept all prompts')
  .option('--keep-files', 'Keep .env files after migration')
  .option('--from <file>', 'Migrate from specific file')
  .action(
    async (options: {
      verbose?: boolean;
      auto?: boolean;
      keepFiles?: boolean;
      from?: string;
    }) => {
      await migrateAction(options);
    }
  );

program
  .command('export')
  .description('Export secrets to .env file (INSECURE)')
  .option('-v, --verbose', 'Enable verbose logging', false)
  .option('--unsafe', 'Confirm you understand the security risks', false)
  .option('--to <file>', 'Output filename', '.env')
  .option('-e, --env <environment>', 'Environment to export')
  .action(
    async (options: {
      verbose?: boolean;
      unsafe?: boolean;
      to?: string;
      env?: string;
    }) => {
      await exportAction(options);
    }
  );

program
  .command('template')
  .description('Generate .env.template from current secrets')
  .option('-v, --verbose', 'Enable verbose logging', false)
  .option('-f, --force', 'Overwrite existing template')
  .action(async (options: { verbose?: boolean; force?: boolean }) => {
    await templateAction(options);
  });

program
  .command('edit [key]')
  .description('Edit secrets interactively')
  .option('-v, --verbose', 'Enable verbose logging', false)
  .option('-e, --env <environment>', 'Environment name')
  .option('--add', 'Add new secret')
  .action(
    async (
      key: string | undefined,
      options: { verbose?: boolean; env?: string; add?: boolean }
    ) => {
      await editAction(key, options);
    }
  );

program
  .command('show <key>')
  .description('Show secret value (masked by default)')
  .option('-v, --verbose', 'Enable verbose logging', false)
  .option('-e, --env <environment>', 'Environment name')
  .option('--reveal', 'Show actual value (unmasked)')
  .action(
    async (
      key: string,
      options: { verbose?: boolean; env?: string; reveal?: boolean }
    ) => {
      await showAction(key, options);
    }
  );

program
  .command('copy [key]')
  .description('Copy secrets between environments')
  .requiredOption('--from <environment>', 'Source environment')
  .requiredOption('--to <environment>', 'Destination environment')
  .option('-v, --verbose', 'Enable verbose logging', false)
  .option('-f, --force', 'Overwrite existing secrets')
  .action(
    async (
      key: string | undefined,
      options: { from: string; to: string; verbose?: boolean; force?: boolean }
    ) => {
      await copyAction(key, options);
    }
  );

// Config command with subcommands
const configCommand = program
  .command('config')
  .description('Manage EnvGuard configuration');

configCommand
  .command('get <key>')
  .description('Get a config value (supports dot notation)')
  .option('-v, --verbose', 'Enable verbose logging', false)
  .action(async (key: string, options) => {
    await configGetAction(key, options);
  });

configCommand
  .command('set <key> <value>')
  .description('Set a config value (supports dot notation)')
  .option('-v, --verbose', 'Enable verbose logging', false)
  .action(async (key: string, value: string, options) => {
    await configSetAction(key, value, options);
  });

configCommand
  .command('list')
  .description('List all config values')
  .option('-v, --verbose', 'Enable verbose logging', false)
  .action(async (options) => {
    await configListAction(options);
  });

configCommand
  .command('validate')
  .description('Validate current config')
  .option('-v, --verbose', 'Enable verbose logging', false)
  .action(async (options) => {
    await configValidateAction(options);
  });

configCommand
  .command('backup')
  .description('Backup current config')
  .option('-o, --output <path>', 'Output path for backup file')
  .option('-v, --verbose', 'Enable verbose logging', false)
  .action(async (options) => {
    await configBackupAction(options);
  });

configCommand
  .command('restore <file>')
  .description('Restore config from backup')
  .option('-v, --verbose', 'Enable verbose logging', false)
  .action(async (file: string, options) => {
    await configRestoreAction(file, options);
  });

configCommand
  .command('migrate')
  .description('Migrate config from v1 to v2')
  .option('--no-backup', 'Skip creating backup before migration')
  .option('-v, --verbose', 'Enable verbose logging', false)
  .action(async (options) => {
    await configMigrateAction(options);
  });

program
  .command('status')
  .description('Show current EnvGuard status and configuration')
  .action(() => {
    info('EnvGuard Status');
    info(`Version: ${version}`);
    info(`Node.js: ${process.version}`);
    info(`Platform: ${process.platform} ${process.arch}`);
    warn('Full functionality coming soon.');

    info('');
    info('Implementation Progress:');
    info('  • Keychain integration (in progress)');
    info('  • CLI commands');
    info('  • Config validation');
    info('  • Runtime runners');
  });

// Add help examples
program.addHelpText(
  'after',
  `
Examples:
  $ envg status                            Show current status
  $ envg init                              Initialize in current directory
  $ envg set API_KEY abc123                Store a secret in default environment (development)
  $ envg set API_KEY xyz789 --env prod     Store a secret in production environment
  $ envg get API_KEY                       Retrieve a secret from development
  $ envg get API_KEY --env production      Retrieve from production environment
  $ envg del API_KEY --env staging         Delete from staging environment
  $ envg list                              List all secrets

Environment Support:
  Use --env to specify environment (development, staging, production, etc.)
  Default environment is 'development' if not specified.

Documentation:
  Visit https://github.com/amannirala13/envguard for full documentation,
  guides, and examples.
`
);

// Parse CLI arguments
program.parse(process.argv);

// Show help if no arguments provided
if (process.argv.slice(2).length === 0) {
  program.outputHelp();
}