@build-astron-co/nimbus 0.2.0 → 0.4.0

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

@@ -0,0 +1,402 @@
+/**
+ * AWS EC2 Commands
+ *
+ * EC2 instance operations with cost warnings before billable actions
+ *
+ * Usage:
+ *   nimbus aws ec2 list
+ *   nimbus aws ec2 describe <instance-id>
+ *   nimbus aws ec2 start <instance-id>
+ *   nimbus aws ec2 stop <instance-id>
+ *   nimbus aws ec2 terminate <instance-id>
+ */
+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';
+/**
+ * EC2 command router
+ */
+export async function ec2Command(action, args, options) {
+    logger.info('Running EC2 command', { action, args, options });
+    switch (action) {
+        case 'list':
+        case 'ls':
+            await listInstances(options);
+            break;
+        case 'describe':
+            if (!args[0]) {
+                ui.error('Instance ID is required');
+                ui.print('Usage: nimbus aws ec2 describe <instance-id>');
+                return;
+            }
+            await describeInstance(args[0], options);
+            break;
+        case 'start':
+            if (!args[0]) {
+                ui.error('Instance ID is required');
+                ui.print('Usage: nimbus aws ec2 start <instance-id>');
+                return;
+            }
+            await startInstance(args[0], options);
+            break;
+        case 'stop':
+            if (!args[0]) {
+                ui.error('Instance ID is required');
+                ui.print('Usage: nimbus aws ec2 stop <instance-id>');
+                return;
+            }
+            await stopInstance(args[0], options);
+            break;
+        case 'terminate':
+            if (!args[0]) {
+                ui.error('Instance ID is required');
+                ui.print('Usage: nimbus aws ec2 terminate <instance-id>');
+                return;
+            }
+            await terminateInstance(args[0], options);
+            break;
+        default:
+            showEc2Help();
+            break;
+    }
+}
+/**
+ * List all EC2 instances
+ */
+async function listInstances(options) {
+    ui.header('EC2 Instances');
+    ui.startSpinner({ message: 'Fetching EC2 instances...' });
+    try {
+        const instances = await runAwsCommand('ec2 describe-instances --query "Reservations[].Instances[]"', options);
+        ui.stopSpinnerSuccess(`Found ${instances.length} instance(s)`);
+        ui.newLine();
+        if (instances.length === 0) {
+            ui.info('No EC2 instances found');
+            return;
+        }
+        // Display table
+        displayInstanceTable(instances);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to list instances');
+        ui.error(error.message);
+    }
+}
+/**
+ * Describe a specific EC2 instance
+ */
+async function describeInstance(instanceId, options) {
+    ui.header(`EC2 Instance: ${instanceId}`);
+    ui.startSpinner({ message: 'Fetching instance details...' });
+    try {
+        const instances = await runAwsCommand(`ec2 describe-instances --instance-ids ${instanceId} --query "Reservations[].Instances[]"`, options);
+        ui.stopSpinnerSuccess('Instance details retrieved');
+        ui.newLine();
+        if (instances.length === 0) {
+            ui.error(`Instance ${instanceId} not found`);
+            return;
+        }
+        const instance = instances[0];
+        // Display instance details
+        ui.print(ui.bold('Instance Details:'));
+        ui.newLine();
+        ui.print(`  Instance ID:     ${instance.InstanceId}`);
+        ui.print(`  Instance Type:   ${instance.InstanceType}`);
+        ui.print(`  State:           ${formatState(instance.State.Name)}`);
+        ui.print(`  Public IP:       ${instance.PublicIpAddress || 'N/A'}`);
+        ui.print(`  Private IP:      ${instance.PrivateIpAddress || 'N/A'}`);
+        ui.print(`  Launch Time:     ${instance.LaunchTime || 'N/A'}`);
+        if (instance.Tags && instance.Tags.length > 0) {
+            ui.newLine();
+            ui.print(ui.bold('Tags:'));
+            for (const tag of instance.Tags) {
+                ui.print(`  ${tag.Key}: ${tag.Value}`);
+            }
+        }
+        // Show cost estimate for running instances
+        displayCostWarning(instance.InstanceType);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to describe instance');
+        ui.error(error.message);
+    }
+}
+/**
+ * Display a cost warning for an EC2 instance type using the cloud cost estimator.
+ */
+function displayCostWarning(instanceType) {
+    const estimate = estimateCloudCost('ec2:StartInstances', { instanceType });
+    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, approximate)`);
+        ui.newLine();
+    }
+}
+/**
+ * Start an EC2 instance
+ */
+async function startInstance(instanceId, options) {
+    ui.header(`Start EC2 Instance: ${instanceId}`);
+    // Try to get instance type for cost estimate
+    try {
+        const instances = await runAwsCommand(`ec2 describe-instances --instance-ids ${instanceId} --query "Reservations[].Instances[]"`, options);
+        if (instances.length > 0) {
+            const instanceType = instances[0].InstanceType;
+            const estimate = estimateCloudCost('ec2:StartInstances', { instanceType });
+            if (estimate) {
+                ui.newLine();
+                ui.warning(formatCostWarning(estimate));
+                ui.newLine();
+            }
+        }
+    }
+    catch {
+        // Non-critical, continue without cost estimate
+    }
+    // Confirm action
+    const proceed = await confirm({
+        message: `Start instance ${instanceId}?`,
+        defaultValue: true,
+    });
+    if (!proceed) {
+        ui.info('Operation cancelled');
+        return;
+    }
+    ui.startSpinner({ message: 'Starting instance...' });
+    try {
+        await runAwsCommand(`ec2 start-instances --instance-ids ${instanceId}`, options);
+        ui.stopSpinnerSuccess('Instance started');
+        ui.info(`Instance ${instanceId} is now starting`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to start instance');
+        ui.error(error.message);
+    }
+}
+/**
+ * Stop an EC2 instance
+ */
+async function stopInstance(instanceId, options) {
+    ui.header(`Stop EC2 Instance: ${instanceId}`);
+    // Show cost estimate for the instance being stopped
+    try {
+        const instances = await runAwsCommand(`ec2 describe-instances --instance-ids ${instanceId} --query "Reservations[].Instances[]"`, options);
+        if (instances.length > 0) {
+            displayCostWarning(instances[0].InstanceType);
+            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', instanceId, options);
+    if (!safetyResult.passed) {
+        ui.error('Safety checks failed');
+        return;
+    }
+    if (safetyResult.requiresApproval) {
+        const approval = await promptForApproval({
+            title: 'Stop EC2 Instance',
+            operation: `ec2 stop ${instanceId}`,
+            risks: safetyResult.risks,
+        });
+        if (!approval.approved) {
+            ui.info('Operation cancelled');
+            return;
+        }
+    }
+    else {
+        const proceed = await confirm({
+            message: `Stop instance ${instanceId}?`,
+            defaultValue: false,
+        });
+        if (!proceed) {
+            ui.info('Operation cancelled');
+            return;
+        }
+    }
+    ui.startSpinner({ message: 'Stopping instance...' });
+    try {
+        await runAwsCommand(`ec2 stop-instances --instance-ids ${instanceId}`, options);
+        ui.stopSpinnerSuccess('Instance stopped');
+        ui.info(`Instance ${instanceId} is now stopping`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to stop instance');
+        ui.error(error.message);
+    }
+}
+/**
+ * Terminate an EC2 instance
+ */
+async function terminateInstance(instanceId, options) {
+    ui.header(`Terminate EC2 Instance: ${instanceId}`);
+    ui.warning('This action cannot be undone!');
+    ui.newLine();
+    // Show cost estimate for the instance being terminated
+    try {
+        const instances = await runAwsCommand(`ec2 describe-instances --instance-ids ${instanceId} --query "Reservations[].Instances[]"`, options);
+        if (instances.length > 0) {
+            displayCostWarning(instances[0].InstanceType);
+            ui.info('Terminating this instance will permanently stop all charges.');
+            ui.newLine();
+        }
+    }
+    catch {
+        // Non-critical, continue without cost estimate
+    }
+    // Run safety checks
+    const safetyResult = await runSafetyCheck('terminate', instanceId, options);
+    if (!safetyResult.passed) {
+        ui.error('Safety checks failed - operation blocked');
+        for (const blocker of safetyResult.blockers) {
+            ui.print(`  ${ui.color('x', 'red')} ${blocker.message}`);
+        }
+        return;
+    }
+    // Always require approval for terminate
+    const approval = await promptForApproval({
+        title: 'Terminate EC2 Instance',
+        operation: `ec2 terminate ${instanceId}`,
+        risks: safetyResult.risks,
+        requireConfirmation: true,
+        confirmationWord: 'terminate',
+    });
+    if (!approval.approved) {
+        ui.info('Operation cancelled');
+        return;
+    }
+    ui.startSpinner({ message: 'Terminating instance...' });
+    try {
+        await runAwsCommand(`ec2 terminate-instances --instance-ids ${instanceId}`, options);
+        ui.stopSpinnerSuccess('Instance terminated');
+        ui.info(`Instance ${instanceId} has been terminated`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to terminate instance');
+        ui.error(error.message);
+    }
+}
+/**
+ * Run safety check for EC2 operation
+ */
+async function runSafetyCheck(operation, instanceId, options) {
+    const policy = loadSafetyPolicy();
+    const context = {
+        operation,
+        type: 'aws',
+        resources: [instanceId],
+        metadata: {
+            service: 'ec2',
+            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) {
+    // Calculate column widths
+    const headers = ['Instance ID', 'Name', 'Type', 'State', 'Public IP', 'Private IP'];
+    const rows = instances.map(inst => {
+        const nameTag = inst.Tags?.find(t => t.Key === 'Name');
+        return [
+            inst.InstanceId,
+            nameTag?.Value || '-',
+            inst.InstanceType,
+            inst.State.Name,
+            inst.PublicIpAddress || '-',
+            inst.PrivateIpAddress || '-',
+        ];
+    });
+    // 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) {
+                // State column - colorize
+                return formatState(cell).padEnd(maxWidth + 10); // Extra for color codes
+            }
+            return cell.padEnd(maxWidth);
+        })
+            .join('  ');
+        ui.print(formattedRow);
+    }
+}
+/**
+ * Format instance state with color
+ */
+function formatState(state) {
+    switch (state) {
+        case 'running':
+            return ui.color(state, 'green');
+        case 'stopped':
+            return ui.color(state, 'red');
+        case 'pending':
+        case 'stopping':
+            return ui.color(state, 'yellow');
+        case 'terminated':
+            return ui.color(state, 'gray');
+        default:
+            return state;
+    }
+}
+/**
+ * Show EC2 command help
+ */
+function showEc2Help() {
+    ui.print('Usage: nimbus aws ec2 <action> [args]');
+    ui.newLine();
+    ui.print(ui.bold('Actions:'));
+    ui.print('  list                  List all EC2 instances');
+    ui.print('  describe <id>         Describe a specific instance');
+    ui.print('  start <id>            Start an instance');
+    ui.print('  stop <id>             Stop an instance');
+    ui.print('  terminate <id>        Terminate an instance (requires approval)');
+    ui.newLine();
+    ui.print(ui.bold('Examples:'));
+    ui.print('  nimbus aws ec2 list');
+    ui.print('  nimbus aws ec2 describe i-1234567890abcdef0');
+    ui.print('  nimbus aws ec2 stop i-1234567890abcdef0');
+}
+export default ec2Command;

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

@@ -0,0 +1,304 @@
+/**
+ * AWS IAM Commands
+ *
+ * IAM user, role, and policy operations
+ *
+ * Usage:
+ *   nimbus aws iam users
+ *   nimbus aws iam roles
+ *   nimbus aws iam policies
+ */
+import { logger } from '../../utils';
+import { ui } from '../../wizard/ui';
+/**
+ * IAM command router
+ */
+export async function iamCommand(action, args, options) {
+    logger.info('Running IAM command', { action, args, options });
+    switch (action) {
+        case 'users':
+            await listUsers(options);
+            break;
+        case 'roles':
+            await listRoles(options);
+            break;
+        case 'policies':
+            await listPolicies(options);
+            break;
+        case 'user':
+            if (!args[0]) {
+                ui.error('User name is required');
+                ui.print('Usage: nimbus aws iam user <username>');
+                return;
+            }
+            await describeUser(args[0], options);
+            break;
+        case 'role':
+            if (!args[0]) {
+                ui.error('Role name is required');
+                ui.print('Usage: nimbus aws iam role <rolename>');
+                return;
+            }
+            await describeRole(args[0], options);
+            break;
+        default:
+            showIamHelp();
+            break;
+    }
+}
+/**
+ * List all IAM users
+ */
+async function listUsers(options) {
+    ui.header('IAM Users');
+    ui.startSpinner({ message: 'Fetching IAM users...' });
+    try {
+        const result = await runAwsCommand('iam list-users', options);
+        const users = result.Users || [];
+        ui.stopSpinnerSuccess(`Found ${users.length} user(s)`);
+        ui.newLine();
+        if (users.length === 0) {
+            ui.info('No IAM users found');
+            return;
+        }
+        // Display table
+        const headers = ['Username', 'User ID', 'Created', 'Last Login'];
+        const rows = users.map(user => [
+            user.UserName,
+            user.UserId,
+            new Date(user.CreateDate).toLocaleDateString(),
+            user.PasswordLastUsed ? new Date(user.PasswordLastUsed).toLocaleDateString() : 'Never',
+        ]);
+        displayTable(headers, rows);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to list users');
+        ui.error(error.message);
+    }
+}
+/**
+ * List all IAM roles
+ */
+async function listRoles(options) {
+    ui.header('IAM Roles');
+    ui.startSpinner({ message: 'Fetching IAM roles...' });
+    try {
+        const result = await runAwsCommand('iam list-roles', options);
+        const roles = result.Roles || [];
+        ui.stopSpinnerSuccess(`Found ${roles.length} role(s)`);
+        ui.newLine();
+        if (roles.length === 0) {
+            ui.info('No IAM roles found');
+            return;
+        }
+        // Display table (filter out AWS service roles by default)
+        const customRoles = roles.filter(r => !r.RoleName.startsWith('AWS'));
+        const headers = ['Role Name', 'Role ID', 'Created', 'Description'];
+        const rows = customRoles.map(role => [
+            role.RoleName,
+            role.RoleId,
+            new Date(role.CreateDate).toLocaleDateString(),
+            role.Description || '-',
+        ]);
+        displayTable(headers, rows);
+        if (customRoles.length < roles.length) {
+            ui.newLine();
+            ui.dim(`(${roles.length - customRoles.length} AWS service roles hidden)`);
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to list roles');
+        ui.error(error.message);
+    }
+}
+/**
+ * List all IAM policies
+ */
+async function listPolicies(options) {
+    ui.header('IAM Policies');
+    ui.startSpinner({ message: 'Fetching IAM policies...' });
+    try {
+        const result = await runAwsCommand('iam list-policies --scope Local', options);
+        const policies = result.Policies || [];
+        ui.stopSpinnerSuccess(`Found ${policies.length} custom policy(ies)`);
+        ui.newLine();
+        if (policies.length === 0) {
+            ui.info('No custom IAM policies found');
+            return;
+        }
+        // Display table
+        const headers = ['Policy Name', 'Policy ID', 'Attachments', 'Created'];
+        const rows = policies.map(policy => [
+            policy.PolicyName,
+            policy.PolicyId,
+            String(policy.AttachmentCount),
+            new Date(policy.CreateDate).toLocaleDateString(),
+        ]);
+        displayTable(headers, rows);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to list policies');
+        ui.error(error.message);
+    }
+}
+/**
+ * Describe a specific IAM user
+ */
+async function describeUser(userName, options) {
+    ui.header(`IAM User: ${userName}`);
+    ui.startSpinner({ message: 'Fetching user details...' });
+    try {
+        const { execFile } = await import('child_process');
+        const { promisify } = await import('util');
+        const execFileAsync = promisify(execFile);
+        // Get user details
+        const userArgs = ['iam', 'get-user', '--user-name', userName, '--output', 'json'];
+        if (options.profile) {
+            userArgs.push('--profile', options.profile);
+        }
+        const { stdout: userOutput } = await execFileAsync('aws', userArgs);
+        const userData = JSON.parse(userOutput);
+        const user = userData.User;
+        // Get user groups
+        const groupArgs = ['iam', 'list-groups-for-user', '--user-name', userName, '--output', 'json'];
+        if (options.profile) {
+            groupArgs.push('--profile', options.profile);
+        }
+        const { stdout: groupOutput } = await execFileAsync('aws', groupArgs);
+        const groupData = JSON.parse(groupOutput);
+        const groups = groupData.Groups || [];
+        ui.stopSpinnerSuccess('User details retrieved');
+        ui.newLine();
+        ui.print(ui.bold('User Details:'));
+        ui.newLine();
+        ui.print(`  Username:        ${user.UserName}`);
+        ui.print(`  User ID:         ${user.UserId}`);
+        ui.print(`  ARN:             ${user.Arn}`);
+        ui.print(`  Created:         ${new Date(user.CreateDate).toLocaleString()}`);
+        ui.print(`  Last Login:      ${user.PasswordLastUsed ? new Date(user.PasswordLastUsed).toLocaleString() : 'Never'}`);
+        if (groups.length > 0) {
+            ui.newLine();
+            ui.print(ui.bold('Groups:'));
+            for (const group of groups) {
+                ui.print(`  - ${group.GroupName}`);
+            }
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to describe user');
+        ui.error(error.message);
+    }
+}
+/**
+ * Describe a specific IAM role
+ */
+async function describeRole(roleName, options) {
+    ui.header(`IAM Role: ${roleName}`);
+    ui.startSpinner({ message: 'Fetching role details...' });
+    try {
+        const { execFile } = await import('child_process');
+        const { promisify } = await import('util');
+        const execFileAsync = promisify(execFile);
+        // Get role details
+        const roleArgs = ['iam', 'get-role', '--role-name', roleName, '--output', 'json'];
+        if (options.profile) {
+            roleArgs.push('--profile', options.profile);
+        }
+        const { stdout: roleOutput } = await execFileAsync('aws', roleArgs);
+        const roleData = JSON.parse(roleOutput);
+        const role = roleData.Role;
+        // Get attached policies
+        const policyArgs = [
+            'iam',
+            'list-attached-role-policies',
+            '--role-name',
+            roleName,
+            '--output',
+            'json',
+        ];
+        if (options.profile) {
+            policyArgs.push('--profile', options.profile);
+        }
+        const { stdout: policyOutput } = await execFileAsync('aws', policyArgs);
+        const policyData = JSON.parse(policyOutput);
+        const policies = policyData.AttachedPolicies || [];
+        ui.stopSpinnerSuccess('Role details retrieved');
+        ui.newLine();
+        ui.print(ui.bold('Role Details:'));
+        ui.newLine();
+        ui.print(`  Role Name:       ${role.RoleName}`);
+        ui.print(`  Role ID:         ${role.RoleId}`);
+        ui.print(`  ARN:             ${role.Arn}`);
+        ui.print(`  Created:         ${new Date(role.CreateDate).toLocaleString()}`);
+        if (role.Description) {
+            ui.print(`  Description:     ${role.Description}`);
+        }
+        if (policies.length > 0) {
+            ui.newLine();
+            ui.print(ui.bold('Attached Policies:'));
+            for (const policy of policies) {
+                ui.print(`  - ${policy.PolicyName}`);
+            }
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to describe role');
+        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);
+    }
+    commandArgs.push('--output', 'json');
+    const { stdout } = await execFileAsync('aws', [baseCommand, ...commandArgs]);
+    return JSON.parse(stdout);
+}
+/**
+ * Display a table
+ */
+function displayTable(headers, rows) {
+    // Calculate column widths
+    const colWidths = headers.map((h, i) => {
+        const maxDataWidth = Math.max(...rows.map(r => (r[i] || '').length));
+        return Math.max(h.length, maxDataWidth);
+    });
+    // Print header
+    const headerRow = headers.map((h, i) => h.padEnd(colWidths[i])).join('  ');
+    ui.print(ui.bold(headerRow));
+    ui.print('-'.repeat(headerRow.length));
+    // Print rows
+    for (const row of rows) {
+        const formattedRow = row.map((cell, i) => (cell || '').padEnd(colWidths[i])).join('  ');
+        ui.print(formattedRow);
+    }
+}
+/**
+ * Show IAM command help
+ */
+function showIamHelp() {
+    ui.print('Usage: nimbus aws iam <action> [args]');
+    ui.newLine();
+    ui.print(ui.bold('Actions:'));
+    ui.print('  users             List all IAM users');
+    ui.print('  roles             List all IAM roles');
+    ui.print('  policies          List custom IAM policies');
+    ui.print('  user <name>       Describe a specific user');
+    ui.print('  role <name>       Describe a specific role');
+    ui.newLine();
+    ui.print(ui.bold('Examples:'));
+    ui.print('  nimbus aws iam users');
+    ui.print('  nimbus aws iam roles');
+    ui.print('  nimbus aws iam user admin');
+}
+export default iamCommand;