@build-astron-co/nimbus 0.2.0 → 0.4.0

package/dist/src/tools/aws-ops.js

@@ -0,0 +1,747 @@
+/**
+ * AWS Operations — Embedded tool (stripped HTTP wrappers)
+ *
+ * Merged from services/aws-tools-service/src/aws/ec2.ts, s3.ts, iam.ts
+ * Uses lazy imports for AWS SDK to keep binary size small.
+ */
+import { logger } from '../utils';
+/**
+ * Unified AWS Operations class merging EC2, S3, and IAM operations.
+ * All AWS SDK imports are lazy to minimize binary size.
+ */
+export class AwsOperations {
+    config;
+    constructor(config = {}) {
+        this.config = {
+            region: config.region || process.env.AWS_REGION || 'us-east-1',
+            accessKeyId: config.accessKeyId,
+            secretAccessKey: config.secretAccessKey,
+            sessionToken: config.sessionToken,
+        };
+    }
+    /**
+     * Build common client config
+     */
+    getClientConfig() {
+        const clientConfig = {
+            region: this.config.region,
+        };
+        if (this.config.accessKeyId && this.config.secretAccessKey) {
+            clientConfig.credentials = {
+                accessKeyId: this.config.accessKeyId,
+                secretAccessKey: this.config.secretAccessKey,
+                sessionToken: this.config.sessionToken,
+            };
+        }
+        return clientConfig;
+    }
+    // ==========================================
+    // EC2 Operations
+    // ==========================================
+    /**
+     * List EC2 instances
+     */
+    async listInstances(options = {}) {
+        try {
+            const { EC2Client, DescribeInstancesCommand } = await import('@aws-sdk/client-ec2');
+            const client = new EC2Client(this.getClientConfig());
+            const input = {};
+            if (options.instanceIds && options.instanceIds.length > 0) {
+                input.InstanceIds = options.instanceIds;
+            }
+            if (options.filters) {
+                input.Filters = Object.entries(options.filters).map(([name, values]) => ({
+                    Name: name,
+                    Values: values,
+                }));
+            }
+            if (options.maxResults) {
+                input.MaxResults = options.maxResults;
+            }
+            if (options.nextToken) {
+                input.NextToken = options.nextToken;
+            }
+            const command = new DescribeInstancesCommand(input);
+            const response = await client.send(command);
+            const instances = response.Reservations?.flatMap((r) => r.Instances?.map((i) => ({
+                instanceId: i.InstanceId,
+                instanceType: i.InstanceType,
+                state: i.State?.Name,
+                publicIpAddress: i.PublicIpAddress,
+                privateIpAddress: i.PrivateIpAddress,
+                launchTime: i.LaunchTime,
+                availabilityZone: i.Placement?.AvailabilityZone,
+                vpcId: i.VpcId,
+                subnetId: i.SubnetId,
+                imageId: i.ImageId,
+                keyName: i.KeyName,
+                tags: i.Tags?.reduce((acc, tag) => {
+                    if (tag.Key) {
+                        acc[tag.Key] = tag.Value || '';
+                    }
+                    return acc;
+                }, {}),
+            })) || []);
+            return {
+                success: true,
+                data: {
+                    instances: instances || [],
+                    nextToken: response.NextToken,
+                },
+            };
+        }
+        catch (error) {
+            logger.error('Failed to list instances', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Start EC2 instances
+     */
+    async startInstances(instanceIds) {
+        try {
+            const { EC2Client, StartInstancesCommand } = await import('@aws-sdk/client-ec2');
+            const client = new EC2Client(this.getClientConfig());
+            const command = new StartInstancesCommand({ InstanceIds: instanceIds });
+            const response = await client.send(command);
+            const results = response.StartingInstances?.map((i) => ({
+                instanceId: i.InstanceId,
+                previousState: i.PreviousState?.Name,
+                currentState: i.CurrentState?.Name,
+            }));
+            return { success: true, data: { instances: results || [] } };
+        }
+        catch (error) {
+            logger.error('Failed to start instances', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Start a single instance (convenience wrapper)
+     */
+    async startInstance(instanceId) {
+        return this.startInstances([instanceId]);
+    }
+    /**
+     * Stop EC2 instances
+     */
+    async stopInstances(instanceIds, force) {
+        try {
+            const { EC2Client, StopInstancesCommand } = await import('@aws-sdk/client-ec2');
+            const client = new EC2Client(this.getClientConfig());
+            const command = new StopInstancesCommand({ InstanceIds: instanceIds, Force: force });
+            const response = await client.send(command);
+            const results = response.StoppingInstances?.map((i) => ({
+                instanceId: i.InstanceId,
+                previousState: i.PreviousState?.Name,
+                currentState: i.CurrentState?.Name,
+            }));
+            return { success: true, data: { instances: results || [] } };
+        }
+        catch (error) {
+            logger.error('Failed to stop instances', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Stop a single instance (convenience wrapper)
+     */
+    async stopInstance(instanceId, force) {
+        return this.stopInstances([instanceId], force);
+    }
+    /**
+     * Reboot EC2 instances
+     */
+    async rebootInstances(instanceIds) {
+        try {
+            const { EC2Client, RebootInstancesCommand } = await import('@aws-sdk/client-ec2');
+            const client = new EC2Client(this.getClientConfig());
+            const command = new RebootInstancesCommand({ InstanceIds: instanceIds });
+            await client.send(command);
+            return {
+                success: true,
+                data: { message: `Reboot initiated for instances: ${instanceIds.join(', ')}` },
+            };
+        }
+        catch (error) {
+            logger.error('Failed to reboot instances', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Terminate EC2 instances
+     */
+    async terminateInstances(instanceIds) {
+        try {
+            const { EC2Client, TerminateInstancesCommand } = await import('@aws-sdk/client-ec2');
+            const client = new EC2Client(this.getClientConfig());
+            const command = new TerminateInstancesCommand({ InstanceIds: instanceIds });
+            const response = await client.send(command);
+            const results = response.TerminatingInstances?.map((i) => ({
+                instanceId: i.InstanceId,
+                previousState: i.PreviousState?.Name,
+                currentState: i.CurrentState?.Name,
+            }));
+            return { success: true, data: { instances: results || [] } };
+        }
+        catch (error) {
+            logger.error('Failed to terminate instances', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Terminate a single instance (convenience wrapper)
+     */
+    async terminateInstance(instanceId) {
+        return this.terminateInstances([instanceId]);
+    }
+    /**
+     * Describe instance status
+     */
+    async getInstanceStatus(instanceIds) {
+        try {
+            const { EC2Client, DescribeInstanceStatusCommand } = await import('@aws-sdk/client-ec2');
+            const client = new EC2Client(this.getClientConfig());
+            const command = new DescribeInstanceStatusCommand({
+                InstanceIds: instanceIds,
+                IncludeAllInstances: true,
+            });
+            const response = await client.send(command);
+            const statuses = response.InstanceStatuses?.map((s) => ({
+                instanceId: s.InstanceId,
+                instanceState: s.InstanceState?.Name,
+                instanceStatus: s.InstanceStatus?.Status,
+                systemStatus: s.SystemStatus?.Status,
+                availabilityZone: s.AvailabilityZone,
+            }));
+            return { success: true, data: { statuses: statuses || [] } };
+        }
+        catch (error) {
+            logger.error('Failed to get instance status', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * List VPCs
+     */
+    async listVpcs() {
+        try {
+            const { EC2Client, DescribeVpcsCommand } = await import('@aws-sdk/client-ec2');
+            const client = new EC2Client(this.getClientConfig());
+            const command = new DescribeVpcsCommand({});
+            const response = await client.send(command);
+            const vpcs = response.Vpcs?.map((v) => ({
+                vpcId: v.VpcId,
+                cidrBlock: v.CidrBlock,
+                state: v.State,
+                isDefault: v.IsDefault,
+                tags: v.Tags?.reduce((acc, tag) => {
+                    if (tag.Key) {
+                        acc[tag.Key] = tag.Value || '';
+                    }
+                    return acc;
+                }, {}),
+            }));
+            return { success: true, data: { vpcs: vpcs || [] } };
+        }
+        catch (error) {
+            logger.error('Failed to list VPCs', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * List subnets
+     */
+    async listSubnets(vpcId) {
+        try {
+            const { EC2Client, DescribeSubnetsCommand } = await import('@aws-sdk/client-ec2');
+            const client = new EC2Client(this.getClientConfig());
+            const input = {};
+            if (vpcId) {
+                input.Filters = [{ Name: 'vpc-id', Values: [vpcId] }];
+            }
+            const command = new DescribeSubnetsCommand(input);
+            const response = await client.send(command);
+            const subnets = response.Subnets?.map((s) => ({
+                subnetId: s.SubnetId,
+                vpcId: s.VpcId,
+                cidrBlock: s.CidrBlock,
+                availabilityZone: s.AvailabilityZone,
+                availableIpAddressCount: s.AvailableIpAddressCount,
+                defaultForAz: s.DefaultForAz,
+                tags: s.Tags?.reduce((acc, tag) => {
+                    if (tag.Key) {
+                        acc[tag.Key] = tag.Value || '';
+                    }
+                    return acc;
+                }, {}),
+            }));
+            return { success: true, data: { subnets: subnets || [] } };
+        }
+        catch (error) {
+            logger.error('Failed to list subnets', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * List security groups
+     */
+    async listSecurityGroups(vpcId) {
+        try {
+            const { EC2Client, DescribeSecurityGroupsCommand } = await import('@aws-sdk/client-ec2');
+            const client = new EC2Client(this.getClientConfig());
+            const input = {};
+            if (vpcId) {
+                input.Filters = [{ Name: 'vpc-id', Values: [vpcId] }];
+            }
+            const command = new DescribeSecurityGroupsCommand(input);
+            const response = await client.send(command);
+            const groups = response.SecurityGroups?.map((g) => ({
+                groupId: g.GroupId,
+                groupName: g.GroupName,
+                description: g.Description,
+                vpcId: g.VpcId,
+            }));
+            return { success: true, data: { securityGroups: groups || [] } };
+        }
+        catch (error) {
+            logger.error('Failed to list security groups', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * List regions
+     */
+    async listRegions() {
+        try {
+            const { EC2Client, DescribeRegionsCommand } = await import('@aws-sdk/client-ec2');
+            const client = new EC2Client(this.getClientConfig());
+            const command = new DescribeRegionsCommand({});
+            const response = await client.send(command);
+            const regions = response.Regions?.map((r) => ({
+                regionName: r.RegionName,
+                endpoint: r.Endpoint,
+            }));
+            return { success: true, data: { regions: regions || [] } };
+        }
+        catch (error) {
+            logger.error('Failed to list regions', error);
+            return { success: false, error: error.message };
+        }
+    }
+    // ==========================================
+    // S3 Operations
+    // ==========================================
+    /**
+     * List all S3 buckets
+     */
+    async listBuckets() {
+        try {
+            const { S3Client, ListBucketsCommand } = await import('@aws-sdk/client-s3');
+            const client = new S3Client(this.getClientConfig());
+            const command = new ListBucketsCommand({});
+            const response = await client.send(command);
+            const buckets = response.Buckets?.map((b) => ({
+                name: b.Name,
+                creationDate: b.CreationDate,
+            }));
+            return {
+                success: true,
+                data: {
+                    buckets: buckets || [],
+                    owner: {
+                        id: response.Owner?.ID,
+                        displayName: response.Owner?.DisplayName,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            logger.error('Failed to list buckets', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * List objects in a bucket
+     */
+    async listObjects(options) {
+        try {
+            const { S3Client, ListObjectsV2Command } = await import('@aws-sdk/client-s3');
+            const client = new S3Client(this.getClientConfig());
+            const input = { Bucket: options.bucket };
+            if (options.prefix) {
+                input.Prefix = options.prefix;
+            }
+            if (options.delimiter) {
+                input.Delimiter = options.delimiter;
+            }
+            if (options.maxKeys) {
+                input.MaxKeys = options.maxKeys;
+            }
+            if (options.continuationToken) {
+                input.ContinuationToken = options.continuationToken;
+            }
+            const command = new ListObjectsV2Command(input);
+            const response = await client.send(command);
+            const objects = response.Contents?.map((o) => ({
+                key: o.Key,
+                size: o.Size,
+                lastModified: o.LastModified,
+                etag: o.ETag,
+                storageClass: o.StorageClass,
+            }));
+            const commonPrefixes = response.CommonPrefixes?.map((p) => p.Prefix);
+            return {
+                success: true,
+                data: {
+                    objects: objects || [],
+                    commonPrefixes: commonPrefixes || [],
+                    isTruncated: response.IsTruncated,
+                    nextContinuationToken: response.NextContinuationToken,
+                    keyCount: response.KeyCount,
+                },
+            };
+        }
+        catch (error) {
+            logger.error('Failed to list objects', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Get object from bucket
+     */
+    async getObject(bucket, key) {
+        try {
+            const { S3Client, GetObjectCommand } = await import('@aws-sdk/client-s3');
+            const client = new S3Client(this.getClientConfig());
+            const command = new GetObjectCommand({ Bucket: bucket, Key: key });
+            const response = await client.send(command);
+            const body = await response.Body?.transformToString();
+            return {
+                success: true,
+                data: {
+                    body,
+                    contentType: response.ContentType,
+                    contentLength: response.ContentLength,
+                    lastModified: response.LastModified,
+                    etag: response.ETag,
+                    metadata: response.Metadata,
+                },
+            };
+        }
+        catch (error) {
+            logger.error('Failed to get object', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Put object to bucket
+     */
+    async putObject(options) {
+        try {
+            const { S3Client, PutObjectCommand } = await import('@aws-sdk/client-s3');
+            const client = new S3Client(this.getClientConfig());
+            const command = new PutObjectCommand({
+                Bucket: options.bucket,
+                Key: options.key,
+                Body: options.body,
+                ContentType: options.contentType,
+                Metadata: options.metadata,
+                Tagging: options.tags
+                    ? Object.entries(options.tags)
+                        .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+                        .join('&')
+                    : undefined,
+            });
+            const response = await client.send(command);
+            return {
+                success: true,
+                data: { etag: response.ETag, versionId: response.VersionId },
+            };
+        }
+        catch (error) {
+            logger.error('Failed to put object', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Delete object from bucket
+     */
+    async deleteObject(bucket, key) {
+        try {
+            const { S3Client, DeleteObjectCommand } = await import('@aws-sdk/client-s3');
+            const client = new S3Client(this.getClientConfig());
+            const command = new DeleteObjectCommand({ Bucket: bucket, Key: key });
+            const response = await client.send(command);
+            return {
+                success: true,
+                data: { deleteMarker: response.DeleteMarker, versionId: response.VersionId },
+            };
+        }
+        catch (error) {
+            logger.error('Failed to delete object', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Create a bucket
+     */
+    async createBucket(bucket, region) {
+        try {
+            const { S3Client, CreateBucketCommand } = await import('@aws-sdk/client-s3');
+            const targetRegion = region || this.config.region || 'us-east-1';
+            const client = new S3Client({ ...this.getClientConfig(), region: targetRegion });
+            const command = new CreateBucketCommand({
+                Bucket: bucket,
+                CreateBucketConfiguration: targetRegion !== 'us-east-1' ? { LocationConstraint: targetRegion } : undefined,
+            });
+            await client.send(command);
+            return { success: true, data: { bucket, region: targetRegion } };
+        }
+        catch (error) {
+            logger.error('Failed to create bucket', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Delete a bucket
+     */
+    async deleteBucket(bucket) {
+        try {
+            const { S3Client, DeleteBucketCommand } = await import('@aws-sdk/client-s3');
+            const client = new S3Client(this.getClientConfig());
+            const command = new DeleteBucketCommand({ Bucket: bucket });
+            await client.send(command);
+            return { success: true, data: { message: `Bucket ${bucket} deleted` } };
+        }
+        catch (error) {
+            logger.error('Failed to delete bucket', error);
+            return { success: false, error: error.message };
+        }
+    }
+    // ==========================================
+    // IAM Operations
+    // ==========================================
+    /**
+     * List IAM users
+     */
+    async listUsers(options = {}) {
+        try {
+            const { IAMClient, ListUsersCommand } = await import('@aws-sdk/client-iam');
+            const client = new IAMClient(this.getClientConfig());
+            const input = {};
+            if (options.maxItems) {
+                input.MaxItems = options.maxItems;
+            }
+            if (options.marker) {
+                input.Marker = options.marker;
+            }
+            if (options.pathPrefix) {
+                input.PathPrefix = options.pathPrefix;
+            }
+            const command = new ListUsersCommand(input);
+            const response = await client.send(command);
+            const users = response.Users?.map((u) => ({
+                userName: u.UserName,
+                userId: u.UserId,
+                arn: u.Arn,
+                path: u.Path,
+                createDate: u.CreateDate,
+                passwordLastUsed: u.PasswordLastUsed,
+            }));
+            return {
+                success: true,
+                data: {
+                    users: users || [],
+                    isTruncated: response.IsTruncated,
+                    marker: response.Marker,
+                },
+            };
+        }
+        catch (error) {
+            logger.error('Failed to list users', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * List IAM roles
+     */
+    async listRoles(options = {}) {
+        try {
+            const { IAMClient, ListRolesCommand } = await import('@aws-sdk/client-iam');
+            const client = new IAMClient(this.getClientConfig());
+            const input = {};
+            if (options.maxItems) {
+                input.MaxItems = options.maxItems;
+            }
+            if (options.marker) {
+                input.Marker = options.marker;
+            }
+            if (options.pathPrefix) {
+                input.PathPrefix = options.pathPrefix;
+            }
+            const command = new ListRolesCommand(input);
+            const response = await client.send(command);
+            const roles = response.Roles?.map((r) => ({
+                roleName: r.RoleName,
+                roleId: r.RoleId,
+                arn: r.Arn,
+                path: r.Path,
+                createDate: r.CreateDate,
+                description: r.Description,
+                maxSessionDuration: r.MaxSessionDuration,
+            }));
+            return {
+                success: true,
+                data: {
+                    roles: roles || [],
+                    isTruncated: response.IsTruncated,
+                    marker: response.Marker,
+                },
+            };
+        }
+        catch (error) {
+            logger.error('Failed to list roles', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * List IAM policies
+     */
+    async listPolicies(options = {}) {
+        try {
+            const { IAMClient, ListPoliciesCommand } = await import('@aws-sdk/client-iam');
+            const client = new IAMClient(this.getClientConfig());
+            const command = new ListPoliciesCommand({
+                MaxItems: options.maxItems,
+                Marker: options.marker,
+                PathPrefix: options.pathPrefix,
+                Scope: options.scope,
+                OnlyAttached: options.onlyAttached,
+            });
+            const response = await client.send(command);
+            const policies = response.Policies?.map((p) => ({
+                policyName: p.PolicyName,
+                policyId: p.PolicyId,
+                arn: p.Arn,
+                path: p.Path,
+                createDate: p.CreateDate,
+                updateDate: p.UpdateDate,
+                attachmentCount: p.AttachmentCount,
+                isAttachable: p.IsAttachable,
+                description: p.Description,
+            }));
+            return {
+                success: true,
+                data: {
+                    policies: policies || [],
+                    isTruncated: response.IsTruncated,
+                    marker: response.Marker,
+                },
+            };
+        }
+        catch (error) {
+            logger.error('Failed to list policies', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * List IAM groups
+     */
+    async listGroups(options = {}) {
+        try {
+            const { IAMClient, ListGroupsCommand } = await import('@aws-sdk/client-iam');
+            const client = new IAMClient(this.getClientConfig());
+            const command = new ListGroupsCommand({
+                MaxItems: options.maxItems,
+                Marker: options.marker,
+                PathPrefix: options.pathPrefix,
+            });
+            const response = await client.send(command);
+            const groups = response.Groups?.map((g) => ({
+                groupName: g.GroupName,
+                groupId: g.GroupId,
+                arn: g.Arn,
+                path: g.Path,
+                createDate: g.CreateDate,
+            }));
+            return {
+                success: true,
+                data: {
+                    groups: groups || [],
+                    isTruncated: response.IsTruncated,
+                    marker: response.Marker,
+                },
+            };
+        }
+        catch (error) {
+            logger.error('Failed to list groups', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Get IAM user details
+     */
+    async getUser(userName) {
+        try {
+            const { IAMClient, GetUserCommand } = await import('@aws-sdk/client-iam');
+            const client = new IAMClient(this.getClientConfig());
+            const command = new GetUserCommand(userName ? { UserName: userName } : {});
+            const response = await client.send(command);
+            const user = response.User;
+            return {
+                success: true,
+                data: {
+                    userName: user?.UserName,
+                    userId: user?.UserId,
+                    arn: user?.Arn,
+                    path: user?.Path,
+                    createDate: user?.CreateDate,
+                    passwordLastUsed: user?.PasswordLastUsed,
+                },
+            };
+        }
+        catch (error) {
+            logger.error('Failed to get user', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Attach policy to role
+     */
+    async attachRolePolicy(roleName, policyArn) {
+        try {
+            const { IAMClient, AttachRolePolicyCommand } = await import('@aws-sdk/client-iam');
+            const client = new IAMClient(this.getClientConfig());
+            const command = new AttachRolePolicyCommand({ RoleName: roleName, PolicyArn: policyArn });
+            await client.send(command);
+            return {
+                success: true,
+                data: { message: `Policy ${policyArn} attached to role ${roleName}` },
+            };
+        }
+        catch (error) {
+            logger.error('Failed to attach role policy', error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Detach policy from role
+     */
+    async detachRolePolicy(roleName, policyArn) {
+        try {
+            const { IAMClient, DetachRolePolicyCommand } = await import('@aws-sdk/client-iam');
+            const client = new IAMClient(this.getClientConfig());
+            const command = new DetachRolePolicyCommand({ RoleName: roleName, PolicyArn: policyArn });
+            await client.send(command);
+            return {
+                success: true,
+                data: { message: `Policy ${policyArn} detached from role ${roleName}` },
+            };
+        }
+        catch (error) {
+            logger.error('Failed to detach role policy', error);
+            return { success: false, error: error.message };
+        }
+    }
+}