@build-astron-co/nimbus 0.2.0 → 0.4.0

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

@@ -0,0 +1,108 @@
+/**
+ * AWS CLI Commands
+ *
+ * Wrapper for AWS CLI operations with enhanced output and safety checks
+ *
+ * Usage:
+ *   nimbus aws ec2 list
+ *   nimbus aws s3 ls
+ *   nimbus aws rds list
+ *   nimbus aws lambda list
+ *   nimbus aws iam users
+ *   nimbus aws vpc list
+ */
+import { logger } from '../../utils';
+import { ui } from '../../wizard/ui';
+import { ec2Command } from './ec2';
+import { s3Command } from './s3';
+import { rdsCommand } from './rds';
+import { lambdaCommand } from './lambda';
+import { iamCommand } from './iam';
+import { vpcCommand } from './vpc';
+/**
+ * Parse common AWS options from args
+ */
+export function parseAwsOptions(args) {
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if ((arg === '--profile' || arg === '-p') && args[i + 1]) {
+            options.profile = args[++i];
+        }
+        else if ((arg === '--region' || arg === '-r') && args[i + 1]) {
+            options.region = args[++i];
+        }
+        else if ((arg === '--output' || arg === '-o') && args[i + 1]) {
+            options.output = args[++i];
+        }
+    }
+    return options;
+}
+/**
+ * Main AWS command router
+ */
+export async function awsCommand(subcommand, args) {
+    logger.info('Running AWS command', { subcommand, args });
+    const options = parseAwsOptions(args);
+    const positionalArgs = args.filter(arg => !arg.startsWith('-') && !arg.startsWith('--'));
+    switch (subcommand) {
+        case 'ec2':
+            await ec2Command(positionalArgs[0], positionalArgs.slice(1), options);
+            break;
+        case 's3':
+            await s3Command(positionalArgs[0], positionalArgs.slice(1), options);
+            break;
+        case 'rds':
+            await rdsCommand(positionalArgs[0], positionalArgs.slice(1), options);
+            break;
+        case 'lambda':
+            await lambdaCommand(positionalArgs[0], positionalArgs.slice(1), options);
+            break;
+        case 'iam':
+            await iamCommand(positionalArgs[0], positionalArgs.slice(1), options);
+            break;
+        case 'vpc':
+            await vpcCommand(positionalArgs[0], positionalArgs.slice(1), options);
+            break;
+        default:
+            showAwsHelp();
+            break;
+    }
+}
+/**
+ * Show AWS command help
+ */
+function showAwsHelp() {
+    ui.header('Nimbus AWS Commands');
+    ui.newLine();
+    ui.print('Usage: nimbus aws <service> <action> [options]');
+    ui.newLine();
+    ui.print(ui.bold('Services:'));
+    ui.print('  ec2      EC2 instance operations');
+    ui.print('  s3       S3 bucket and object operations');
+    ui.print('  rds      RDS database operations');
+    ui.print('  lambda   Lambda function operations');
+    ui.print('  iam      IAM user, role, and policy operations');
+    ui.print('  vpc      VPC and networking operations');
+    ui.newLine();
+    ui.print(ui.bold('Common Options:'));
+    ui.print('  --profile, -p   AWS profile to use');
+    ui.print('  --region, -r    AWS region');
+    ui.print('  --output, -o    Output format (json, table, text)');
+    ui.newLine();
+    ui.print(ui.bold('Examples:'));
+    ui.print('  nimbus aws ec2 list                    List all EC2 instances');
+    ui.print('  nimbus aws ec2 describe i-1234567890   Describe specific instance');
+    ui.print('  nimbus aws s3 ls                       List all S3 buckets');
+    ui.print('  nimbus aws s3 ls my-bucket             List objects in bucket');
+    ui.print('  nimbus aws rds list                    List all RDS instances');
+    ui.print('  nimbus aws lambda list                 List all Lambda functions');
+}
+// Re-export subcommands
+export { ec2Command } from './ec2';
+export { s3Command } from './s3';
+export { rdsCommand } from './rds';
+export { lambdaCommand } from './lambda';
+export { iamCommand } from './iam';
+export { vpcCommand } from './vpc';
+export default awsCommand;

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

@@ -0,0 +1,317 @@
+/**
+ * AWS Lambda Commands
+ *
+ * Lambda function operations
+ *
+ * Usage:
+ *   nimbus aws lambda list
+ *   nimbus aws lambda invoke <function-name>
+ *   nimbus aws lambda logs <function-name>
+ */
+import { logger } from '../../utils';
+import { ui } from '../../wizard/ui';
+import { confirm, input } from '../../wizard/prompts';
+/**
+ * Lambda command router
+ */
+export async function lambdaCommand(action, args, options) {
+    logger.info('Running Lambda command', { action, args, options });
+    switch (action) {
+        case 'list':
+        case 'ls':
+            await listFunctions(options);
+            break;
+        case 'invoke':
+            if (!args[0]) {
+                ui.error('Function name is required');
+                ui.print('Usage: nimbus aws lambda invoke <function-name>');
+                return;
+            }
+            await invokeFunction(args[0], args[1], options);
+            break;
+        case 'logs':
+            if (!args[0]) {
+                ui.error('Function name is required');
+                ui.print('Usage: nimbus aws lambda logs <function-name>');
+                return;
+            }
+            await getFunctionLogs(args[0], options);
+            break;
+        default:
+            showLambdaHelp();
+            break;
+    }
+}
+/**
+ * List all Lambda functions
+ */
+async function listFunctions(options) {
+    ui.header('Lambda Functions');
+    ui.startSpinner({ message: 'Fetching Lambda functions...' });
+    try {
+        const result = await runAwsCommand('lambda list-functions', options);
+        const functions = result.Functions || [];
+        ui.stopSpinnerSuccess(`Found ${functions.length} function(s)`);
+        ui.newLine();
+        if (functions.length === 0) {
+            ui.info('No Lambda functions found');
+            return;
+        }
+        // Display table
+        displayFunctionTable(functions);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to list functions');
+        ui.error(error.message);
+    }
+}
+/**
+ * Invoke a Lambda function
+ */
+async function invokeFunction(functionName, payload, options) {
+    ui.header(`Invoke Lambda: ${functionName}`);
+    // Get payload if not provided
+    let invokePayload = payload;
+    if (!invokePayload) {
+        invokePayload = await input({
+            message: 'Enter payload (JSON):',
+            defaultValue: '{}',
+        });
+    }
+    // Validate JSON
+    try {
+        JSON.parse(invokePayload);
+    }
+    catch {
+        ui.error('Invalid JSON payload');
+        return;
+    }
+    const proceed = await confirm({
+        message: `Invoke function ${functionName}?`,
+        defaultValue: true,
+    });
+    if (!proceed) {
+        ui.info('Operation cancelled');
+        return;
+    }
+    ui.startSpinner({ message: 'Invoking function...' });
+    try {
+        const { execFile } = await import('child_process');
+        const { promisify } = await import('util');
+        const fs = await import('fs/promises');
+        const os = await import('os');
+        const path = await import('path');
+        const execFileAsync = promisify(execFile);
+        // Write payload to temp file
+        const tempFile = path.join(os.tmpdir(), `lambda-payload-${Date.now()}.json`);
+        await fs.writeFile(tempFile, invokePayload);
+        // Invoke Lambda
+        const args = [
+            'lambda',
+            'invoke',
+            '--function-name',
+            functionName,
+            '--payload',
+            `file://${tempFile}`,
+            '--cli-binary-format',
+            'raw-in-base64-out',
+        ];
+        if (options.profile) {
+            args.push('--profile', options.profile);
+        }
+        if (options.region) {
+            args.push('--region', options.region);
+        }
+        const outputFile = path.join(os.tmpdir(), `lambda-response-${Date.now()}.json`);
+        args.push(outputFile);
+        const { stdout } = await execFileAsync('aws', args);
+        ui.stopSpinnerSuccess('Function invoked');
+        ui.newLine();
+        // Parse invocation result
+        const result = JSON.parse(stdout);
+        ui.print(ui.bold('Invocation Result:'));
+        ui.print(`  Status Code: ${result.StatusCode}`);
+        if (result.FunctionError) {
+            ui.print(`  Error: ${ui.color(result.FunctionError, 'red')}`);
+        }
+        // Read response
+        try {
+            const response = await fs.readFile(outputFile, 'utf-8');
+            ui.newLine();
+            ui.print(ui.bold('Response:'));
+            ui.print(response);
+        }
+        catch {
+            // No response file
+        }
+        // Cleanup
+        await fs.unlink(tempFile).catch(() => { });
+        await fs.unlink(outputFile).catch(() => { });
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Invocation failed');
+        ui.error(error.message);
+    }
+}
+/**
+ * Get Lambda function logs
+ */
+async function getFunctionLogs(functionName, options) {
+    ui.header(`Lambda Logs: ${functionName}`);
+    ui.startSpinner({ message: 'Fetching logs...' });
+    try {
+        const { execFile } = await import('child_process');
+        const { promisify } = await import('util');
+        const execFileAsync = promisify(execFile);
+        // Get log group name
+        const logGroupName = `/aws/lambda/${functionName}`;
+        // Fetch recent log streams
+        const args = [
+            'logs',
+            'describe-log-streams',
+            '--log-group-name',
+            logGroupName,
+            '--order-by',
+            'LastEventTime',
+            '--descending',
+            '--limit',
+            '1',
+            '--output',
+            'json',
+        ];
+        if (options.profile) {
+            args.push('--profile', options.profile);
+        }
+        if (options.region) {
+            args.push('--region', options.region);
+        }
+        const { stdout: streamsOutput } = await execFileAsync('aws', args);
+        const streams = JSON.parse(streamsOutput);
+        if (!streams.logStreams || streams.logStreams.length === 0) {
+            ui.stopSpinnerSuccess('');
+            ui.info('No log streams found');
+            return;
+        }
+        const latestStream = streams.logStreams[0].logStreamName;
+        // Fetch log events
+        const logArgs = [
+            'logs',
+            'get-log-events',
+            '--log-group-name',
+            logGroupName,
+            '--log-stream-name',
+            latestStream,
+            '--limit',
+            '50',
+            '--output',
+            'json',
+        ];
+        if (options.profile) {
+            logArgs.push('--profile', options.profile);
+        }
+        if (options.region) {
+            logArgs.push('--region', options.region);
+        }
+        const { stdout: logsOutput } = await execFileAsync('aws', logArgs);
+        const logs = JSON.parse(logsOutput);
+        ui.stopSpinnerSuccess('Logs retrieved');
+        ui.newLine();
+        if (!logs.events || logs.events.length === 0) {
+            ui.info('No log events found');
+            return;
+        }
+        ui.print(ui.bold(`Recent logs from: ${latestStream}`));
+        ui.newLine();
+        for (const event of logs.events) {
+            const timestamp = new Date(event.timestamp).toISOString();
+            ui.print(`${ui.dim(timestamp)} ${event.message.trim()}`);
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to fetch logs');
+        ui.error(error.message);
+    }
+}
+/**
+ * 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 functions in a table format
+ */
+function displayFunctionTable(functions) {
+    const headers = ['Name', 'Runtime', 'Memory', 'Timeout', 'Code Size', 'Modified'];
+    const rows = functions.map(fn => [
+        fn.FunctionName,
+        fn.Runtime || 'N/A',
+        `${fn.MemorySize} MB`,
+        `${fn.Timeout}s`,
+        formatBytes(fn.CodeSize),
+        new Date(fn.LastModified).toLocaleDateString(),
+    ]);
+    // 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));
+            return cell.padEnd(maxWidth);
+        })
+            .join('  ');
+        ui.print(formattedRow);
+    }
+}
+/**
+ * Format bytes to human readable
+ */
+function formatBytes(bytes) {
+    if (bytes === 0) {
+        return '0 B';
+    }
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
+}
+/**
+ * Show Lambda command help
+ */
+function showLambdaHelp() {
+    ui.print('Usage: nimbus aws lambda <action> [args]');
+    ui.newLine();
+    ui.print(ui.bold('Actions:'));
+    ui.print('  list                  List all Lambda functions');
+    ui.print('  invoke <name>         Invoke a function');
+    ui.print('  logs <name>           View function logs');
+    ui.newLine();
+    ui.print(ui.bold('Examples:'));
+    ui.print('  nimbus aws lambda list');
+    ui.print('  nimbus aws lambda invoke my-function \'{"key": "value"}\'');
+    ui.print('  nimbus aws lambda logs my-function');
+}
+export default lambdaCommand;