@build-astron-co/nimbus 0.2.0 → 0.4.0

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

@@ -0,0 +1,105 @@
+/**
+ * GCP CLI Commands
+ *
+ * Wrapper for Google Cloud CLI operations with enhanced output and safety checks
+ *
+ * Usage:
+ *   nimbus gcp compute list
+ *   nimbus gcp storage ls
+ *   nimbus gcp gke clusters
+ *   nimbus gcp functions list
+ *   nimbus gcp iam service-accounts
+ */
+import { logger } from '../../utils';
+import { ui } from '../../wizard/ui';
+import { computeCommand } from './compute';
+import { storageCommand } from './storage';
+import { gkeCommand } from './gke';
+import { functionsCommand } from './functions';
+import { iamCommand } from './iam';
+/**
+ * Parse common GCP options from args
+ */
+export function parseGcpOptions(args) {
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if ((arg === '--project' || arg === '-p') && args[i + 1]) {
+            options.project = args[++i];
+        }
+        else if ((arg === '--region' || arg === '-r') && args[i + 1]) {
+            options.region = args[++i];
+        }
+        else if ((arg === '--zone' || arg === '-z') && args[i + 1]) {
+            options.zone = args[++i];
+        }
+        else if ((arg === '--format' || arg === '-f') && args[i + 1]) {
+            options.format = args[++i];
+        }
+    }
+    return options;
+}
+/**
+ * Main GCP command router
+ */
+export async function gcpCommand(subcommand, args) {
+    logger.info('Running GCP command', { subcommand, args });
+    const options = parseGcpOptions(args);
+    const positionalArgs = args.filter(arg => !arg.startsWith('-') && !arg.startsWith('--'));
+    switch (subcommand) {
+        case 'compute':
+            await computeCommand(positionalArgs[0], positionalArgs.slice(1), options);
+            break;
+        case 'storage':
+            await storageCommand(positionalArgs[0], positionalArgs.slice(1), options);
+            break;
+        case 'gke':
+            await gkeCommand(positionalArgs[0], positionalArgs.slice(1), options);
+            break;
+        case 'functions':
+            await functionsCommand(positionalArgs[0], positionalArgs.slice(1), options);
+            break;
+        case 'iam':
+            await iamCommand(positionalArgs[0], positionalArgs.slice(1), options);
+            break;
+        default:
+            showGcpHelp();
+            break;
+    }
+}
+/**
+ * Show GCP command help
+ */
+function showGcpHelp() {
+    ui.header('Nimbus GCP Commands');
+    ui.newLine();
+    ui.print('Usage: nimbus gcp <service> <action> [options]');
+    ui.newLine();
+    ui.print(ui.bold('Services:'));
+    ui.print('  compute     Compute Engine operations');
+    ui.print('  storage     Cloud Storage operations');
+    ui.print('  gke         Google Kubernetes Engine operations');
+    ui.print('  functions   Cloud Functions operations');
+    ui.print('  iam         IAM service accounts and roles');
+    ui.newLine();
+    ui.print(ui.bold('Common Options:'));
+    ui.print('  --project, -p   GCP project ID');
+    ui.print('  --region, -r    GCP region');
+    ui.print('  --zone, -z      GCP zone');
+    ui.print('  --format, -f    Output format (json, table, text)');
+    ui.newLine();
+    ui.print(ui.bold('Examples:'));
+    ui.print('  nimbus gcp compute list                    List all Compute Engine instances');
+    ui.print('  nimbus gcp compute describe my-instance    Describe specific instance');
+    ui.print('  nimbus gcp storage ls                      List all Cloud Storage buckets');
+    ui.print('  nimbus gcp storage ls gs://my-bucket       List objects in bucket');
+    ui.print('  nimbus gcp gke clusters                    List GKE clusters');
+    ui.print('  nimbus gcp functions list                  List Cloud Functions');
+}
+// Re-export subcommands
+export { computeCommand } from './compute';
+export { storageCommand } from './storage';
+export { gkeCommand } from './gke';
+export { functionsCommand } from './functions';
+export { iamCommand } from './iam';
+export default gcpCommand;

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

@@ -0,0 +1,232 @@
+/**
+ * GCP Cloud Storage CLI Commands
+ *
+ * Operations for Cloud Storage buckets and objects
+ */
+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: 'gcp',
+        environment: options.project || 'default',
+        resources: [target],
+        metadata: {
+            resourceType: 'storage',
+            resourceId: target,
+        },
+    };
+    return evaluateSafety(context, safetyPolicy);
+}
+/**
+ * Main Cloud Storage command router
+ */
+export async function storageCommand(action, args, options) {
+    logger.info('Running GCP Storage command', { action, args, options });
+    switch (action) {
+        case 'ls':
+            await listBucketsOrObjects(args[0], options);
+            break;
+        case 'cp':
+            if (args.length < 2) {
+                ui.error('Source and destination required');
+                return;
+            }
+            await copyObject(args[0], args[1], options);
+            break;
+        case 'rm':
+            if (!args[0]) {
+                ui.error('Object path required');
+                return;
+            }
+            await removeObject(args[0], options);
+            break;
+        case 'mb':
+            if (!args[0]) {
+                ui.error('Bucket name required');
+                return;
+            }
+            await makeBucket(args[0], options);
+            break;
+        case 'rb':
+            if (!args[0]) {
+                ui.error('Bucket name required');
+                return;
+            }
+            await removeBucket(args[0], options);
+            break;
+        default:
+            showStorageHelp();
+            break;
+    }
+}
+/**
+ * List buckets or objects
+ */
+async function listBucketsOrObjects(path, _options) {
+    const gsutilArgs = ['ls'];
+    if (path) {
+        gsutilArgs.push(path);
+    }
+    try {
+        ui.startSpinner({ message: path ? `Listing objects in ${path}...` : 'Listing buckets...' });
+        const { stdout } = await execFileAsync('gsutil', gsutilArgs);
+        ui.stopSpinnerSuccess(path ? `Objects in ${path}` : 'Buckets listed');
+        const items = stdout.trim().split('\n').filter(Boolean);
+        if (items.length === 0) {
+            ui.info(path ? 'No objects found' : 'No buckets found');
+            return;
+        }
+        ui.header(path ? `Objects in ${path}` : 'Cloud Storage Buckets');
+        ui.newLine();
+        ui.print(`Found ${items.length} item(s)\n`);
+        for (const item of items) {
+            if (item.startsWith('gs://')) {
+                // Bucket
+                ui.print(`  ${ui.color(item, 'cyan')}`);
+            }
+            else {
+                // Object
+                ui.print(`  ${item}`);
+            }
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to list');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to list storage', { error: message });
+        ui.error(`Failed to list: ${message}`);
+    }
+}
+/**
+ * Copy objects
+ */
+async function copyObject(source, destination, _options) {
+    const gsutilArgs = ['cp', source, destination];
+    try {
+        ui.startSpinner({ message: `Copying ${source} to ${destination}...` });
+        await execFileAsync('gsutil', gsutilArgs);
+        ui.stopSpinnerSuccess(`Copied ${source} to ${destination}`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to copy');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to copy object', { error: message });
+        ui.error(`Failed to copy: ${message}`);
+    }
+}
+/**
+ * Remove an object (requires safety approval)
+ */
+async function removeObject(path, options) {
+    // Run safety checks
+    const safetyResult = await runStorageSafetyChecks('delete', path, options);
+    displaySafetySummary({
+        operation: `rm ${path}`,
+        risks: safetyResult.risks,
+        passed: safetyResult.passed,
+    });
+    if (safetyResult.requiresApproval) {
+        const result = await promptForApproval({
+            title: 'Remove Storage Object',
+            operation: `gsutil rm ${path}`,
+            risks: safetyResult.risks,
+        });
+        if (!result.approved) {
+            ui.warning('Operation cancelled');
+            return;
+        }
+    }
+    const gsutilArgs = ['rm', path];
+    try {
+        ui.startSpinner({ message: `Removing ${path}...` });
+        await execFileAsync('gsutil', gsutilArgs);
+        ui.stopSpinnerSuccess(`Removed ${path}`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to remove');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to remove object', { error: message });
+        ui.error(`Failed to remove: ${message}`);
+    }
+}
+/**
+ * Create a bucket
+ */
+async function makeBucket(bucketName, options) {
+    const gsutilArgs = ['mb'];
+    if (options.project) {
+        gsutilArgs.push('-p', options.project);
+    }
+    if (options.region) {
+        gsutilArgs.push('-l', options.region);
+    }
+    gsutilArgs.push(bucketName.startsWith('gs://') ? bucketName : `gs://${bucketName}`);
+    try {
+        ui.startSpinner({ message: `Creating bucket ${bucketName}...` });
+        await execFileAsync('gsutil', gsutilArgs);
+        ui.stopSpinnerSuccess(`Bucket ${bucketName} created`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to create bucket');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to create bucket', { error: message });
+        ui.error(`Failed to create bucket: ${message}`);
+    }
+}
+/**
+ * Remove a bucket (requires safety approval)
+ */
+async function removeBucket(bucketName, options) {
+    const bucket = bucketName.startsWith('gs://') ? bucketName : `gs://${bucketName}`;
+    // Run safety checks
+    const safetyResult = await runStorageSafetyChecks('delete', bucket, options);
+    displaySafetySummary({
+        operation: `rb ${bucket}`,
+        risks: safetyResult.risks,
+        passed: safetyResult.passed,
+    });
+    if (safetyResult.requiresApproval) {
+        const result = await promptForApproval({
+            title: 'Remove Storage Bucket',
+            operation: `gsutil rb ${bucket}`,
+            risks: safetyResult.risks,
+        });
+        if (!result.approved) {
+            ui.warning('Operation cancelled');
+            return;
+        }
+    }
+    const gsutilArgs = ['rb', bucket];
+    try {
+        ui.startSpinner({ message: `Removing bucket ${bucket}...` });
+        await execFileAsync('gsutil', gsutilArgs);
+        ui.stopSpinnerSuccess(`Bucket ${bucket} removed`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to remove bucket');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to remove bucket', { error: message });
+        ui.error(`Failed to remove bucket: ${message}`);
+    }
+}
+/**
+ * Show Storage help
+ */
+function showStorageHelp() {
+    ui.print(ui.bold('Cloud Storage Commands:'));
+    ui.print('  ls [gs://bucket]      List buckets or objects');
+    ui.print('  cp <src> <dst>        Copy objects');
+    ui.print('  rm <path>             Remove object (requires approval)');
+    ui.print('  mb <bucket>           Create bucket');
+    ui.print('  rb <bucket>           Remove bucket (requires approval)');
+}