@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/commands/aws/rds.js

@@ -0,0 +1,345 @@
+/**
+ * AWS RDS Commands
+ *
+ * RDS database operations with cost warnings before billable actions
+ *
+ * Usage:
+ *   nimbus aws rds list
+ *   nimbus aws rds describe <db-identifier>
+ *   nimbus aws rds start <db-identifier>
+ *   nimbus aws rds stop <db-identifier>
+ */
+import { logger } from '../../utils';
+import { ui } from '../../wizard/ui';
+import { confirm } from '../../wizard/prompts';
+import { loadSafetyPolicy, evaluateSafety, } from '../../config/safety-policy';
+import { promptForApproval } from '../../wizard/approval';
+import { estimateCloudCost, formatCostWarning } from '../cost/cloud-cost-estimator';
+/**
+ * RDS command router
+ */
+export async function rdsCommand(action, args, options) {
+    logger.info('Running RDS command', { action, args, options });
+    switch (action) {
+        case 'list':
+        case 'ls':
+            await listInstances(options);
+            break;
+        case 'describe':
+            if (!args[0]) {
+                ui.error('DB instance identifier is required');
+                ui.print('Usage: nimbus aws rds describe <db-identifier>');
+                return;
+            }
+            await describeInstance(args[0], options);
+            break;
+        case 'start':
+            if (!args[0]) {
+                ui.error('DB instance identifier is required');
+                ui.print('Usage: nimbus aws rds start <db-identifier>');
+                return;
+            }
+            await startInstance(args[0], options);
+            break;
+        case 'stop':
+            if (!args[0]) {
+                ui.error('DB instance identifier is required');
+                ui.print('Usage: nimbus aws rds stop <db-identifier>');
+                return;
+            }
+            await stopInstance(args[0], options);
+            break;
+        default:
+            showRdsHelp();
+            break;
+    }
+}
+/**
+ * Display a cost warning for an RDS instance class using the cloud cost estimator.
+ */
+function displayRdsCostWarning(instanceClass, multiAz) {
+    const estimate = estimateCloudCost('rds:StartDBInstance', {
+        instanceClass,
+        multiAz,
+    });
+    if (estimate) {
+        const color = estimate.monthly > 200 ? 'red' : estimate.monthly > 50 ? 'yellow' : 'green';
+        ui.newLine();
+        ui.print(ui.bold('  Estimated Cost:'));
+        ui.print(`    Hourly:  ${ui.color(`$${estimate.hourly.toFixed(4)}/hr`, color)}`);
+        ui.print(`    Monthly: ${ui.color(`$${estimate.monthly.toFixed(2)}/mo`, color)} (on-demand${multiAz ? ', Multi-AZ' : ''}, approximate)`);
+        ui.newLine();
+    }
+}
+/**
+ * List all RDS instances
+ */
+async function listInstances(options) {
+    ui.header('RDS Instances');
+    ui.startSpinner({ message: 'Fetching RDS instances...' });
+    try {
+        const result = await runAwsCommand('rds describe-db-instances', options);
+        const instances = result.DBInstances || [];
+        ui.stopSpinnerSuccess(`Found ${instances.length} instance(s)`);
+        ui.newLine();
+        if (instances.length === 0) {
+            ui.info('No RDS instances found');
+            return;
+        }
+        // Display table
+        displayInstanceTable(instances);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to list instances');
+        ui.error(error.message);
+    }
+}
+/**
+ * Describe a specific RDS instance
+ */
+async function describeInstance(identifier, options) {
+    ui.header(`RDS Instance: ${identifier}`);
+    ui.startSpinner({ message: 'Fetching instance details...' });
+    try {
+        const result = await runAwsCommand(`rds describe-db-instances --db-instance-identifier ${identifier}`, options);
+        const instances = result.DBInstances || [];
+        ui.stopSpinnerSuccess('Instance details retrieved');
+        ui.newLine();
+        if (instances.length === 0) {
+            ui.error(`Instance ${identifier} not found`);
+            return;
+        }
+        const instance = instances[0];
+        // Display instance details
+        ui.print(ui.bold('Instance Details:'));
+        ui.newLine();
+        ui.print(`  Identifier:      ${instance.DBInstanceIdentifier}`);
+        ui.print(`  Class:           ${instance.DBInstanceClass}`);
+        ui.print(`  Engine:          ${instance.Engine} ${instance.EngineVersion}`);
+        ui.print(`  Status:          ${formatStatus(instance.DBInstanceStatus)}`);
+        ui.print(`  Storage:         ${instance.AllocatedStorage} GB`);
+        ui.print(`  AZ:              ${instance.AvailabilityZone}`);
+        ui.print(`  Multi-AZ:        ${instance.MultiAZ ? 'Yes' : 'No'}`);
+        if (instance.Endpoint) {
+            ui.newLine();
+            ui.print(ui.bold('Endpoint:'));
+            ui.print(`  Address:         ${instance.Endpoint.Address}`);
+            ui.print(`  Port:            ${instance.Endpoint.Port}`);
+        }
+        // Show cost estimate
+        displayRdsCostWarning(instance.DBInstanceClass, instance.MultiAZ);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to describe instance');
+        ui.error(error.message);
+    }
+}
+/**
+ * Start an RDS instance
+ */
+async function startInstance(identifier, options) {
+    ui.header(`Start RDS Instance: ${identifier}`);
+    // Try to get instance class for cost estimate
+    try {
+        const result = await runAwsCommand(`rds describe-db-instances --db-instance-identifier ${identifier}`, options);
+        const instances = result.DBInstances || [];
+        if (instances.length > 0) {
+            const instance = instances[0];
+            const estimate = estimateCloudCost('rds:StartDBInstance', {
+                instanceClass: instance.DBInstanceClass,
+                multiAz: instance.MultiAZ,
+            });
+            if (estimate) {
+                ui.newLine();
+                ui.warning(formatCostWarning(estimate));
+                ui.newLine();
+            }
+        }
+    }
+    catch {
+        // Non-critical, continue without cost estimate
+    }
+    const proceed = await confirm({
+        message: `Start instance ${identifier}?`,
+        defaultValue: true,
+    });
+    if (!proceed) {
+        ui.info('Operation cancelled');
+        return;
+    }
+    ui.startSpinner({ message: 'Starting instance...' });
+    try {
+        await runAwsCommand(`rds start-db-instance --db-instance-identifier ${identifier}`, options);
+        ui.stopSpinnerSuccess('Instance starting');
+        ui.info(`Instance ${identifier} is now starting`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to start instance');
+        ui.error(error.message);
+    }
+}
+/**
+ * Stop an RDS instance
+ */
+async function stopInstance(identifier, options) {
+    ui.header(`Stop RDS Instance: ${identifier}`);
+    // Show cost estimate for the instance being stopped
+    try {
+        const result = await runAwsCommand(`rds describe-db-instances --db-instance-identifier ${identifier}`, options);
+        const instances = result.DBInstances || [];
+        if (instances.length > 0) {
+            const instance = instances[0];
+            displayRdsCostWarning(instance.DBInstanceClass, instance.MultiAZ);
+            ui.info('Stopping this instance will stop incurring compute charges.');
+            ui.newLine();
+        }
+    }
+    catch {
+        // Non-critical, continue without cost estimate
+    }
+    // Run safety checks
+    const safetyResult = await runSafetyCheck('stop', identifier, options);
+    if (safetyResult.requiresApproval) {
+        const approval = await promptForApproval({
+            title: 'Stop RDS Instance',
+            operation: `rds stop ${identifier}`,
+            risks: safetyResult.risks,
+        });
+        if (!approval.approved) {
+            ui.info('Operation cancelled');
+            return;
+        }
+    }
+    else {
+        const proceed = await confirm({
+            message: `Stop instance ${identifier}?`,
+            defaultValue: false,
+        });
+        if (!proceed) {
+            ui.info('Operation cancelled');
+            return;
+        }
+    }
+    ui.startSpinner({ message: 'Stopping instance...' });
+    try {
+        await runAwsCommand(`rds stop-db-instance --db-instance-identifier ${identifier}`, options);
+        ui.stopSpinnerSuccess('Instance stopping');
+        ui.info(`Instance ${identifier} is now stopping`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to stop instance');
+        ui.error(error.message);
+    }
+}
+/**
+ * Run safety check for RDS operation
+ */
+async function runSafetyCheck(operation, identifier, options) {
+    const policy = loadSafetyPolicy();
+    const context = {
+        operation,
+        type: 'aws',
+        resources: [identifier],
+        metadata: {
+            service: 'rds',
+            region: options.region,
+        },
+    };
+    return evaluateSafety(context, policy);
+}
+/**
+ * Run AWS CLI command and parse JSON output
+ */
+async function runAwsCommand(command, options) {
+    const { execFile } = await import('child_process');
+    const { promisify } = await import('util');
+    const execFileAsync = promisify(execFile);
+    const args = command.split(' ');
+    const baseCommand = args[0];
+    const commandArgs = args.slice(1);
+    // Add common options
+    if (options.profile) {
+        commandArgs.push('--profile', options.profile);
+    }
+    if (options.region) {
+        commandArgs.push('--region', options.region);
+    }
+    commandArgs.push('--output', 'json');
+    const { stdout } = await execFileAsync('aws', [baseCommand, ...commandArgs]);
+    return JSON.parse(stdout);
+}
+/**
+ * Display instances in a table format
+ */
+function displayInstanceTable(instances) {
+    const headers = ['Identifier', 'Engine', 'Class', 'Status', 'Storage', 'Multi-AZ'];
+    const rows = instances.map(inst => [
+        inst.DBInstanceIdentifier,
+        `${inst.Engine} ${inst.EngineVersion}`,
+        inst.DBInstanceClass,
+        inst.DBInstanceStatus,
+        `${inst.AllocatedStorage} GB`,
+        inst.MultiAZ ? 'Yes' : 'No',
+    ]);
+    // Print header
+    const headerRow = headers
+        .map((h, i) => {
+        const maxWidth = Math.max(h.length, ...rows.map(r => r[i].length));
+        return h.padEnd(maxWidth);
+    })
+        .join('  ');
+    ui.print(ui.bold(headerRow));
+    ui.print('-'.repeat(headerRow.length));
+    // Print rows
+    for (const row of rows) {
+        const formattedRow = row
+            .map((cell, i) => {
+            const maxWidth = Math.max(headers[i].length, ...rows.map(r => r[i].length));
+            if (i === 3) {
+                // Status column - colorize
+                return formatStatus(cell).padEnd(maxWidth + 10);
+            }
+            return cell.padEnd(maxWidth);
+        })
+            .join('  ');
+        ui.print(formattedRow);
+    }
+}
+/**
+ * Format instance status with color
+ */
+function formatStatus(status) {
+    switch (status) {
+        case 'available':
+            return ui.color(status, 'green');
+        case 'stopped':
+            return ui.color(status, 'red');
+        case 'starting':
+        case 'stopping':
+        case 'creating':
+        case 'modifying':
+            return ui.color(status, 'yellow');
+        case 'deleting':
+            return ui.color(status, 'gray');
+        default:
+            return status;
+    }
+}
+/**
+ * Show RDS command help
+ */
+function showRdsHelp() {
+    ui.print('Usage: nimbus aws rds <action> [args]');
+    ui.newLine();
+    ui.print(ui.bold('Actions:'));
+    ui.print('  list                  List all RDS instances');
+    ui.print('  describe <id>         Describe a specific instance');
+    ui.print('  start <id>            Start an instance');
+    ui.print('  stop <id>             Stop an instance');
+    ui.newLine();
+    ui.print(ui.bold('Examples:'));
+    ui.print('  nimbus aws rds list');
+    ui.print('  nimbus aws rds describe my-database');
+    ui.print('  nimbus aws rds stop my-database');
+}
+export default rdsCommand;

package/dist/src/commands/aws/s3.js

@@ -0,0 +1,346 @@
+/**
+ * AWS S3 Commands
+ *
+ * S3 bucket and object operations
+ *
+ * Usage:
+ *   nimbus aws s3 ls
+ *   nimbus aws s3 ls <bucket>
+ *   nimbus aws s3 cp <src> <dst>
+ *   nimbus aws s3 rm <path>
+ *   nimbus aws s3 mb <bucket>
+ */
+import { logger } from '../../utils';
+import { ui } from '../../wizard/ui';
+import { confirm } from '../../wizard/prompts';
+import { loadSafetyPolicy, evaluateSafety, } from '../../config/safety-policy';
+import { promptForApproval } from '../../wizard/approval';
+/**
+ * S3 command router
+ */
+export async function s3Command(action, args, options) {
+    logger.info('Running S3 command', { action, args, options });
+    switch (action) {
+        case 'ls':
+        case 'list':
+            if (args[0]) {
+                await listObjects(args[0], options);
+            }
+            else {
+                await listBuckets(options);
+            }
+            break;
+        case 'cp':
+        case 'copy':
+            if (args.length < 2) {
+                ui.error('Source and destination are required');
+                ui.print('Usage: nimbus aws s3 cp <source> <destination>');
+                return;
+            }
+            await copyObject(args[0], args[1], options);
+            break;
+        case 'rm':
+        case 'remove':
+            if (!args[0]) {
+                ui.error('S3 path is required');
+                ui.print('Usage: nimbus aws s3 rm <s3://bucket/key>');
+                return;
+            }
+            await removeObject(args[0], options);
+            break;
+        case 'mb':
+            if (!args[0]) {
+                ui.error('Bucket name is required');
+                ui.print('Usage: nimbus aws s3 mb <bucket-name>');
+                return;
+            }
+            await makeBucket(args[0], options);
+            break;
+        case 'rb':
+            if (!args[0]) {
+                ui.error('Bucket name is required');
+                ui.print('Usage: nimbus aws s3 rb <bucket-name>');
+                return;
+            }
+            await removeBucket(args[0], options);
+            break;
+        default:
+            showS3Help();
+            break;
+    }
+}
+/**
+ * List all S3 buckets
+ */
+async function listBuckets(options) {
+    ui.header('S3 Buckets');
+    ui.startSpinner({ message: 'Fetching S3 buckets...' });
+    try {
+        const result = await runAwsCommand('s3api list-buckets', options);
+        const buckets = result.Buckets || [];
+        ui.stopSpinnerSuccess(`Found ${buckets.length} bucket(s)`);
+        ui.newLine();
+        if (buckets.length === 0) {
+            ui.info('No S3 buckets found');
+            return;
+        }
+        // Display table
+        ui.print(ui.bold(`${'Name'.padEnd(50)}Created`));
+        ui.print('-'.repeat(70));
+        for (const bucket of buckets) {
+            const date = new Date(bucket.CreationDate).toLocaleDateString();
+            ui.print(`${bucket.Name.padEnd(50)}${date}`);
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to list buckets');
+        ui.error(error.message);
+    }
+}
+/**
+ * List objects in a bucket
+ */
+async function listObjects(bucket, options) {
+    // Remove s3:// prefix if present
+    const bucketName = bucket.replace(/^s3:\/\//, '').split('/')[0];
+    const prefix = bucket
+        .replace(/^s3:\/\//, '')
+        .split('/')
+        .slice(1)
+        .join('/');
+    ui.header(`S3 Objects: ${bucketName}`);
+    ui.startSpinner({ message: 'Fetching objects...' });
+    try {
+        let command = `s3api list-objects-v2 --bucket ${bucketName}`;
+        if (prefix) {
+            command += ` --prefix ${prefix}`;
+        }
+        const result = await runAwsCommand(command, options);
+        const objects = result.Contents || [];
+        ui.stopSpinnerSuccess(`Found ${objects.length} object(s)`);
+        ui.newLine();
+        if (objects.length === 0) {
+            ui.info('No objects found');
+            return;
+        }
+        // Display table
+        ui.print(ui.bold(`${'Key'.padEnd(50) + 'Size'.padEnd(15)}Modified`));
+        ui.print('-'.repeat(80));
+        for (const obj of objects) {
+            const size = formatBytes(obj.Size);
+            const date = new Date(obj.LastModified).toLocaleDateString();
+            ui.print(`${obj.Key.padEnd(50)}${size.padEnd(15)}${date}`);
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to list objects');
+        ui.error(error.message);
+    }
+}
+/**
+ * Copy object
+ */
+async function copyObject(source, destination, options) {
+    ui.header('S3 Copy');
+    ui.info(`Source: ${source}`);
+    ui.info(`Destination: ${destination}`);
+    ui.newLine();
+    const proceed = await confirm({
+        message: 'Proceed with copy?',
+        defaultValue: true,
+    });
+    if (!proceed) {
+        ui.info('Operation cancelled');
+        return;
+    }
+    ui.startSpinner({ message: 'Copying...' });
+    try {
+        await runAwsS3Command(`cp ${source} ${destination}`, options);
+        ui.stopSpinnerSuccess('Copy complete');
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Copy failed');
+        ui.error(error.message);
+    }
+}
+/**
+ * Remove object
+ */
+async function removeObject(path, options) {
+    ui.header('S3 Remove');
+    ui.warning(`This will delete: ${path}`);
+    ui.newLine();
+    // Run safety checks
+    const safetyResult = await runSafetyCheck('delete', path, options);
+    if (safetyResult.requiresApproval) {
+        const approval = await promptForApproval({
+            title: 'Delete S3 Object',
+            operation: `s3 rm ${path}`,
+            risks: safetyResult.risks,
+        });
+        if (!approval.approved) {
+            ui.info('Operation cancelled');
+            return;
+        }
+    }
+    else {
+        const proceed = await confirm({
+            message: 'Delete this object?',
+            defaultValue: false,
+        });
+        if (!proceed) {
+            ui.info('Operation cancelled');
+            return;
+        }
+    }
+    ui.startSpinner({ message: 'Deleting...' });
+    try {
+        await runAwsS3Command(`rm ${path}`, options);
+        ui.stopSpinnerSuccess('Object deleted');
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Delete failed');
+        ui.error(error.message);
+    }
+}
+/**
+ * Create a bucket
+ */
+async function makeBucket(bucketName, options) {
+    ui.header('Create S3 Bucket');
+    ui.info(`Bucket: ${bucketName}`);
+    ui.newLine();
+    const proceed = await confirm({
+        message: 'Create this bucket?',
+        defaultValue: true,
+    });
+    if (!proceed) {
+        ui.info('Operation cancelled');
+        return;
+    }
+    ui.startSpinner({ message: 'Creating bucket...' });
+    try {
+        await runAwsS3Command(`mb s3://${bucketName}`, options);
+        ui.stopSpinnerSuccess('Bucket created');
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to create bucket');
+        ui.error(error.message);
+    }
+}
+/**
+ * Remove a bucket
+ */
+async function removeBucket(bucketName, options) {
+    ui.header('Remove S3 Bucket');
+    ui.warning(`This will delete bucket: ${bucketName}`);
+    ui.newLine();
+    // Run safety checks
+    const safetyResult = await runSafetyCheck('delete', bucketName, options);
+    const approval = await promptForApproval({
+        title: 'Delete S3 Bucket',
+        operation: `s3 rb ${bucketName}`,
+        risks: safetyResult.risks,
+        requireConfirmation: true,
+        confirmationWord: 'delete',
+    });
+    if (!approval.approved) {
+        ui.info('Operation cancelled');
+        return;
+    }
+    ui.startSpinner({ message: 'Removing bucket...' });
+    try {
+        await runAwsS3Command(`rb s3://${bucketName} --force`, options);
+        ui.stopSpinnerSuccess('Bucket removed');
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to remove bucket');
+        ui.error(error.message);
+    }
+}
+/**
+ * Run safety check for S3 operation
+ */
+async function runSafetyCheck(operation, resource, options) {
+    const policy = loadSafetyPolicy();
+    const context = {
+        operation,
+        type: 'aws',
+        resources: [resource],
+        metadata: {
+            service: 's3',
+            region: options.region,
+        },
+    };
+    return evaluateSafety(context, policy);
+}
+/**
+ * Run AWS CLI command and parse JSON output
+ */
+async function runAwsCommand(command, options) {
+    const { execFile } = await import('child_process');
+    const { promisify } = await import('util');
+    const execFileAsync = promisify(execFile);
+    const args = command.split(' ');
+    const baseCommand = args[0];
+    const commandArgs = args.slice(1);
+    // Add common options
+    if (options.profile) {
+        commandArgs.push('--profile', options.profile);
+    }
+    if (options.region) {
+        commandArgs.push('--region', options.region);
+    }
+    commandArgs.push('--output', 'json');
+    const { stdout } = await execFileAsync('aws', [baseCommand, ...commandArgs]);
+    return JSON.parse(stdout);
+}
+/**
+ * Run AWS S3 high-level command
+ */
+async function runAwsS3Command(command, options) {
+    const { execFile } = await import('child_process');
+    const { promisify } = await import('util');
+    const execFileAsync = promisify(execFile);
+    const args = command.split(' ');
+    // Add common options
+    if (options.profile) {
+        args.push('--profile', options.profile);
+    }
+    if (options.region) {
+        args.push('--region', options.region);
+    }
+    await execFileAsync('aws', ['s3', ...args]);
+}
+/**
+ * Format bytes to human readable
+ */
+function formatBytes(bytes) {
+    if (bytes === 0) {
+        return '0 B';
+    }
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
+}
+/**
+ * Show S3 command help
+ */
+function showS3Help() {
+    ui.print('Usage: nimbus aws s3 <action> [args]');
+    ui.newLine();
+    ui.print(ui.bold('Actions:'));
+    ui.print('  ls [bucket]           List buckets or objects');
+    ui.print('  cp <src> <dst>        Copy files/objects');
+    ui.print('  rm <path>             Remove an object');
+    ui.print('  mb <bucket>           Create a bucket');
+    ui.print('  rb <bucket>           Remove a bucket');
+    ui.newLine();
+    ui.print(ui.bold('Examples:'));
+    ui.print('  nimbus aws s3 ls');
+    ui.print('  nimbus aws s3 ls s3://my-bucket/prefix/');
+    ui.print('  nimbus aws s3 cp file.txt s3://my-bucket/');
+    ui.print('  nimbus aws s3 rm s3://my-bucket/file.txt');
+}
+export default s3Command;