infrastructure.service.tsā¢4.7 kB
import { EC2Service } from './aws/ec2.service';
import { S3Service } from './aws/s3.service';
import { DynamoDBService } from './aws/dynamodb.service';
import { LambdaService } from './aws/lambda.service';
import { IAMService } from './aws/iam.service';
import { MCPServer } from './mcp/mcp.server';
import { ResourceQuery, ResourceResponse, MCPResource } from '../types';
import { logger } from '../utils/logger';
export class InfrastructureService {
private ec2Service: EC2Service;
private s3Service: S3Service;
private dynamoDBService: DynamoDBService;
private lambdaService: LambdaService;
private iamService: IAMService;
private mcpServer: MCPServer;
private resourceMap: Map<string, { type: string; awsId: string }> = new Map();
constructor(mcpServer: MCPServer) {
this.ec2Service = new EC2Service();
this.s3Service = new S3Service();
this.dynamoDBService = new DynamoDBService();
this.lambdaService = new LambdaService();
this.iamService = new IAMService();
this.mcpServer = mcpServer;
}
async processQuery(query: ResourceQuery): Promise<ResourceResponse> {
try {
if (query.action === 'create') {
return await this.createResource(query);
} else if (query.action === 'delete') {
return await this.deleteResource(query);
} else {
throw new Error(`Invalid action: ${query.action}`);
}
} catch (error: any) {
logger.error('Error processing query:', error);
return {
success: false,
message: error.message || 'An error occurred',
};
}
}
private async createResource(query: ResourceQuery): Promise<ResourceResponse> {
let result: any;
let awsResourceId: string;
const resourceId = `${query.resourceType}-${Date.now()}`;
switch (query.resourceType) {
case 'ec2':
result = await this.ec2Service.createInstance(query.parameters);
awsResourceId = result.instanceId;
break;
case 's3':
result = await this.s3Service.createBucket(query.parameters);
awsResourceId = result.bucketName;
break;
case 'dynamodb':
result = await this.dynamoDBService.createTable(query.parameters);
awsResourceId = result.tableName;
break;
case 'lambda':
result = await this.lambdaService.createFunction(query.parameters);
awsResourceId = result.functionName;
break;
case 'iam-role':
result = await this.iamService.createRole(query.parameters);
awsResourceId = result.roleName;
break;
default:
throw new Error(`Unsupported resource type: ${query.resourceType}`);
}
const mcpResource: MCPResource = {
type: query.resourceType,
id: resourceId,
metadata: {
awsResourceId,
parameters: query.parameters,
...result,
},
createdAt: new Date(),
};
this.mcpServer.addResource(mcpResource);
this.resourceMap.set(resourceId, { type: query.resourceType, awsId: awsResourceId });
return {
success: true,
resourceId,
message: `Successfully created ${query.resourceType} resource`,
details: result,
};
}
private async deleteResource(query: ResourceQuery): Promise<ResourceResponse> {
if (!query.resourceId) {
throw new Error('Resource ID is required for delete operation');
}
const resourceInfo = this.resourceMap.get(query.resourceId);
if (!resourceInfo) {
throw new Error(`Resource not found: ${query.resourceId}`);
}
let result: any;
switch (resourceInfo.type) {
case 'ec2':
result = await this.ec2Service.terminateInstance(resourceInfo.awsId);
break;
case 's3':
result = await this.s3Service.deleteBucket(resourceInfo.awsId);
break;
case 'dynamodb':
result = await this.dynamoDBService.deleteTable(resourceInfo.awsId);
break;
case 'lambda':
result = await this.lambdaService.deleteFunction(resourceInfo.awsId);
break;
case 'iam-role':
result = await this.iamService.deleteRole(resourceInfo.awsId);
break;
default:
throw new Error(`Unsupported resource type: ${resourceInfo.type}`);
}
this.mcpServer.removeResource(query.resourceId);
this.resourceMap.delete(query.resourceId);
return {
success: true,
message: `Successfully deleted ${resourceInfo.type} resource`,
details: result,
};
}
getResourceStatus(resourceId: string): MCPResource | undefined {
return this.mcpServer.getResource(resourceId);
}
getAllResources(): MCPResource[] {
return this.mcpServer.getAllResources();
}
}