@build-astron-co/nimbus 0.2.0

package/src/commands/azure/aks.ts

@@ -0,0 +1,376 @@
+/**
+ * Azure Kubernetes Service CLI Commands
+ *
+ * Operations for AKS clusters
+ */
+
+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 AKS safety checks
+ */
+async function runAksSafetyChecks(
+  action: string,
+  clusterName: string,
+  options: AzureCommandOptions
+): Promise<SafetyCheckResult> {
+  const safetyPolicy = loadSafetyPolicy();
+
+  const context: SafetyContext = {
+    operation: action,
+    type: 'azure',
+    environment: options.subscription || 'default',
+    resources: [clusterName],
+    metadata: {
+      resourceType: 'aks-cluster',
+      resourceGroup: options.resourceGroup,
+    },
+  };
+
+  return evaluateSafety(context, safetyPolicy);
+}
+
+/**
+ * Main AKS command router
+ */
+export async function aksCommand(
+  action: string,
+  args: string[],
+  options: AzureCommandOptions
+): Promise<void> {
+  logger.info('Running Azure AKS command', { action, args, options });
+
+  switch (action) {
+    case 'list':
+      await listClusters(options);
+      break;
+
+    case 'show':
+      if (!args[0]) {
+        ui.error('Cluster name required');
+        return;
+      }
+      await showCluster(args[0], options);
+      break;
+
+    case 'get-credentials':
+      if (!args[0]) {
+        ui.error('Cluster name required');
+        return;
+      }
+      await getCredentials(args[0], options);
+      break;
+
+    case 'scale':
+      if (args.length < 2) {
+        ui.error('Cluster name and node count required');
+        return;
+      }
+      await scaleCluster(args[0], parseInt(args[1], 10), options);
+      break;
+
+    case 'delete':
+      if (!args[0]) {
+        ui.error('Cluster name required');
+        return;
+      }
+      await deleteCluster(args[0], options);
+      break;
+
+    default:
+      showAksHelp();
+      break;
+  }
+}
+
+/**
+ * List AKS clusters
+ */
+async function listClusters(options: AzureCommandOptions): Promise<void> {
+  ui.header('AKS Clusters');
+  ui.newLine();
+
+  const azArgs = ['aks', 'list', '-o', 'json'];
+  if (options.subscription) {
+    azArgs.push('--subscription', options.subscription);
+  }
+  if (options.resourceGroup) {
+    azArgs.push('-g', options.resourceGroup);
+  }
+
+  try {
+    ui.startSpinner({ message: 'Fetching AKS clusters...' });
+    const { stdout } = await execFileAsync('az', azArgs);
+    ui.stopSpinnerSuccess('Clusters fetched');
+
+    const clusters = JSON.parse(stdout || '[]');
+
+    if (clusters.length === 0) {
+      ui.info('No AKS clusters found');
+      return;
+    }
+
+    ui.print(`Found ${clusters.length} cluster(s)\n`);
+
+    // Display table
+    ui.print(
+      ui.color(
+        `${
+          'Name'.padEnd(25) +
+          'Resource Group'.padEnd(25) +
+          'Location'.padEnd(15) +
+          'K8s Version'.padEnd(15)
+        }Status`,
+        'cyan'
+      )
+    );
+    ui.print('─'.repeat(95));
+
+    for (const cluster of clusters) {
+      const name = cluster.name?.substring(0, 24) || '';
+      const rg = cluster.resourceGroup?.substring(0, 24) || '';
+      const location = cluster.location?.substring(0, 14) || '';
+      const version = cluster.kubernetesVersion?.substring(0, 14) || '';
+      const status = cluster.provisioningState || '';
+
+      const statusColor =
+        status === 'Succeeded'
+          ? 'green'
+          : status === 'Failed'
+            ? 'red'
+            : status === 'Updating'
+              ? 'yellow'
+              : 'white';
+
+      ui.print(
+        `${name.padEnd(25)}${rg.padEnd(25)}${location.padEnd(15)}${version.padEnd(15)}${ui.color(status, statusColor as 'green' | 'red' | 'yellow' | 'white')}`
+      );
+    }
+  } catch (error: unknown) {
+    ui.stopSpinnerFail('Failed to fetch clusters');
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    logger.error('Failed to list AKS clusters', { error: message });
+    ui.error(`Failed to list clusters: ${message}`);
+  }
+}
+
+/**
+ * Show AKS cluster details
+ */
+async function showCluster(clusterName: string, options: AzureCommandOptions): Promise<void> {
+  ui.header(`AKS Cluster: ${clusterName}`);
+  ui.newLine();
+
+  if (!options.resourceGroup) {
+    ui.error('Resource group required (use -g)');
+    return;
+  }
+
+  const azArgs = ['aks', 'show', '-n', clusterName, '-g', options.resourceGroup, '-o', 'json'];
+  if (options.subscription) {
+    azArgs.push('--subscription', options.subscription);
+  }
+
+  try {
+    ui.startSpinner({ message: 'Fetching cluster details...' });
+    const { stdout } = await execFileAsync('az', azArgs);
+    ui.stopSpinnerSuccess('Details fetched');
+
+    const cluster = JSON.parse(stdout);
+
+    ui.print(ui.bold('Basic Information:'));
+    ui.print(`  Name:              ${cluster.name}`);
+    ui.print(`  Resource Group:    ${cluster.resourceGroup}`);
+    ui.print(`  Location:          ${cluster.location}`);
+    ui.print(`  Kubernetes Ver:    ${cluster.kubernetesVersion}`);
+    ui.print(`  Status:            ${cluster.provisioningState}`);
+    ui.print(`  FQDN:              ${cluster.fqdn}`);
+    ui.newLine();
+
+    ui.print(ui.bold('Network:'));
+    const networkProfile = cluster.networkProfile || {};
+    ui.print(`  Network Plugin:    ${networkProfile.networkPlugin}`);
+    ui.print(`  Network Policy:    ${networkProfile.networkPolicy || 'None'}`);
+    ui.print(`  Service CIDR:      ${networkProfile.serviceCidr}`);
+    ui.print(`  DNS Service IP:    ${networkProfile.dnsServiceIp}`);
+    ui.print(`  Pod CIDR:          ${networkProfile.podCidr || 'N/A'}`);
+    ui.newLine();
+
+    ui.print(ui.bold('Node Pools:'));
+    const nodePools = cluster.agentPoolProfiles || [];
+    for (const pool of nodePools) {
+      ui.print(`  ${ui.color(pool.name, 'cyan')}`);
+      ui.print(`    VM Size:         ${pool.vmSize}`);
+      ui.print(`    Node Count:      ${pool.count}`);
+      ui.print(`    OS Type:         ${pool.osType}`);
+      ui.print(`    Mode:            ${pool.mode}`);
+      ui.newLine();
+    }
+  } catch (error: unknown) {
+    ui.stopSpinnerFail('Failed to fetch details');
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    logger.error('Failed to show cluster', { error: message });
+    ui.error(`Failed to show cluster: ${message}`);
+  }
+}
+
+/**
+ * Get cluster credentials for kubectl
+ */
+async function getCredentials(clusterName: string, options: AzureCommandOptions): Promise<void> {
+  if (!options.resourceGroup) {
+    ui.error('Resource group required (use -g)');
+    return;
+  }
+
+  const azArgs = ['aks', 'get-credentials', '-n', clusterName, '-g', options.resourceGroup];
+  if (options.subscription) {
+    azArgs.push('--subscription', options.subscription);
+  }
+
+  try {
+    ui.startSpinner({ message: `Getting credentials for ${clusterName}...` });
+    await execFileAsync('az', azArgs);
+    ui.stopSpinnerSuccess(`Credentials configured for cluster ${clusterName}`);
+    ui.info('You can now use kubectl to interact with this cluster');
+  } catch (error: unknown) {
+    ui.stopSpinnerFail('Failed to get credentials');
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    logger.error('Failed to get credentials', { error: message });
+    ui.error(`Failed to get credentials: ${message}`);
+  }
+}
+
+/**
+ * Scale AKS cluster
+ */
+async function scaleCluster(
+  clusterName: string,
+  nodeCount: number,
+  options: AzureCommandOptions
+): Promise<void> {
+  if (!options.resourceGroup) {
+    ui.error('Resource group required (use -g)');
+    return;
+  }
+
+  // Run safety checks
+  const safetyResult = await runAksSafetyChecks('scale', clusterName, options);
+
+  displaySafetySummary({
+    operation: `scale ${clusterName} to ${nodeCount} nodes`,
+    risks: safetyResult.risks,
+    passed: safetyResult.passed,
+  });
+
+  if (safetyResult.requiresApproval) {
+    const result = await promptForApproval({
+      title: 'Scale AKS Cluster',
+      operation: `az aks scale -n ${clusterName} -g ${options.resourceGroup} --node-count ${nodeCount}`,
+      risks: safetyResult.risks,
+    });
+
+    if (!result.approved) {
+      ui.warning('Operation cancelled');
+      return;
+    }
+  }
+
+  const azArgs = [
+    'aks',
+    'scale',
+    '-n',
+    clusterName,
+    '-g',
+    options.resourceGroup,
+    '--node-count',
+    String(nodeCount),
+  ];
+  if (options.subscription) {
+    azArgs.push('--subscription', options.subscription);
+  }
+
+  try {
+    ui.startSpinner({ message: `Scaling cluster ${clusterName} to ${nodeCount} nodes...` });
+    await execFileAsync('az', azArgs);
+    ui.stopSpinnerSuccess(`Cluster ${clusterName} scaled to ${nodeCount} nodes`);
+  } catch (error: unknown) {
+    ui.stopSpinnerFail('Failed to scale cluster');
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    logger.error('Failed to scale cluster', { error: message });
+    ui.error(`Failed to scale cluster: ${message}`);
+  }
+}
+
+/**
+ * Delete AKS cluster (requires safety approval)
+ */
+async function deleteCluster(clusterName: string, options: AzureCommandOptions): Promise<void> {
+  if (!options.resourceGroup) {
+    ui.error('Resource group required (use -g)');
+    return;
+  }
+
+  // Run safety checks
+  const safetyResult = await runAksSafetyChecks('delete', clusterName, options);
+
+  displaySafetySummary({
+    operation: `delete cluster ${clusterName}`,
+    risks: safetyResult.risks,
+    passed: safetyResult.passed,
+  });
+
+  if (safetyResult.requiresApproval) {
+    const result = await promptForApproval({
+      title: 'Delete AKS Cluster',
+      operation: `az aks delete -n ${clusterName} -g ${options.resourceGroup}`,
+      risks: safetyResult.risks,
+    });
+
+    if (!result.approved) {
+      ui.warning('Operation cancelled');
+      return;
+    }
+  }
+
+  const azArgs = ['aks', 'delete', '-n', clusterName, '-g', options.resourceGroup, '--yes'];
+  if (options.subscription) {
+    azArgs.push('--subscription', options.subscription);
+  }
+
+  try {
+    ui.startSpinner({ message: `Deleting cluster ${clusterName}...` });
+    await execFileAsync('az', azArgs);
+    ui.stopSpinnerSuccess(`Cluster ${clusterName} deleted`);
+  } catch (error: unknown) {
+    ui.stopSpinnerFail('Failed to delete cluster');
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    logger.error('Failed to delete cluster', { error: message });
+    ui.error(`Failed to delete cluster: ${message}`);
+  }
+}
+
+/**
+ * Show AKS help
+ */
+function showAksHelp(): void {
+  ui.print(ui.bold('AKS Commands:'));
+  ui.print('  list                              List all AKS clusters');
+  ui.print('  show <name> -g <rg>               Show cluster details');
+  ui.print('  get-credentials <name> -g <rg>    Configure kubectl for cluster');
+  ui.print('  scale <name> <count> -g <rg>      Scale cluster (requires approval)');
+  ui.print('  delete <name> -g <rg>             Delete cluster (requires approval)');
+}

package/src/commands/azure/functions.ts

@@ -0,0 +1,253 @@
+/**
+ * Azure Functions CLI Commands
+ *
+ * Operations for Azure Function Apps
+ */
+
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { logger } from '../../utils';
+import { ui } from '../../wizard/ui';
+import type { AzureCommandOptions } from './index';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Main Functions command router
+ */
+export async function functionsCommand(
+  action: string,
+  args: string[],
+  options: AzureCommandOptions
+): Promise<void> {
+  logger.info('Running Azure Functions command', { action, args, options });
+
+  switch (action) {
+    case 'list':
+      await listFunctionApps(options);
+      break;
+
+    case 'show':
+      if (!args[0]) {
+        ui.error('Function app name required');
+        return;
+      }
+      await showFunctionApp(args[0], options);
+      break;
+
+    case 'functions':
+      if (!args[0]) {
+        ui.error('Function app name required');
+        return;
+      }
+      await listFunctions(args[0], options);
+      break;
+
+    default:
+      showFunctionsHelp();
+      break;
+  }
+}
+
+/**
+ * List Function Apps
+ */
+async function listFunctionApps(options: AzureCommandOptions): Promise<void> {
+  ui.header('Azure Function Apps');
+  ui.newLine();
+
+  const azArgs = ['functionapp', 'list', '-o', 'json'];
+  if (options.subscription) {
+    azArgs.push('--subscription', options.subscription);
+  }
+  if (options.resourceGroup) {
+    azArgs.push('-g', options.resourceGroup);
+  }
+
+  try {
+    ui.startSpinner({ message: 'Fetching function apps...' });
+    const { stdout } = await execFileAsync('az', azArgs);
+    ui.stopSpinnerSuccess('Function apps fetched');
+
+    const apps = JSON.parse(stdout || '[]');
+
+    if (apps.length === 0) {
+      ui.info('No function apps found');
+      return;
+    }
+
+    ui.print(`Found ${apps.length} function app(s)\n`);
+
+    // Display table
+    ui.print(
+      ui.color(
+        `${
+          'Name'.padEnd(30) +
+          'Resource Group'.padEnd(25) +
+          'Location'.padEnd(15) +
+          'Runtime'.padEnd(15)
+        }State`,
+        'cyan'
+      )
+    );
+    ui.print('─'.repeat(100));
+
+    for (const app of apps) {
+      const name = app.name?.substring(0, 29) || '';
+      const rg = app.resourceGroup?.substring(0, 24) || '';
+      const location = app.location?.substring(0, 14) || '';
+      const runtime =
+        app.siteConfig?.linuxFxVersion?.substring(0, 14) ||
+        app.siteConfig?.windowsFxVersion?.substring(0, 14) ||
+        'N/A';
+      const state = app.state || '';
+
+      const stateColor = state === 'Running' ? 'green' : state === 'Stopped' ? 'red' : 'white';
+
+      ui.print(
+        `${name.padEnd(30)}${rg.padEnd(25)}${location.padEnd(15)}${runtime.padEnd(15)}${ui.color(state, stateColor as 'green' | 'red' | 'white')}`
+      );
+    }
+  } catch (error: unknown) {
+    ui.stopSpinnerFail('Failed to fetch function apps');
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    logger.error('Failed to list function apps', { error: message });
+    ui.error(`Failed to list function apps: ${message}`);
+  }
+}
+
+/**
+ * Show Function App details
+ */
+async function showFunctionApp(appName: string, options: AzureCommandOptions): Promise<void> {
+  ui.header(`Function App: ${appName}`);
+  ui.newLine();
+
+  if (!options.resourceGroup) {
+    ui.error('Resource group required (use -g)');
+    return;
+  }
+
+  const azArgs = ['functionapp', 'show', '-n', appName, '-g', options.resourceGroup, '-o', 'json'];
+  if (options.subscription) {
+    azArgs.push('--subscription', options.subscription);
+  }
+
+  try {
+    ui.startSpinner({ message: 'Fetching function app details...' });
+    const { stdout } = await execFileAsync('az', azArgs);
+    ui.stopSpinnerSuccess('Details fetched');
+
+    const app = JSON.parse(stdout);
+
+    ui.print(ui.bold('Basic Information:'));
+    ui.print(`  Name:           ${app.name}`);
+    ui.print(`  Resource Group: ${app.resourceGroup}`);
+    ui.print(`  Location:       ${app.location}`);
+    ui.print(`  State:          ${app.state}`);
+    ui.print(`  Default Host:   ${app.defaultHostName}`);
+    ui.newLine();
+
+    ui.print(ui.bold('Configuration:'));
+    ui.print(
+      `  Runtime:        ${app.siteConfig?.linuxFxVersion || app.siteConfig?.windowsFxVersion || 'N/A'}`
+    );
+    ui.print(`  Node Version:   ${app.siteConfig?.nodeVersion || 'N/A'}`);
+    ui.print(`  Python Version: ${app.siteConfig?.pythonVersion || 'N/A'}`);
+    ui.print(`  HTTPS Only:     ${app.httpsOnly ? 'Yes' : 'No'}`);
+    ui.newLine();
+
+    ui.print(ui.bold('Resources:'));
+    ui.print(`  App Service Plan: ${app.serverFarmId?.split('/').pop() || 'Consumption'}`);
+    ui.print(`  Kind:             ${app.kind}`);
+    ui.newLine();
+
+    ui.print(ui.bold('Outbound IPs:'));
+    const outboundIps = app.outboundIpAddresses?.split(',') || [];
+    for (const ip of outboundIps.slice(0, 5)) {
+      ui.print(`  - ${ip}`);
+    }
+    if (outboundIps.length > 5) {
+      ui.print(ui.dim(`  ... and ${outboundIps.length - 5} more`));
+    }
+  } catch (error: unknown) {
+    ui.stopSpinnerFail('Failed to fetch details');
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    logger.error('Failed to show function app', { error: message });
+    ui.error(`Failed to show function app: ${message}`);
+  }
+}
+
+/**
+ * List functions in a Function App
+ */
+async function listFunctions(appName: string, options: AzureCommandOptions): Promise<void> {
+  ui.header(`Functions in ${appName}`);
+  ui.newLine();
+
+  if (!options.resourceGroup) {
+    ui.error('Resource group required (use -g)');
+    return;
+  }
+
+  const azArgs = [
+    'functionapp',
+    'function',
+    'list',
+    '-n',
+    appName,
+    '-g',
+    options.resourceGroup,
+    '-o',
+    'json',
+  ];
+  if (options.subscription) {
+    azArgs.push('--subscription', options.subscription);
+  }
+
+  try {
+    ui.startSpinner({ message: 'Fetching functions...' });
+    const { stdout } = await execFileAsync('az', azArgs);
+    ui.stopSpinnerSuccess('Functions fetched');
+
+    const functions = JSON.parse(stdout || '[]');
+
+    if (functions.length === 0) {
+      ui.info('No functions found');
+      return;
+    }
+
+    ui.print(`Found ${functions.length} function(s)\n`);
+
+    for (const fn of functions) {
+      const name = fn.name?.split('/').pop() || fn.name;
+      const enabled = fn.isDisabled === false;
+
+      ui.print(
+        `  ${ui.color(name, 'cyan')} ${enabled ? ui.color('[enabled]', 'green') : ui.color('[disabled]', 'red')}`
+      );
+
+      // Show config if available
+      if (fn.config?.bindings) {
+        for (const binding of fn.config.bindings) {
+          ui.print(ui.dim(`    ${binding.direction}: ${binding.type}`));
+        }
+      }
+    }
+  } catch (error: unknown) {
+    ui.stopSpinnerFail('Failed to fetch functions');
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    logger.error('Failed to list functions', { error: message });
+    ui.error(`Failed to list functions: ${message}`);
+  }
+}
+
+/**
+ * Show Functions help
+ */
+function showFunctionsHelp(): void {
+  ui.print(ui.bold('Azure Functions Commands:'));
+  ui.print('  list                        List all function apps');
+  ui.print('  show <name> -g <rg>         Show function app details');
+  ui.print('  functions <name> -g <rg>    List functions in app');
+}