@frontpoint/aws-infra-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 frontpoint
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,141 @@
+# AWS Infra MCP
+
+MCP (Model Context Protocol) server for generating AWS CDK TypeScript infrastructure code with resource analysis.
+
+## Features
+
+- **AWS Resource Analysis**: Scan existing AWS resources (EC2, RDS, Lambda, S3, DynamoDB, ECS, EKS, ECR, VPC, API Gateway)
+- **CDK Code Generation**: Generate type-safe AWS CDK TypeScript projects
+- **Full Service Coverage**: Support for compute, database, storage, and network resources
+- **Interactive Configuration**: Add resources incrementally with MCP tools
+- **Cost Estimation**: Preview estimated monthly costs (coming soon)
+- **Security Validation**: IAM and security group validation (coming soon)
+
+## Installation
+
+```bash
+npm install -g @frontpoint/aws-infra-mcp
+```
+
+## Usage
+
+### As MCP Server
+
+Add to your Claude Code MCP configuration:
+
+```json
+{
+  "mcpServers": {
+    "aws-infra": {
+      "command": "aws-infra-mcp",
+      "args": ["/path/to/your/project"]
+    }
+  }
+}
+```
+
+### CLI
+
+```bash
+# Start MCP server in current directory
+aws-infra-mcp
+
+# Start with specific project path
+aws-infra-mcp /path/to/project
+```
+
+## Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `aws-init` | Initialize project with AWS credentials verification |
+| `aws-analyze` | Scan existing AWS resources in your account |
+| `aws-status` | Show current configuration status |
+| `aws-add-compute` | Add EC2, Lambda, ECS, EKS resources |
+| `aws-add-database` | Add RDS, Aurora, DynamoDB resources |
+| `aws-add-storage` | Add S3, ECR resources |
+| `aws-add-network` | Add VPC, API Gateway resources |
+| `aws-generate-all` | Generate complete CDK project |
+
+## Supported AWS Services
+
+### Compute
+- EC2 Instances & Auto Scaling Groups
+- Lambda Functions with event sources
+- ECS Clusters, Services, Task Definitions
+- EKS Clusters with Node Groups
+
+### Database
+- RDS (MySQL, PostgreSQL, MariaDB)
+- Aurora (MySQL, PostgreSQL, Serverless v2)
+- DynamoDB Tables with GSI/LSI
+
+### Storage
+- S3 Buckets with lifecycle policies
+- ECR Repositories
+
+### Network
+- VPC with public/private subnets
+- NAT Gateways
+- API Gateway (REST, HTTP, WebSocket)
+
+## Example Workflow
+
+```bash
+# 1. Initialize project
+aws-init projectName: my-app region: ap-northeast-2
+
+# 2. Analyze existing resources (optional)
+aws-analyze
+
+# 3. Add infrastructure resources
+aws-add-network type: vpc name: main-vpc cidrBlock: 10.0.0.0/16
+aws-add-database type: dynamodb name: users-table partitionKey: userId:S
+aws-add-storage type: s3 name: my-app-assets versioning: true
+aws-add-compute type: lambda name: api-handler runtime: nodejs20.x
+
+# 4. Generate CDK project
+aws-generate-all
+
+# 5. Deploy
+cd cdk-infra && npm install && npx cdk deploy --all
+```
+
+## Generated CDK Structure
+
+```
+cdk-infra/
+├── bin/
+│   └── app.ts              # CDK app entry point
+├── lib/
+│   └── stacks/
+│       ├── network-stack.ts
+│       ├── compute-stack.ts
+│       ├── database-stack.ts
+│       └── storage-stack.ts
+├── cdk.json
+├── package.json
+└── tsconfig.json
+```
+
+## Requirements
+
+- Node.js >= 18.0.0
+- AWS CLI configured with credentials
+- AWS CDK CLI (`npm install -g aws-cdk`)
+
+## Configuration
+
+Configuration is stored in `.aws-infra-mcp/` directory:
+
+- `config.json` - Infrastructure configuration
+- `state.json` - Generation state and history
+- `analysis-cache.json` - Cached AWS resource analysis
+
+## License
+
+MIT
+
+## Author
+
+frontpoint

package/dist/core/aws-analyzer.d.ts

@@ -0,0 +1,73 @@
+/**
+ * AWS Resource Analyzer
+ *
+ * Analyzes existing AWS resources using AWS SDK v3
+ */
+import type { AWSRegion, AWSResourceAnalysis, AnalyzedEC2Instance, AnalyzedRDSInstance, AnalyzedLambdaFunction, AnalyzedS3Bucket, AnalyzedDynamoDBTable, AnalyzedECSCluster, AnalyzedEKSCluster, AnalyzedECRRepository, AnalyzedVPC, AnalyzedAPIGateway } from '../types.js';
+export interface AWSAnalyzerOptions {
+    region: AWSRegion;
+    profile?: string;
+}
+export interface AWSCredentialsInfo {
+    account: string;
+    userId: string;
+    arn: string;
+}
+export declare class AWSAnalyzer {
+    private region;
+    private clientConfig;
+    constructor(options: AWSAnalyzerOptions);
+    /**
+     * Verify AWS credentials and get account info
+     */
+    verifyCredentials(): Promise<AWSCredentialsInfo>;
+    /**
+     * Analyze all AWS resources
+     */
+    analyzeAll(): Promise<AWSResourceAnalysis>;
+    /**
+     * Analyze EC2 instances
+     */
+    analyzeEC2(): Promise<AnalyzedEC2Instance[]>;
+    /**
+     * Analyze RDS instances
+     */
+    analyzeRDS(): Promise<AnalyzedRDSInstance[]>;
+    /**
+     * Analyze Lambda functions
+     */
+    analyzeLambda(): Promise<AnalyzedLambdaFunction[]>;
+    /**
+     * Analyze S3 buckets
+     */
+    analyzeS3(): Promise<AnalyzedS3Bucket[]>;
+    /**
+     * Analyze DynamoDB tables
+     */
+    analyzeDynamoDB(): Promise<AnalyzedDynamoDBTable[]>;
+    /**
+     * Analyze ECS clusters
+     */
+    analyzeECS(): Promise<AnalyzedECSCluster[]>;
+    /**
+     * Analyze EKS clusters
+     */
+    analyzeEKS(): Promise<AnalyzedEKSCluster[]>;
+    /**
+     * Analyze ECR repositories
+     */
+    analyzeECR(): Promise<AnalyzedECRRepository[]>;
+    /**
+     * Analyze VPCs
+     */
+    analyzeVPC(): Promise<AnalyzedVPC[]>;
+    /**
+     * Analyze API Gateways
+     */
+    analyzeAPIGateway(): Promise<AnalyzedAPIGateway[]>;
+    /**
+     * Build importable resources list
+     */
+    private buildImportableResources;
+}
+//# sourceMappingURL=aws-analyzer.d.ts.map

package/dist/core/aws-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aws-analyzer.d.ts","sourceRoot":"","sources":["../../src/core/aws-analyzer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAYH,OAAO,KAAK,EACV,SAAS,EACT,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,sBAAsB,EACtB,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,WAAW,EACX,kBAAkB,EAEnB,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,SAAS,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACb;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,YAAY,CAAqB;gBAE7B,OAAO,EAAE,kBAAkB;IAWvC;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAWtD;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,mBAAmB,CAAC;IAwChD;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,mBAAmB,EAAE,CAAC;IA8BlD;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,mBAAmB,EAAE,CAAC;IAoBlD;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,sBAAsB,EAAE,CAAC;IAmBxD;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAwC9C;;OAEG;IACG,eAAe,IAAI,OAAO,CAAC,qBAAqB,EAAE,CAAC;IAgCzD;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC;IA0BjD;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC;IA+BjD;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,qBAAqB,EAAE,CAAC;IAgBpD;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAmB1C;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAgBxD;;OAEG;IACH,OAAO,CAAC,wBAAwB;CA2HjC"}

package/dist/core/aws-analyzer.js

@@ -0,0 +1,429 @@
+/**
+ * AWS Resource Analyzer
+ *
+ * Analyzes existing AWS resources using AWS SDK v3
+ */
+import { EC2Client, DescribeInstancesCommand, DescribeVpcsCommand } from '@aws-sdk/client-ec2';
+import { RDSClient, DescribeDBInstancesCommand } from '@aws-sdk/client-rds';
+import { S3Client, ListBucketsCommand, GetBucketVersioningCommand, GetBucketEncryptionCommand } from '@aws-sdk/client-s3';
+import { LambdaClient, ListFunctionsCommand } from '@aws-sdk/client-lambda';
+import { DynamoDBClient, ListTablesCommand, DescribeTableCommand } from '@aws-sdk/client-dynamodb';
+import { ECSClient, ListClustersCommand, DescribeClustersCommand } from '@aws-sdk/client-ecs';
+import { EKSClient, ListClustersCommand as EKSListClustersCommand, DescribeClusterCommand } from '@aws-sdk/client-eks';
+import { ECRClient, DescribeRepositoriesCommand } from '@aws-sdk/client-ecr';
+import { ApiGatewayV2Client, GetApisCommand } from '@aws-sdk/client-apigatewayv2';
+import { STSClient, GetCallerIdentityCommand } from '@aws-sdk/client-sts';
+export class AWSAnalyzer {
+    region;
+    clientConfig;
+    constructor(options) {
+        this.region = options.region;
+        this.clientConfig = { region: options.region };
+        // If profile is specified, set environment variable
+        // AWS SDK v3 will automatically use AWS_PROFILE
+        if (options.profile) {
+            process.env.AWS_PROFILE = options.profile;
+        }
+    }
+    /**
+     * Verify AWS credentials and get account info
+     */
+    async verifyCredentials() {
+        const client = new STSClient(this.clientConfig);
+        const response = await client.send(new GetCallerIdentityCommand({}));
+        return {
+            account: response.Account || '',
+            userId: response.UserId || '',
+            arn: response.Arn || '',
+        };
+    }
+    /**
+     * Analyze all AWS resources
+     */
+    async analyzeAll() {
+        const credentials = await this.verifyCredentials();
+        const [ec2, rds, lambda, s3, dynamodb, ecs, eks, ecr, vpc, apiGateway,] = await Promise.all([
+            this.analyzeEC2(),
+            this.analyzeRDS(),
+            this.analyzeLambda(),
+            this.analyzeS3(),
+            this.analyzeDynamoDB(),
+            this.analyzeECS(),
+            this.analyzeEKS(),
+            this.analyzeECR(),
+            this.analyzeVPC(),
+            this.analyzeAPIGateway(),
+        ]);
+        const importableResources = this.buildImportableResources({
+            ec2, rds, lambda, s3, dynamodb, ecs, eks, ecr, vpc, apiGateway,
+        });
+        return {
+            region: this.region,
+            account: credentials.account,
+            analyzedAt: new Date().toISOString(),
+            resources: { ec2, rds, lambda, s3, dynamodb, ecs, eks, ecr, vpc, apiGateway },
+            importableResources,
+        };
+    }
+    /**
+     * Analyze EC2 instances
+     */
+    async analyzeEC2() {
+        try {
+            const client = new EC2Client(this.clientConfig);
+            const response = await client.send(new DescribeInstancesCommand({}));
+            const instances = [];
+            for (const reservation of response.Reservations || []) {
+                for (const instance of reservation.Instances || []) {
+                    const nameTag = instance.Tags?.find((t) => t.Key === 'Name');
+                    instances.push({
+                        instanceId: instance.InstanceId || '',
+                        name: nameTag?.Value,
+                        instanceType: instance.InstanceType || '',
+                        state: instance.State?.Name || '',
+                        vpcId: instance.VpcId,
+                        subnetId: instance.SubnetId,
+                        publicIpAddress: instance.PublicIpAddress,
+                        privateIpAddress: instance.PrivateIpAddress,
+                        tags: Object.fromEntries((instance.Tags || []).map((t) => [t.Key || '', t.Value || ''])),
+                    });
+                }
+            }
+            return instances;
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Analyze RDS instances
+     */
+    async analyzeRDS() {
+        try {
+            const client = new RDSClient(this.clientConfig);
+            const response = await client.send(new DescribeDBInstancesCommand({}));
+            return (response.DBInstances || []).map((db) => ({
+                dbInstanceIdentifier: db.DBInstanceIdentifier || '',
+                engine: db.Engine || '',
+                engineVersion: db.EngineVersion || '',
+                dbInstanceClass: db.DBInstanceClass || '',
+                allocatedStorage: db.AllocatedStorage || 0,
+                status: db.DBInstanceStatus || '',
+                multiAZ: db.MultiAZ || false,
+                publiclyAccessible: db.PubliclyAccessible || false,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Analyze Lambda functions
+     */
+    async analyzeLambda() {
+        try {
+            const client = new LambdaClient(this.clientConfig);
+            const response = await client.send(new ListFunctionsCommand({}));
+            return (response.Functions || []).map((fn) => ({
+                functionName: fn.FunctionName || '',
+                functionArn: fn.FunctionArn || '',
+                runtime: fn.Runtime || '',
+                handler: fn.Handler || '',
+                memorySize: fn.MemorySize || 0,
+                timeout: fn.Timeout || 0,
+                lastModified: fn.LastModified || '',
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Analyze S3 buckets
+     */
+    async analyzeS3() {
+        try {
+            const client = new S3Client(this.clientConfig);
+            const response = await client.send(new ListBucketsCommand({}));
+            const buckets = [];
+            for (const bucket of response.Buckets || []) {
+                let versioning = false;
+                let encryption = false;
+                try {
+                    const versioningResponse = await client.send(new GetBucketVersioningCommand({ Bucket: bucket.Name }));
+                    versioning = versioningResponse.Status === 'Enabled';
+                }
+                catch {
+                    // Bucket might be in different region
+                }
+                try {
+                    await client.send(new GetBucketEncryptionCommand({ Bucket: bucket.Name }));
+                    encryption = true;
+                }
+                catch {
+                    // No encryption or different region
+                }
+                buckets.push({
+                    name: bucket.Name || '',
+                    creationDate: bucket.CreationDate?.toISOString() || '',
+                    region: this.region,
+                    versioning,
+                    encryption,
+                });
+            }
+            return buckets;
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Analyze DynamoDB tables
+     */
+    async analyzeDynamoDB() {
+        try {
+            const client = new DynamoDBClient(this.clientConfig);
+            const listResponse = await client.send(new ListTablesCommand({}));
+            const tables = [];
+            for (const tableName of listResponse.TableNames || []) {
+                try {
+                    const describeResponse = await client.send(new DescribeTableCommand({ TableName: tableName }));
+                    const table = describeResponse.Table;
+                    if (table) {
+                        tables.push({
+                            tableName: table.TableName || '',
+                            tableArn: table.TableArn || '',
+                            status: table.TableStatus || '',
+                            itemCount: Number(table.ItemCount) || 0,
+                            tableSizeBytes: Number(table.TableSizeBytes) || 0,
+                            billingMode: table.BillingModeSummary?.BillingMode || 'PROVISIONED',
+                        });
+                    }
+                }
+                catch {
+                    // Skip tables we can't describe
+                }
+            }
+            return tables;
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Analyze ECS clusters
+     */
+    async analyzeECS() {
+        try {
+            const client = new ECSClient(this.clientConfig);
+            const listResponse = await client.send(new ListClustersCommand({}));
+            if (!listResponse.clusterArns?.length) {
+                return [];
+            }
+            const describeResponse = await client.send(new DescribeClustersCommand({ clusters: listResponse.clusterArns }));
+            return (describeResponse.clusters || []).map((cluster) => ({
+                clusterName: cluster.clusterName || '',
+                clusterArn: cluster.clusterArn || '',
+                status: cluster.status || '',
+                runningTasksCount: cluster.runningTasksCount || 0,
+                pendingTasksCount: cluster.pendingTasksCount || 0,
+                activeServicesCount: cluster.activeServicesCount || 0,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Analyze EKS clusters
+     */
+    async analyzeEKS() {
+        try {
+            const client = new EKSClient(this.clientConfig);
+            const listResponse = await client.send(new EKSListClustersCommand({}));
+            const clusters = [];
+            for (const clusterName of listResponse.clusters || []) {
+                try {
+                    const describeResponse = await client.send(new DescribeClusterCommand({ name: clusterName }));
+                    const cluster = describeResponse.cluster;
+                    if (cluster) {
+                        clusters.push({
+                            name: cluster.name || '',
+                            arn: cluster.arn || '',
+                            version: cluster.version || '',
+                            status: cluster.status || '',
+                            endpoint: cluster.endpoint || '',
+                        });
+                    }
+                }
+                catch {
+                    // Skip clusters we can't describe
+                }
+            }
+            return clusters;
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Analyze ECR repositories
+     */
+    async analyzeECR() {
+        try {
+            const client = new ECRClient(this.clientConfig);
+            const response = await client.send(new DescribeRepositoriesCommand({}));
+            return (response.repositories || []).map((repo) => ({
+                repositoryName: repo.repositoryName || '',
+                repositoryArn: repo.repositoryArn || '',
+                repositoryUri: repo.repositoryUri || '',
+                imageCount: 0, // Would need additional API call
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Analyze VPCs
+     */
+    async analyzeVPC() {
+        try {
+            const client = new EC2Client(this.clientConfig);
+            const response = await client.send(new DescribeVpcsCommand({}));
+            return (response.Vpcs || []).map((vpc) => ({
+                vpcId: vpc.VpcId || '',
+                cidrBlock: vpc.CidrBlock || '',
+                state: vpc.State || '',
+                isDefault: vpc.IsDefault || false,
+                tags: Object.fromEntries((vpc.Tags || []).map((t) => [t.Key || '', t.Value || ''])),
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Analyze API Gateways
+     */
+    async analyzeAPIGateway() {
+        try {
+            const client = new ApiGatewayV2Client(this.clientConfig);
+            const response = await client.send(new GetApisCommand({}));
+            return (response.Items || []).map((api) => ({
+                apiId: api.ApiId || '',
+                name: api.Name || '',
+                protocolType: api.ProtocolType || '',
+                apiEndpoint: api.ApiEndpoint || '',
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /**
+     * Build importable resources list
+     */
+    buildImportableResources(resources) {
+        const importable = [];
+        // EC2 instances
+        for (const instance of resources.ec2) {
+            importable.push({
+                type: 'AWS::EC2::Instance',
+                id: instance.instanceId,
+                name: instance.name || instance.instanceId,
+                importCommand: `cdk import ${instance.instanceId}`,
+            });
+        }
+        // RDS instances
+        for (const db of resources.rds) {
+            importable.push({
+                type: 'AWS::RDS::DBInstance',
+                id: db.dbInstanceIdentifier,
+                name: db.dbInstanceIdentifier,
+                importCommand: `cdk import ${db.dbInstanceIdentifier}`,
+            });
+        }
+        // Lambda functions
+        for (const fn of resources.lambda) {
+            importable.push({
+                type: 'AWS::Lambda::Function',
+                id: fn.functionName,
+                name: fn.functionName,
+                arn: fn.functionArn,
+                importCommand: `cdk import ${fn.functionName}`,
+            });
+        }
+        // S3 buckets
+        for (const bucket of resources.s3) {
+            importable.push({
+                type: 'AWS::S3::Bucket',
+                id: bucket.name,
+                name: bucket.name,
+                importCommand: `cdk import ${bucket.name}`,
+            });
+        }
+        // DynamoDB tables
+        for (const table of resources.dynamodb) {
+            importable.push({
+                type: 'AWS::DynamoDB::Table',
+                id: table.tableName,
+                name: table.tableName,
+                arn: table.tableArn,
+                importCommand: `cdk import ${table.tableName}`,
+            });
+        }
+        // ECS clusters
+        for (const cluster of resources.ecs) {
+            importable.push({
+                type: 'AWS::ECS::Cluster',
+                id: cluster.clusterName,
+                name: cluster.clusterName,
+                arn: cluster.clusterArn,
+                importCommand: `cdk import ${cluster.clusterName}`,
+            });
+        }
+        // EKS clusters
+        for (const cluster of resources.eks) {
+            importable.push({
+                type: 'AWS::EKS::Cluster',
+                id: cluster.name,
+                name: cluster.name,
+                arn: cluster.arn,
+                importCommand: `cdk import ${cluster.name}`,
+            });
+        }
+        // ECR repositories
+        for (const repo of resources.ecr) {
+            importable.push({
+                type: 'AWS::ECR::Repository',
+                id: repo.repositoryName,
+                name: repo.repositoryName,
+                arn: repo.repositoryArn,
+                importCommand: `cdk import ${repo.repositoryName}`,
+            });
+        }
+        // VPCs
+        for (const vpc of resources.vpc) {
+            if (!vpc.isDefault) {
+                importable.push({
+                    type: 'AWS::EC2::VPC',
+                    id: vpc.vpcId,
+                    name: vpc.tags['Name'] || vpc.vpcId,
+                    importCommand: `cdk import ${vpc.vpcId}`,
+                });
+            }
+        }
+        // API Gateways
+        for (const api of resources.apiGateway) {
+            importable.push({
+                type: 'AWS::ApiGatewayV2::Api',
+                id: api.apiId,
+                name: api.name,
+                importCommand: `cdk import ${api.apiId}`,
+            });
+        }
+        return importable;
+    }
+}
+//# sourceMappingURL=aws-analyzer.js.map