@build-astron-co/nimbus 0.2.0

package/src/commands/azure/vm.ts

@@ -0,0 +1,355 @@
+/**
+ * Azure Virtual Machine CLI Commands
+ *
+ * Operations for Azure VMs
+ */
+
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { logger } from '../../utils';
+import { ui } from '../../wizard/ui';
+import {
+  loadSafetyPolicy,
+  evaluateSafety,
+  type SafetyContext,
+  type SafetyCheckResult,
+} from '../../config/safety-policy';
+import { promptForApproval, displaySafetySummary } from '../../wizard/approval';
+import type { AzureCommandOptions } from './index';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Run VM safety checks
+ */
+async function runVmSafetyChecks(
+  action: string,
+  vmName: string,
+  options: AzureCommandOptions
+): Promise<SafetyCheckResult> {
+  const safetyPolicy = loadSafetyPolicy();
+
+  const context: SafetyContext = {
+    operation: action,
+    type: 'azure',
+    environment: options.subscription || 'default',
+    resources: [vmName],
+    metadata: {
+      resourceType: 'virtual-machine',
+      resourceGroup: options.resourceGroup,
+    },
+  };
+
+  return evaluateSafety(context, safetyPolicy);
+}
+
+/**
+ * Main VM command router
+ */
+export async function vmCommand(
+  action: string,
+  args: string[],
+  options: AzureCommandOptions
+): Promise<void> {
+  logger.info('Running Azure VM command', { action, args, options });
+
+  switch (action) {
+    case 'list':
+      await listVms(options);
+      break;
+
+    case 'show':
+      if (!args[0]) {
+        ui.error('VM name required');
+        return;
+      }
+      await showVm(args[0], options);
+      break;
+
+    case 'start':
+      if (!args[0]) {
+        ui.error('VM name required');
+        return;
+      }
+      await startVm(args[0], options);
+      break;
+
+    case 'stop':
+      if (!args[0]) {
+        ui.error('VM name required');
+        return;
+      }
+      await stopVm(args[0], options);
+      break;
+
+    case 'delete':
+      if (!args[0]) {
+        ui.error('VM name required');
+        return;
+      }
+      await deleteVm(args[0], options);
+      break;
+
+    default:
+      showVmHelp();
+      break;
+  }
+}
+
+/**
+ * List VMs
+ */
+async function listVms(options: AzureCommandOptions): Promise<void> {
+  ui.header('Azure Virtual Machines');
+  ui.newLine();
+
+  const azArgs = ['vm', 'list', '-o', 'json'];
+  if (options.subscription) {
+    azArgs.push('--subscription', options.subscription);
+  }
+  if (options.resourceGroup) {
+    azArgs.push('-g', options.resourceGroup);
+  }
+
+  try {
+    ui.startSpinner({ message: 'Fetching VMs...' });
+    const { stdout } = await execFileAsync('az', azArgs);
+    ui.stopSpinnerSuccess('VMs fetched');
+
+    const vms = JSON.parse(stdout || '[]');
+
+    if (vms.length === 0) {
+      ui.info('No VMs found');
+      return;
+    }
+
+    ui.print(`Found ${vms.length} VM(s)\n`);
+
+    // Display table
+    ui.print(
+      ui.color(
+        `${
+          'Name'.padEnd(25) +
+          'Resource Group'.padEnd(25) +
+          'Location'.padEnd(15) +
+          'VM Size'.padEnd(20)
+        }Status`,
+        'cyan'
+      )
+    );
+    ui.print('─'.repeat(100));
+
+    for (const vm of vms) {
+      const name = vm.name?.substring(0, 24) || '';
+      const rg = vm.resourceGroup?.substring(0, 24) || '';
+      const location = vm.location?.substring(0, 14) || '';
+      const size = vm.hardwareProfile?.vmSize?.substring(0, 19) || '';
+      const status = vm.provisioningState || '';
+
+      const statusColor =
+        status === 'Succeeded'
+          ? 'green'
+          : status === 'Failed'
+            ? 'red'
+            : status === 'Updating'
+              ? 'yellow'
+              : 'white';
+
+      ui.print(
+        `${name.padEnd(25)}${rg.padEnd(25)}${location.padEnd(15)}${size.padEnd(20)}${ui.color(status, statusColor as 'green' | 'red' | 'yellow' | 'white')}`
+      );
+    }
+  } catch (error: unknown) {
+    ui.stopSpinnerFail('Failed to fetch VMs');
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    logger.error('Failed to list VMs', { error: message });
+    ui.error(`Failed to list VMs: ${message}`);
+  }
+}
+
+/**
+ * Show VM details
+ */
+async function showVm(vmName: string, options: AzureCommandOptions): Promise<void> {
+  ui.header(`VM: ${vmName}`);
+  ui.newLine();
+
+  if (!options.resourceGroup) {
+    ui.error('Resource group required (use -g)');
+    return;
+  }
+
+  const azArgs = [
+    'vm',
+    'show',
+    '-n',
+    vmName,
+    '-g',
+    options.resourceGroup,
+    '-o',
+    'json',
+    '--show-details',
+  ];
+  if (options.subscription) {
+    azArgs.push('--subscription', options.subscription);
+  }
+
+  try {
+    ui.startSpinner({ message: 'Fetching VM details...' });
+    const { stdout } = await execFileAsync('az', azArgs);
+    ui.stopSpinnerSuccess('Details fetched');
+
+    const vm = JSON.parse(stdout);
+
+    ui.print(ui.bold('Basic Information:'));
+    ui.print(`  Name:           ${vm.name}`);
+    ui.print(`  Resource Group: ${vm.resourceGroup}`);
+    ui.print(`  Location:       ${vm.location}`);
+    ui.print(`  VM Size:        ${vm.hardwareProfile?.vmSize}`);
+    ui.print(`  State:          ${vm.powerState || 'Unknown'}`);
+    ui.newLine();
+
+    ui.print(ui.bold('OS:'));
+    ui.print(`  Publisher:      ${vm.storageProfile?.imageReference?.publisher || 'Custom'}`);
+    ui.print(`  Offer:          ${vm.storageProfile?.imageReference?.offer || 'N/A'}`);
+    ui.print(`  SKU:            ${vm.storageProfile?.imageReference?.sku || 'N/A'}`);
+    ui.newLine();
+
+    ui.print(ui.bold('Network:'));
+    if (vm.publicIps) {
+      ui.print(`  Public IP:      ${vm.publicIps}`);
+    }
+    if (vm.privateIps) {
+      ui.print(`  Private IP:     ${vm.privateIps}`);
+    }
+    if (vm.fqdns) {
+      ui.print(`  FQDN:           ${vm.fqdns}`);
+    }
+    ui.newLine();
+
+    ui.print(ui.bold('Disks:'));
+    ui.print(`  OS Disk:        ${vm.storageProfile?.osDisk?.name}`);
+    ui.print(`  OS Disk Size:   ${vm.storageProfile?.osDisk?.diskSizeGb} GB`);
+    const dataDisks = vm.storageProfile?.dataDisks || [];
+    if (dataDisks.length > 0) {
+      ui.print(`  Data Disks:     ${dataDisks.length}`);
+    }
+  } catch (error: unknown) {
+    ui.stopSpinnerFail('Failed to fetch details');
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    logger.error('Failed to show VM', { error: message });
+    ui.error(`Failed to show VM: ${message}`);
+  }
+}
+
+/**
+ * Start a VM
+ */
+async function startVm(vmName: string, options: AzureCommandOptions): Promise<void> {
+  if (!options.resourceGroup) {
+    ui.error('Resource group required (use -g)');
+    return;
+  }
+
+  const azArgs = ['vm', 'start', '-n', vmName, '-g', options.resourceGroup];
+  if (options.subscription) {
+    azArgs.push('--subscription', options.subscription);
+  }
+
+  try {
+    ui.startSpinner({ message: `Starting VM ${vmName}...` });
+    await execFileAsync('az', azArgs);
+    ui.stopSpinnerSuccess(`VM ${vmName} started`);
+  } catch (error: unknown) {
+    ui.stopSpinnerFail('Failed to start VM');
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    logger.error('Failed to start VM', { error: message });
+    ui.error(`Failed to start VM: ${message}`);
+  }
+}
+
+/**
+ * Stop a VM
+ */
+async function stopVm(vmName: string, options: AzureCommandOptions): Promise<void> {
+  if (!options.resourceGroup) {
+    ui.error('Resource group required (use -g)');
+    return;
+  }
+
+  const azArgs = ['vm', 'stop', '-n', vmName, '-g', options.resourceGroup];
+  if (options.subscription) {
+    azArgs.push('--subscription', options.subscription);
+  }
+
+  try {
+    ui.startSpinner({ message: `Stopping VM ${vmName}...` });
+    await execFileAsync('az', azArgs);
+    ui.stopSpinnerSuccess(`VM ${vmName} stopped`);
+  } catch (error: unknown) {
+    ui.stopSpinnerFail('Failed to stop VM');
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    logger.error('Failed to stop VM', { error: message });
+    ui.error(`Failed to stop VM: ${message}`);
+  }
+}
+
+/**
+ * Delete a VM (requires safety approval)
+ */
+async function deleteVm(vmName: string, options: AzureCommandOptions): Promise<void> {
+  if (!options.resourceGroup) {
+    ui.error('Resource group required (use -g)');
+    return;
+  }
+
+  // Run safety checks
+  const safetyResult = await runVmSafetyChecks('delete', vmName, options);
+
+  displaySafetySummary({
+    operation: `delete VM ${vmName}`,
+    risks: safetyResult.risks,
+    passed: safetyResult.passed,
+  });
+
+  if (safetyResult.requiresApproval) {
+    const result = await promptForApproval({
+      title: 'Delete Virtual Machine',
+      operation: `az vm delete -n ${vmName} -g ${options.resourceGroup}`,
+      risks: safetyResult.risks,
+    });
+
+    if (!result.approved) {
+      ui.warning('Operation cancelled');
+      return;
+    }
+  }
+
+  const azArgs = ['vm', 'delete', '-n', vmName, '-g', options.resourceGroup, '--yes'];
+  if (options.subscription) {
+    azArgs.push('--subscription', options.subscription);
+  }
+
+  try {
+    ui.startSpinner({ message: `Deleting VM ${vmName}...` });
+    await execFileAsync('az', azArgs);
+    ui.stopSpinnerSuccess(`VM ${vmName} deleted`);
+  } catch (error: unknown) {
+    ui.stopSpinnerFail('Failed to delete VM');
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    logger.error('Failed to delete VM', { error: message });
+    ui.error(`Failed to delete VM: ${message}`);
+  }
+}
+
+/**
+ * Show VM help
+ */
+function showVmHelp(): void {
+  ui.print(ui.bold('VM Commands:'));
+  ui.print('  list                        List all VMs');
+  ui.print('  show <name> -g <rg>         Show VM details');
+  ui.print('  start <name> -g <rg>        Start a VM');
+  ui.print('  stop <name> -g <rg>         Stop a VM');
+  ui.print('  delete <name> -g <rg>       Delete a VM (requires approval)');
+}

package/src/commands/billing/index.ts

@@ -0,0 +1,256 @@
+/**
+ * Billing Commands
+ * Billing and subscription CLI commands
+ */
+
+import { ui } from '../../wizard/ui';
+import { billingClient } from '../../clients/enterprise-client';
+import type {
+  BillingStatusOptions,
+  BillingUpgradeOptions,
+  BillingInvoicesOptions,
+  TeamPlan,
+} from '../../types';
+
+/**
+ * Get current team ID from config or environment
+ */
+function getCurrentTeamId(): string | null {
+  return process.env.NIMBUS_TEAM_ID || null;
+}
+
+/**
+ * Parse billing status options
+ */
+export function parseBillingStatusOptions(args: string[]): BillingStatusOptions {
+  const options: BillingStatusOptions = {};
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--json') {
+      options.json = true;
+    } else if (arg === '--non-interactive') {
+      options.nonInteractive = true;
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Parse billing upgrade options
+ */
+export function parseBillingUpgradeOptions(args: string[]): BillingUpgradeOptions {
+  const options: BillingUpgradeOptions = {};
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--plan' && args[i + 1]) {
+      options.plan = args[++i] as TeamPlan;
+    } else if (arg === '--non-interactive') {
+      options.nonInteractive = true;
+    } else if (!arg.startsWith('-') && !options.plan) {
+      options.plan = arg as TeamPlan;
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Parse billing invoices options
+ */
+export function parseBillingInvoicesOptions(args: string[]): BillingInvoicesOptions {
+  const options: BillingInvoicesOptions = {};
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--limit' && args[i + 1]) {
+      options.limit = parseInt(args[++i], 10);
+    } else if (arg === '--json') {
+      options.json = true;
+    } else if (arg === '--non-interactive') {
+      options.nonInteractive = true;
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Billing status command
+ */
+export async function billingStatusCommand(options: BillingStatusOptions): Promise<void> {
+  try {
+    const teamId = getCurrentTeamId();
+    if (!teamId) {
+      ui.error('No team selected. Run `nimbus team switch <team-id>` first.');
+      return;
+    }
+
+    ui.startSpinner({ message: 'Fetching billing status...' });
+    const status = await billingClient.getStatus(teamId);
+    ui.stopSpinnerSuccess('Billing status retrieved');
+
+    if (options.json) {
+      console.log(JSON.stringify(status, null, 2));
+      return;
+    }
+
+    ui.newLine();
+    ui.header('Billing Status');
+
+    ui.print(`  Plan: ${status.plan.toUpperCase()}`);
+    ui.print(`  Status: ${status.status}`);
+    ui.print(
+      `  Period: ${new Date(status.currentPeriodStart).toLocaleDateString()} - ${new Date(status.currentPeriodEnd).toLocaleDateString()}`
+    );
+    ui.print(`  Seats: ${status.seats.used} / ${status.seats.total} used`);
+
+    if (status.cancelAtPeriodEnd) {
+      ui.warning('Subscription will cancel at end of period');
+    }
+
+    ui.newLine();
+    if (status.plan === 'free') {
+      ui.info('Upgrade to Pro for more seats and features:');
+      ui.print('  nimbus billing upgrade pro');
+    }
+  } catch (error: any) {
+    ui.stopSpinnerFail('Failed to get billing status');
+    ui.error(error.message);
+  }
+}
+
+/**
+ * Billing upgrade command
+ */
+export async function billingUpgradeCommand(options: BillingUpgradeOptions): Promise<void> {
+  try {
+    const teamId = getCurrentTeamId();
+    if (!teamId) {
+      ui.error('No team selected. Run `nimbus team switch <team-id>` first.');
+      return;
+    }
+
+    const plan = options.plan;
+    if (!plan || !['pro', 'enterprise'].includes(plan)) {
+      ui.error('Plan is required');
+      ui.info('Usage: nimbus billing upgrade <pro|enterprise>');
+      return;
+    }
+
+    ui.startSpinner({ message: `Upgrading to ${plan}...` });
+    const status = await billingClient.subscribe(teamId, { plan });
+    ui.stopSpinnerSuccess(`Upgraded to ${plan.toUpperCase()}`);
+
+    ui.newLine();
+    ui.success(`Your team is now on the ${plan.toUpperCase()} plan!`);
+    ui.print(`  Seats available: ${status.seats.total}`);
+    ui.print(`  Next billing date: ${new Date(status.currentPeriodEnd).toLocaleDateString()}`);
+  } catch (error: any) {
+    ui.stopSpinnerFail('Failed to upgrade');
+    ui.error(error.message);
+  }
+}
+
+/**
+ * Billing invoices command
+ */
+export async function billingInvoicesCommand(options: BillingInvoicesOptions): Promise<void> {
+  try {
+    const teamId = getCurrentTeamId();
+    if (!teamId) {
+      ui.error('No team selected. Run `nimbus team switch <team-id>` first.');
+      return;
+    }
+
+    ui.startSpinner({ message: 'Fetching invoices...' });
+    const invoices = await billingClient.getInvoices(teamId, options.limit || 10);
+    ui.stopSpinnerSuccess(`Found ${invoices.length} invoices`);
+
+    if (options.json) {
+      console.log(JSON.stringify(invoices, null, 2));
+      return;
+    }
+
+    if (invoices.length === 0) {
+      ui.info('No invoices found');
+      return;
+    }
+
+    ui.newLine();
+    ui.table({
+      columns: [
+        { key: 'number', header: 'Invoice #' },
+        { key: 'date', header: 'Date' },
+        { key: 'amount', header: 'Amount' },
+        { key: 'status', header: 'Status' },
+      ],
+      data: invoices.map(inv => ({
+        number: inv.number,
+        date: new Date(inv.createdAt).toLocaleDateString(),
+        amount: `$${(inv.amountDue / 100).toFixed(2)} ${inv.currency.toUpperCase()}`,
+        status: inv.status,
+      })),
+    });
+  } catch (error: any) {
+    ui.stopSpinnerFail('Failed to get invoices');
+    ui.error(error.message);
+  }
+}
+
+/**
+ * Billing cancel command
+ */
+export async function billingCancelCommand(): Promise<void> {
+  try {
+    const teamId = getCurrentTeamId();
+    if (!teamId) {
+      ui.error('No team selected. Run `nimbus team switch <team-id>` first.');
+      return;
+    }
+
+    ui.startSpinner({ message: 'Canceling subscription...' });
+    const status = await billingClient.cancel(teamId);
+    ui.stopSpinnerSuccess('Subscription canceled');
+
+    ui.newLine();
+    ui.warning(
+      `Your subscription will end on ${new Date(status.currentPeriodEnd).toLocaleDateString()}`
+    );
+    ui.info('You will retain access until then.');
+  } catch (error: any) {
+    ui.stopSpinnerFail('Failed to cancel');
+    ui.error(error.message);
+  }
+}
+
+/**
+ * Main billing command dispatcher
+ */
+export async function billingCommand(subcommand: string, args: string[]): Promise<void> {
+  switch (subcommand) {
+    case 'status':
+    case undefined:
+      await billingStatusCommand(parseBillingStatusOptions(args));
+      break;
+    case 'upgrade':
+      await billingUpgradeCommand(parseBillingUpgradeOptions(args));
+      break;
+    case 'invoices':
+      await billingInvoicesCommand(parseBillingInvoicesOptions(args));
+      break;
+    case 'cancel':
+      await billingCancelCommand();
+      break;
+    default:
+      ui.error(`Unknown billing command: ${subcommand}`);
+      ui.newLine();
+      ui.info('Available billing commands:');
+      ui.print('  nimbus billing status          - Show billing status');
+      ui.print('  nimbus billing upgrade <plan>  - Upgrade plan (pro|enterprise)');
+      ui.print('  nimbus billing invoices        - List invoices');
+      ui.print('  nimbus billing cancel          - Cancel subscription');
+  }
+}