@build-astron-co/nimbus 0.2.0 → 0.4.0

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

@@ -0,0 +1,266 @@
+/**
+ * GCP Compute Engine CLI Commands
+ *
+ * Operations for Compute Engine instances
+ */
+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 Compute Engine safety checks
+ */
+async function runComputeSafetyChecks(action, instanceId, options) {
+    const safetyPolicy = loadSafetyPolicy();
+    const context = {
+        operation: action,
+        type: 'gcp',
+        environment: options.project || 'default',
+        resources: [instanceId],
+        metadata: {
+            resourceType: 'compute-instance',
+            resourceId: instanceId,
+        },
+    };
+    return evaluateSafety(context, safetyPolicy);
+}
+/**
+ * Main Compute Engine command router
+ */
+export async function computeCommand(action, args, options) {
+    logger.info('Running GCP Compute command', { action, args, options });
+    switch (action) {
+        case 'list':
+            await listInstances(options);
+            break;
+        case 'describe':
+            if (!args[0]) {
+                ui.error('Instance name required');
+                return;
+            }
+            await describeInstance(args[0], options);
+            break;
+        case 'start':
+            if (!args[0]) {
+                ui.error('Instance name required');
+                return;
+            }
+            await startInstance(args[0], options);
+            break;
+        case 'stop':
+            if (!args[0]) {
+                ui.error('Instance name required');
+                return;
+            }
+            await stopInstance(args[0], options);
+            break;
+        case 'delete':
+            if (!args[0]) {
+                ui.error('Instance name required');
+                return;
+            }
+            await deleteInstance(args[0], options);
+            break;
+        default:
+            showComputeHelp();
+            break;
+    }
+}
+/**
+ * List Compute Engine instances
+ */
+async function listInstances(options) {
+    ui.header('Compute Engine Instances');
+    ui.newLine();
+    const gcloudArgs = ['compute', 'instances', 'list', '--format=json'];
+    if (options.project) {
+        gcloudArgs.push(`--project=${options.project}`);
+    }
+    if (options.zone) {
+        gcloudArgs.push(`--zones=${options.zone}`);
+    }
+    try {
+        ui.startSpinner({ message: 'Fetching instances...' });
+        const { stdout } = await execFileAsync('gcloud', gcloudArgs);
+        ui.stopSpinnerSuccess('Instances fetched');
+        const instances = JSON.parse(stdout || '[]');
+        if (instances.length === 0) {
+            ui.info('No instances found');
+            return;
+        }
+        ui.print(`Found ${instances.length} instance(s)\n`);
+        // Display table
+        ui.print(ui.color(`${'Name'.padEnd(25) + 'Zone'.padEnd(25) + 'Machine Type'.padEnd(20) + 'Status'.padEnd(12)}External IP`, 'cyan'));
+        ui.print('─'.repeat(100));
+        for (const instance of instances) {
+            const name = instance.name?.substring(0, 24) || '';
+            const zone = instance.zone?.split('/').pop()?.substring(0, 24) || '';
+            const machineType = instance.machineType?.split('/').pop()?.substring(0, 19) || '';
+            const status = instance.status || '';
+            const externalIp = instance.networkInterfaces?.[0]?.accessConfigs?.[0]?.natIP || 'None';
+            const statusColor = status === 'RUNNING'
+                ? 'green'
+                : status === 'TERMINATED'
+                    ? 'red'
+                    : status === 'STOPPING'
+                        ? 'yellow'
+                        : 'white';
+            ui.print(`${name.padEnd(25)}${zone.padEnd(25)}${machineType.padEnd(20)}${ui.color(status.padEnd(12), statusColor)}${externalIp}`);
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to fetch instances');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to list instances', { error: message });
+        ui.error(`Failed to list instances: ${message}`);
+    }
+}
+/**
+ * Describe a specific instance
+ */
+async function describeInstance(instanceName, options) {
+    ui.header(`Instance: ${instanceName}`);
+    ui.newLine();
+    const gcloudArgs = ['compute', 'instances', 'describe', instanceName, '--format=json'];
+    if (options.project) {
+        gcloudArgs.push(`--project=${options.project}`);
+    }
+    if (options.zone) {
+        gcloudArgs.push(`--zone=${options.zone}`);
+    }
+    try {
+        ui.startSpinner({ message: 'Fetching instance details...' });
+        const { stdout } = await execFileAsync('gcloud', gcloudArgs);
+        ui.stopSpinnerSuccess('Details fetched');
+        const instance = JSON.parse(stdout);
+        ui.print(ui.bold('Basic Information:'));
+        ui.print(`  Name:         ${instance.name}`);
+        ui.print(`  Zone:         ${instance.zone?.split('/').pop()}`);
+        ui.print(`  Machine Type: ${instance.machineType?.split('/').pop()}`);
+        ui.print(`  Status:       ${instance.status}`);
+        ui.print(`  Created:      ${instance.creationTimestamp}`);
+        ui.newLine();
+        ui.print(ui.bold('Network:'));
+        for (const nic of instance.networkInterfaces || []) {
+            ui.print(`  Network:      ${nic.network?.split('/').pop()}`);
+            ui.print(`  Internal IP:  ${nic.networkIP}`);
+            if (nic.accessConfigs?.[0]?.natIP) {
+                ui.print(`  External IP:  ${nic.accessConfigs[0].natIP}`);
+            }
+        }
+        ui.newLine();
+        ui.print(ui.bold('Disks:'));
+        for (const disk of instance.disks || []) {
+            ui.print(`  Name:         ${disk.source?.split('/').pop()}`);
+            ui.print(`  Boot:         ${disk.boot ? 'Yes' : 'No'}`);
+            ui.print(`  Size:         ${disk.diskSizeGb} GB`);
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to fetch details');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to describe instance', { error: message });
+        ui.error(`Failed to describe instance: ${message}`);
+    }
+}
+/**
+ * Start an instance
+ */
+async function startInstance(instanceName, options) {
+    const gcloudArgs = ['compute', 'instances', 'start', instanceName];
+    if (options.project) {
+        gcloudArgs.push(`--project=${options.project}`);
+    }
+    if (options.zone) {
+        gcloudArgs.push(`--zone=${options.zone}`);
+    }
+    try {
+        ui.startSpinner({ message: `Starting instance ${instanceName}...` });
+        await execFileAsync('gcloud', gcloudArgs);
+        ui.stopSpinnerSuccess(`Instance ${instanceName} started`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail(`Failed to start instance`);
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to start instance', { error: message });
+        ui.error(`Failed to start instance: ${message}`);
+    }
+}
+/**
+ * Stop an instance
+ */
+async function stopInstance(instanceName, options) {
+    const gcloudArgs = ['compute', 'instances', 'stop', instanceName];
+    if (options.project) {
+        gcloudArgs.push(`--project=${options.project}`);
+    }
+    if (options.zone) {
+        gcloudArgs.push(`--zone=${options.zone}`);
+    }
+    try {
+        ui.startSpinner({ message: `Stopping instance ${instanceName}...` });
+        await execFileAsync('gcloud', gcloudArgs);
+        ui.stopSpinnerSuccess(`Instance ${instanceName} stopped`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail(`Failed to stop instance`);
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to stop instance', { error: message });
+        ui.error(`Failed to stop instance: ${message}`);
+    }
+}
+/**
+ * Delete an instance (requires safety approval)
+ */
+async function deleteInstance(instanceName, options) {
+    // Run safety checks
+    const safetyResult = await runComputeSafetyChecks('delete', instanceName, options);
+    displaySafetySummary({
+        operation: `delete ${instanceName}`,
+        risks: safetyResult.risks,
+        passed: safetyResult.passed,
+    });
+    if (safetyResult.requiresApproval) {
+        const result = await promptForApproval({
+            title: 'Delete Compute Engine Instance',
+            operation: `gcloud compute instances delete ${instanceName}`,
+            risks: safetyResult.risks,
+        });
+        if (!result.approved) {
+            ui.warning('Operation cancelled');
+            return;
+        }
+    }
+    const gcloudArgs = ['compute', 'instances', 'delete', instanceName, '--quiet'];
+    if (options.project) {
+        gcloudArgs.push(`--project=${options.project}`);
+    }
+    if (options.zone) {
+        gcloudArgs.push(`--zone=${options.zone}`);
+    }
+    try {
+        ui.startSpinner({ message: `Deleting instance ${instanceName}...` });
+        await execFileAsync('gcloud', gcloudArgs);
+        ui.stopSpinnerSuccess(`Instance ${instanceName} deleted`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail(`Failed to delete instance`);
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to delete instance', { error: message });
+        ui.error(`Failed to delete instance: ${message}`);
+    }
+}
+/**
+ * Show Compute help
+ */
+function showComputeHelp() {
+    ui.print(ui.bold('Compute Engine Commands:'));
+    ui.print('  list                  List all instances');
+    ui.print('  describe <name>       Show instance details');
+    ui.print('  start <name>          Start an instance');
+    ui.print('  stop <name>           Stop an instance');
+    ui.print('  delete <name>         Delete an instance (requires approval)');
+}

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

@@ -0,0 +1,221 @@
+/**
+ * GCP Cloud Functions CLI Commands
+ *
+ * Operations for Cloud Functions
+ */
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { logger } from '../../utils';
+import { ui } from '../../wizard/ui';
+const execFileAsync = promisify(execFile);
+/**
+ * Main Cloud Functions command router
+ */
+export async function functionsCommand(action, args, options) {
+    logger.info('Running GCP Functions command', { action, args, options });
+    switch (action) {
+        case 'list':
+            await listFunctions(options);
+            break;
+        case 'describe':
+            if (!args[0]) {
+                ui.error('Function name required');
+                return;
+            }
+            await describeFunction(args[0], options);
+            break;
+        case 'call':
+            if (!args[0]) {
+                ui.error('Function name required');
+                return;
+            }
+            await callFunction(args[0], args[1], options);
+            break;
+        case 'logs':
+            if (!args[0]) {
+                ui.error('Function name required');
+                return;
+            }
+            await getFunctionLogs(args[0], options);
+            break;
+        default:
+            showFunctionsHelp();
+            break;
+    }
+}
+/**
+ * List Cloud Functions
+ */
+async function listFunctions(options) {
+    ui.header('Cloud Functions');
+    ui.newLine();
+    const gcloudArgs = ['functions', 'list', '--format=json'];
+    if (options.project) {
+        gcloudArgs.push(`--project=${options.project}`);
+    }
+    if (options.region) {
+        gcloudArgs.push(`--regions=${options.region}`);
+    }
+    try {
+        ui.startSpinner({ message: 'Fetching functions...' });
+        const { stdout } = await execFileAsync('gcloud', gcloudArgs);
+        ui.stopSpinnerSuccess('Functions fetched');
+        const functions = JSON.parse(stdout || '[]');
+        if (functions.length === 0) {
+            ui.info('No functions found');
+            return;
+        }
+        ui.print(`Found ${functions.length} function(s)\n`);
+        // Display table
+        ui.print(ui.color(`${'Name'.padEnd(30) + 'Region'.padEnd(15) + 'Runtime'.padEnd(15) + 'Trigger'.padEnd(15)}State`, 'cyan'));
+        ui.print('─'.repeat(90));
+        for (const fn of functions) {
+            const name = fn.name?.split('/').pop()?.substring(0, 29) || '';
+            const region = fn.name?.split('/')[3]?.substring(0, 14) || '';
+            const runtime = fn.runtime?.substring(0, 14) || '';
+            const trigger = fn.httpsTrigger ? 'HTTP' : fn.eventTrigger ? 'Event' : 'Unknown';
+            const state = fn.state || '';
+            const stateColor = state === 'ACTIVE'
+                ? 'green'
+                : state === 'DEPLOYING'
+                    ? 'yellow'
+                    : state === 'FAILED'
+                        ? 'red'
+                        : 'white';
+            ui.print(`${name.padEnd(30)}${region.padEnd(15)}${runtime.padEnd(15)}${trigger.padEnd(15)}${ui.color(state, stateColor)}`);
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to fetch functions');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to list functions', { error: message });
+        ui.error(`Failed to list functions: ${message}`);
+    }
+}
+/**
+ * Describe a specific function
+ */
+async function describeFunction(functionName, options) {
+    ui.header(`Function: ${functionName}`);
+    ui.newLine();
+    const gcloudArgs = ['functions', 'describe', functionName, '--format=json'];
+    if (options.project) {
+        gcloudArgs.push(`--project=${options.project}`);
+    }
+    if (options.region) {
+        gcloudArgs.push(`--region=${options.region}`);
+    }
+    try {
+        ui.startSpinner({ message: 'Fetching function details...' });
+        const { stdout } = await execFileAsync('gcloud', gcloudArgs);
+        ui.stopSpinnerSuccess('Details fetched');
+        const fn = JSON.parse(stdout);
+        ui.print(ui.bold('Basic Information:'));
+        ui.print(`  Name:           ${fn.name?.split('/').pop()}`);
+        ui.print(`  Region:         ${fn.name?.split('/')[3]}`);
+        ui.print(`  State:          ${fn.state}`);
+        ui.print(`  Runtime:        ${fn.runtime}`);
+        ui.print(`  Entry Point:    ${fn.entryPoint}`);
+        ui.newLine();
+        ui.print(ui.bold('Resources:'));
+        ui.print(`  Memory:         ${fn.availableMemoryMb} MB`);
+        ui.print(`  Timeout:        ${fn.timeout}`);
+        ui.print(`  Max Instances:  ${fn.maxInstances || 'default'}`);
+        ui.newLine();
+        ui.print(ui.bold('Trigger:'));
+        if (fn.httpsTrigger) {
+            ui.print(`  Type:           HTTP`);
+            ui.print(`  URL:            ${fn.httpsTrigger.url}`);
+        }
+        else if (fn.eventTrigger) {
+            ui.print(`  Type:           Event`);
+            ui.print(`  Event Type:     ${fn.eventTrigger.eventType}`);
+            ui.print(`  Resource:       ${fn.eventTrigger.resource}`);
+        }
+        ui.newLine();
+        ui.print(ui.bold('Timestamps:'));
+        ui.print(`  Created:        ${fn.buildId ? `Build ID: ${fn.buildId}` : 'N/A'}`);
+        ui.print(`  Updated:        ${fn.updateTime}`);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to fetch details');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to describe function', { error: message });
+        ui.error(`Failed to describe function: ${message}`);
+    }
+}
+/**
+ * Call a function
+ */
+async function callFunction(functionName, data, options) {
+    const gcloudArgs = ['functions', 'call', functionName];
+    if (data) {
+        gcloudArgs.push('--data', data);
+    }
+    if (options.project) {
+        gcloudArgs.push(`--project=${options.project}`);
+    }
+    if (options.region) {
+        gcloudArgs.push(`--region=${options.region}`);
+    }
+    try {
+        ui.startSpinner({ message: `Calling function ${functionName}...` });
+        const { stdout, stderr } = await execFileAsync('gcloud', gcloudArgs);
+        ui.stopSpinnerSuccess('Function invoked');
+        ui.newLine();
+        if (stdout) {
+            ui.print(ui.bold('Response:'));
+            ui.print(stdout);
+        }
+        if (stderr) {
+            ui.print(ui.bold('Execution ID:'));
+            ui.print(stderr);
+        }
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to call function');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to call function', { error: message });
+        ui.error(`Failed to call function: ${message}`);
+    }
+}
+/**
+ * Get function logs
+ */
+async function getFunctionLogs(functionName, options) {
+    ui.header(`Logs for ${functionName}`);
+    ui.newLine();
+    const gcloudArgs = ['functions', 'logs', 'read', functionName, '--limit=50'];
+    if (options.project) {
+        gcloudArgs.push(`--project=${options.project}`);
+    }
+    if (options.region) {
+        gcloudArgs.push(`--region=${options.region}`);
+    }
+    try {
+        ui.startSpinner({ message: 'Fetching logs...' });
+        const { stdout } = await execFileAsync('gcloud', gcloudArgs);
+        ui.stopSpinnerSuccess('Logs fetched');
+        if (!stdout.trim()) {
+            ui.info('No logs found');
+            return;
+        }
+        ui.print(stdout);
+    }
+    catch (error) {
+        ui.stopSpinnerFail('Failed to fetch logs');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        logger.error('Failed to get logs', { error: message });
+        ui.error(`Failed to get logs: ${message}`);
+    }
+}
+/**
+ * Show Functions help
+ */
+function showFunctionsHelp() {
+    ui.print(ui.bold('Cloud Functions Commands:'));
+    ui.print('  list                        List all functions');
+    ui.print('  describe <name>             Show function details');
+    ui.print('  call <name> [data]          Invoke a function');
+    ui.print('  logs <name>                 View function logs');
+}