@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/commands/azure/storage.js

@@ -0,0 +1,378 @@
+/**
+ * Azure Storage CLI Commands
+ *
+ * Operations for Azure Storage accounts and blobs
+ */
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { logger } from '../../utils';
+import { ui } from '../../wizard/ui';
+import { loadSafetyPolicy, evaluateSafety, } from '../../config/safety-policy';
+import { promptForApproval, displaySafetySummary } from '../../wizard/approval';
+const execFileAsync = promisify(execFile);
+/**
+ * Run storage safety checks
+ */
+async function runStorageSafetyChecks(action, target, options) {
+    const safetyPolicy = loadSafetyPolicy();
+    const context = {
+        operation: action,
+        type: 'azure',
+        environment: options.subscription || 'default',
+        resources: [target],
+        metadata: {
+            resourceType: 'storage',
+            resourceGroup: options.resourceGroup,
+        },
+    };
+    return evaluateSafety(context, safetyPolicy);
+}
+/**
+ * Main Storage command router
+ */
+export async function storageCommand(action, args, options) {
+    logger.info('Running Azure Storage command', { action, args, options });
+    switch (action) {
+        case 'account':
+            await accountCommand(args[0], args.slice(1), options);
+            break;
+        case 'container':
+            await containerCommand(args[0], args.slice(1), options);
+            break;
+        case 'blob':
+            await blobCommand(args[0], args.slice(1), options);
+            break;
+        default:
+            showStorageHelp();
+            break;
+    }
+}
+/**
+ * Storage account subcommand
+ */
+async function accountCommand(action, args, options) {
+    switch (action) {
+        case 'list':
+            await listAccounts(options);
+            break;
+        case 'show':
+            if (!args[0]) {
+                ui.error('Account name required');
+                return;
+            }
+            await showAccount(args[0], options);
+            break;
+        default:
+            ui.print(ui.bold('Storage Account Commands:'));
+            ui.print('  list                     List all storage accounts');
+            ui.print('  show <name> -g <rg>      Show account details');
+            break;
+    }
+}
+/**
+ * Container subcommand
+ */
+async function containerCommand(action, args, options) {
+    switch (action) {
+        case 'list':
+            if (!args[0]) {
+                ui.error('Account name required');
+                return;
+            }
+            await listContainers(args[0], options);
+            break;
+        case 'delete':
+            if (!args[0] || !args[1]) {
+                ui.error('Account name and container name required');
+                return;
+            }
+            await deleteContainer(args[0], args[1], options);
+            break;
+        default:
+            ui.print(ui.bold('Container Commands:'));
+            ui.print('  list <account>                    List containers in account');
+            ui.print('  delete <account> <container>      Delete container (requires approval)');
+            break;
+    }
+}
+/**
+ * Blob subcommand
+ */
+async function blobCommand(action, args, options) {
+    switch (action) {
+        case 'list':
+            if (!args[0] || !args[1]) {
+                ui.error('Account name and container name required');
+                return;
+            }
+            await listBlobs(args[0], args[1], options);
+            break;
+        default:
+            ui.print(ui.bold('Blob Commands:'));
+            ui.print('  list <account> <container>        List blobs in container');
+            break;
+    }
+}
+/**
+ * List storage accounts
+ */
+async function listAccounts(options) {
+    ui.header('Azure Storage Accounts');
+    ui.newLine();
+    const azArgs = ['storage', 'account', 'list', '-o', 'json'];
+    if (options.subscription) {
+        azArgs.push('--subscription', options.subscription);
+    }
+    if (options.resourceGroup) {
+        azArgs.push('-g', options.resourceGroup);
+    }
+    try {
+        ui.startSpinner({ message: 'Fetching storage accounts...' });
+        const { stdout } = await execFileAsync('az', azArgs);
+        ui.stopSpinnerSuccess('Accounts fetched');
+        const accounts = JSON.parse(stdout || '[]');
+        if (accounts.length === 0) {
+            ui.info('No storage accounts found');
+            return;
+        }
+        ui.print(`Found ${accounts.length} account(s)\n`);
+        // Display table
+        ui.print(ui.color(`${'Name'.padEnd(30) +
+            'Resource Group'.padEnd(25) +
+            'Location'.padEnd(15) +
+            'Kind'.padEnd(15)}Status`, 'cyan'));
+        ui.print('─'.repeat(100));
+        for (const account of accounts) {
+            const name = account.name?.substring(0, 29) || '';
+            const rg = account.resourceGroup?.substring(0, 24) || '';
+            const location = account.location?.substring(0, 14) || '';
+            const kind = account.kind?.substring(0, 14) || '';
+            const status = account.provisioningState || '';
+            const statusColor = status === 'Succeeded' ? 'green' : status === 'Failed' ? 'red' : 'white';
+            ui.print(`${name.padEnd(30)}${rg.padEnd(25)}${location.padEnd(15)}${kind.padEnd(15)}${ui.color(status, statusColor)}`);
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to fetch accounts');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to list storage accounts', { error: message });
+        ui.error(`Failed to list accounts: ${message}`);
+    }
+}
+/**
+ * Show storage account details
+ */
+async function showAccount(accountName, options) {
+    ui.header(`Storage Account: ${accountName}`);
+    ui.newLine();
+    if (!options.resourceGroup) {
+        ui.error('Resource group required (use -g)');
+        return;
+    }
+    const azArgs = [
+        'storage',
+        'account',
+        'show',
+        '-n',
+        accountName,
+        '-g',
+        options.resourceGroup,
+        '-o',
+        'json',
+    ];
+    if (options.subscription) {
+        azArgs.push('--subscription', options.subscription);
+    }
+    try {
+        ui.startSpinner({ message: 'Fetching account details...' });
+        const { stdout } = await execFileAsync('az', azArgs);
+        ui.stopSpinnerSuccess('Details fetched');
+        const account = JSON.parse(stdout);
+        ui.print(ui.bold('Basic Information:'));
+        ui.print(`  Name:           ${account.name}`);
+        ui.print(`  Resource Group: ${account.resourceGroup}`);
+        ui.print(`  Location:       ${account.location}`);
+        ui.print(`  Kind:           ${account.kind}`);
+        ui.print(`  Status:         ${account.provisioningState}`);
+        ui.newLine();
+        ui.print(ui.bold('Properties:'));
+        ui.print(`  SKU:            ${account.sku?.name}`);
+        ui.print(`  Tier:           ${account.sku?.tier}`);
+        ui.print(`  Access Tier:    ${account.accessTier || 'N/A'}`);
+        ui.print(`  HTTPS Only:     ${account.enableHttpsTrafficOnly ? 'Yes' : 'No'}`);
+        ui.newLine();
+        ui.print(ui.bold('Encryption:'));
+        ui.print(`  Services:       ${Object.keys(account.encryption?.services || {}).join(', ')}`);
+        ui.print(`  Key Source:     ${account.encryption?.keySource}`);
+        ui.newLine();
+        ui.print(ui.bold('Endpoints:'));
+        const endpoints = account.primaryEndpoints || {};
+        if (endpoints.blob) {
+            ui.print(`  Blob:           ${endpoints.blob}`);
+        }
+        if (endpoints.file) {
+            ui.print(`  File:           ${endpoints.file}`);
+        }
+        if (endpoints.queue) {
+            ui.print(`  Queue:          ${endpoints.queue}`);
+        }
+        if (endpoints.table) {
+            ui.print(`  Table:          ${endpoints.table}`);
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to fetch details');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to show account', { error: message });
+        ui.error(`Failed to show account: ${message}`);
+    }
+}
+/**
+ * List containers in a storage account
+ */
+async function listContainers(accountName, options) {
+    ui.header(`Containers in ${accountName}`);
+    ui.newLine();
+    const azArgs = [
+        'storage',
+        'container',
+        'list',
+        '--account-name',
+        accountName,
+        '-o',
+        'json',
+        '--auth-mode',
+        'login',
+    ];
+    if (options.subscription) {
+        azArgs.push('--subscription', options.subscription);
+    }
+    try {
+        ui.startSpinner({ message: 'Fetching containers...' });
+        const { stdout } = await execFileAsync('az', azArgs);
+        ui.stopSpinnerSuccess('Containers fetched');
+        const containers = JSON.parse(stdout || '[]');
+        if (containers.length === 0) {
+            ui.info('No containers found');
+            return;
+        }
+        ui.print(`Found ${containers.length} container(s)\n`);
+        for (const container of containers) {
+            ui.print(`  ${ui.color(container.name, 'cyan')}`);
+            if (container.properties?.lastModified) {
+                ui.print(ui.dim(`    Last Modified: ${container.properties.lastModified}`));
+            }
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to fetch containers');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to list containers', { error: message });
+        ui.error(`Failed to list containers: ${message}`);
+    }
+}
+/**
+ * Delete a container (requires safety approval)
+ */
+async function deleteContainer(accountName, containerName, options) {
+    // Run safety checks
+    const safetyResult = await runStorageSafetyChecks('delete', `${accountName}/${containerName}`, options);
+    displaySafetySummary({
+        operation: `delete container ${containerName}`,
+        risks: safetyResult.risks,
+        passed: safetyResult.passed,
+    });
+    if (safetyResult.requiresApproval) {
+        const result = await promptForApproval({
+            title: 'Delete Storage Container',
+            operation: `az storage container delete --name ${containerName} --account-name ${accountName}`,
+            risks: safetyResult.risks,
+        });
+        if (!result.approved) {
+            ui.warning('Operation cancelled');
+            return;
+        }
+    }
+    const azArgs = [
+        'storage',
+        'container',
+        'delete',
+        '--name',
+        containerName,
+        '--account-name',
+        accountName,
+        '--auth-mode',
+        'login',
+    ];
+    if (options.subscription) {
+        azArgs.push('--subscription', options.subscription);
+    }
+    try {
+        ui.startSpinner({ message: `Deleting container ${containerName}...` });
+        await execFileAsync('az', azArgs);
+        ui.stopSpinnerSuccess(`Container ${containerName} deleted`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to delete container');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to delete container', { error: message });
+        ui.error(`Failed to delete container: ${message}`);
+    }
+}
+/**
+ * List blobs in a container
+ */
+async function listBlobs(accountName, containerName, options) {
+    ui.header(`Blobs in ${accountName}/${containerName}`);
+    ui.newLine();
+    const azArgs = [
+        'storage',
+        'blob',
+        'list',
+        '--container-name',
+        containerName,
+        '--account-name',
+        accountName,
+        '-o',
+        'json',
+        '--auth-mode',
+        'login',
+    ];
+    if (options.subscription) {
+        azArgs.push('--subscription', options.subscription);
+    }
+    try {
+        ui.startSpinner({ message: 'Fetching blobs...' });
+        const { stdout } = await execFileAsync('az', azArgs);
+        ui.stopSpinnerSuccess('Blobs fetched');
+        const blobs = JSON.parse(stdout || '[]');
+        if (blobs.length === 0) {
+            ui.info('No blobs found');
+            return;
+        }
+        ui.print(`Found ${blobs.length} blob(s)\n`);
+        for (const blob of blobs) {
+            const size = blob.properties?.contentLength
+                ? `${Math.round(blob.properties.contentLength / 1024)} KB`
+                : '';
+            ui.print(`  ${blob.name} ${ui.dim(size)}`);
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to fetch blobs');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to list blobs', { error: message });
+        ui.error(`Failed to list blobs: ${message}`);
+    }
+}
+/**
+ * Show Storage help
+ */
+function showStorageHelp() {
+    ui.print(ui.bold('Storage Commands:'));
+    ui.print('  account list                       List storage accounts');
+    ui.print('  account show <name> -g <rg>        Show account details');
+    ui.print('  container list <account>           List containers');
+    ui.print('  container delete <account> <name>  Delete container (requires approval)');
+    ui.print('  blob list <account> <container>    List blobs');
+}

package/dist/src/commands/azure/vm.js

@@ -0,0 +1,291 @@
+/**
+ * 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, } from '../../config/safety-policy';
+import { promptForApproval, displaySafetySummary } from '../../wizard/approval';
+const execFileAsync = promisify(execFile);
+/**
+ * Run VM safety checks
+ */
+async function runVmSafetyChecks(action, vmName, options) {
+    const safetyPolicy = loadSafetyPolicy();
+    const context = {
+        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, args, options) {
+    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) {
+    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)}`);
+        }
+    }
+    catch (error) {
+        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, options) {
+    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) {
+        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, options) {
+    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) {
+        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, options) {
+    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) {
+        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, options) {
+    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) {
+        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() {
+    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)');
+}