# Directory Structure
```
├── .gitignore
├── package-lock.json
├── package.json
├── README.md
├── setup.sh
├── src
│ ├── aws-cli.ts
│ ├── aws-services.ts
│ ├── index.ts
│ ├── test.ts
│ └── types.ts
└── tsconfig.json
```
# Files
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
```
# Logs
logs
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
lerna-debug.log*
.pnpm-debug.log*
# Diagnostic reports (https://nodejs.org/api/report.html)
report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
# Runtime data
pids
*.pid
*.seed
*.pid.lock
# Directory for instrumented libs generated by jscoverage/JSCover
lib-cov
# Coverage directory used by tools like istanbul
coverage
*.lcov
# nyc test coverage
.nyc_output
# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
.grunt
# Bower dependency directory (https://bower.io/)
bower_components
# node-waf configuration
.lock-wscript
# Compiled binary addons (https://nodejs.org/api/addons.html)
build/Release
# Dependency directories
node_modules/
jspm_packages/
# Snowpack dependency directory (https://snowpack.dev/)
web_modules/
# TypeScript cache
*.tsbuildinfo
# Optional npm cache directory
.npm
# Optional eslint cache
.eslintcache
# Optional stylelint cache
.stylelintcache
# Microbundle cache
.rpt2_cache/
.rts2_cache_cjs/
.rts2_cache_es/
.rts2_cache_umd/
# Optional REPL history
.node_repl_history
# Output of 'npm pack'
*.tgz
# Yarn Integrity file
.yarn-integrity
# dotenv environment variable files
.env
.env.development.local
.env.test.local
.env.production.local
.env.local
# parcel-bundler cache (https://parceljs.org/)
.cache
.parcel-cache
# Next.js build output
.next
out
# Nuxt.js build / generate output
.nuxt
dist
# Gatsby files
.cache/
# Comment in the public line in if your project uses Gatsby and not Next.js
# https://nextjs.org/blog/next-9-1#public-directory-support
# public
# vuepress build output
.vuepress/dist
# vuepress v2.x temp and cache directory
.temp
.cache
# vitepress build output
**/.vitepress/dist
# vitepress cache directory
**/.vitepress/cache
# Docusaurus cache and generated files
.docusaurus
# Serverless directories
.serverless/
# FuseBox cache
.fusebox/
# DynamoDB Local files
.dynamodb/
# TernJS port file
.tern-port
# Stores VSCode versions used for testing VSCode extensions
.vscode-test
# yarn v2
.yarn/cache
.yarn/unplugged
.yarn/build-state.yml
.yarn/install-state.gz
.pnp.*
```
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
```markdown
# AWS CLI MCP Server
An MCP (Model Context Protocol) server that lets you generate and execute AWS CLI commands directly from Claude.
## Features
- Execute AWS CLI commands through the MCP protocol
- Get detailed information about AWS services
- List available AWS services
- Full access to AWS CLI capabilities
## Tools
- **execute-aws-command**: Execute AWS CLI commands
- Parameters:
- `command`: AWS service (e.g., s3, ec2, lambda)
- `subcommand` (optional): Command to execute (e.g., ls, describe-instances)
- `options` (optional): Command options as key-value pairs
- **get-service-details**: Get details about a specific AWS service
- Parameters:
- `service`: AWS service name (e.g., s3, ec2, lambda)
## Resources
- **aws-services://list**: List available AWS services
## Setup and Installation
### Prerequisites
- Node.js (v20 or later recommended)
- npm or yarn
- AWS CLI installed and configured with credentials
- TypeScript
### Local Installation
1. Clone this repository:
```bash
git clone https://github.com/IcyKallen/aws-cli-mcp-server
cd aws-cli-mcp-server
```
2. Install dependencies:
```bash
npm install
```
3. Build the project:
```bash
npm run build
```
4. Ensure AWS CLI is configured:
```bash
aws configure
```
5. Start the MCP server:
```bash
npm start
```
### Integration with Claude Desktop
Add this to your `claude_desktop_config.json`:
After building the project, you can use:
```json
{
"mcpServers": {
"aws-cli": {
"command": "node",
"args": [
"/path/to/aws-cli-mcp-server/dist/index.js"
]
}
}
}
```
## Example Usage in Claude
### List S3 Buckets
```
I need to list my S3 buckets.
```
### Create an S3 Bucket
```
Create a new S3 bucket named "my-test-bucket" in the us-west-2 region.
```
### Get EC2 Service Details
```
What EC2 commands are available?
```
## Security Notes
- This server executes AWS CLI commands with the same permissions as your configured AWS credentials
- Be careful about who can access this server
- Consider implementing additional authentication for production use
## License
MIT License
```
--------------------------------------------------------------------------------
/src/types.ts:
--------------------------------------------------------------------------------
```typescript
/**
* Service details interface
*/
export interface ServiceDetails {
description: string;
commands: string[];
}
/**
* AWS Command Options interface
*/
export interface AwsCommandOptions {
[key: string]: string;
}
/**
* AWS Command Result interface
*/
export interface AwsCommandResult {
stdout: string;
stderr?: string;
}
/**
* AWS Command Error interface
*/
export interface AwsCommandError extends Error {
stderr?: string;
code?: number;
}
```
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
```json
{
"name": "aws-cli-mcp-server",
"version": "1.0.0",
"description": "An MCP server that can generate and execute AWS CLI commands",
"main": "dist/index.js",
"scripts": {
"build": "tsc",
"start": "node dist/index.js",
"dev": "ts-node src/index.ts",
"test": "echo \"Error: no test specified\" && exit 1",
"test:aws": "ts-node src/test.ts"
},
"keywords": [],
"author": "",
"license": "ISC",
"devDependencies": {
"@types/node": "^22.13.12",
"ts-node": "^10.9.2",
"typescript": "^5.8.2"
},
"dependencies": {
"@modelcontextprotocol/sdk": "^1.7.0",
"zod": "^3.24.2"
}
}
```
--------------------------------------------------------------------------------
/setup.sh:
--------------------------------------------------------------------------------
```bash
#!/bin/bash
# Check if AWS CLI is installed
echo "Checking if AWS CLI is installed..."
if command -v aws &> /dev/null; then
echo "AWS CLI is installed."
# Check AWS CLI version
aws_version=$(aws --version)
echo "AWS CLI version: $aws_version"
# Check if AWS credentials are configured
echo "Checking AWS credentials..."
aws sts get-caller-identity &> /dev/null
if [ $? -eq 0 ]; then
echo "AWS credentials are properly configured."
identity=$(aws sts get-caller-identity)
echo "You are authenticated as:"
echo "$identity"
else
echo "AWS credentials are not configured or are invalid."
echo "Please run 'aws configure' to set up your AWS credentials."
exit 1
fi
else
echo "AWS CLI is not installed."
echo "Please install AWS CLI first. You can find installation instructions at:"
echo "https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html"
exit 1
fi
# Install dependencies
echo "Installing dependencies..."
npm install
# Build the project
echo "Building the project..."
npm run build
echo "Setup complete! You can now run the server with 'npm start' or 'npm run dev'"
```
--------------------------------------------------------------------------------
/src/test.ts:
--------------------------------------------------------------------------------
```typescript
import { executeAwsCommand } from './aws-cli';
import { listServices, getServiceDetails } from './aws-services';
async function testAwsCli() {
console.log('Testing AWS CLI functionality...');
try {
// Test AWS CLI version
console.log('\nChecking AWS CLI version:');
const versionResult = await executeAwsCommand('--version');
console.log(versionResult);
// Test listing services
console.log('\nListing available AWS services:');
const services = listServices();
console.log(services.slice(0, 5).join('\n')); // Show first 5 services
console.log(`... and ${services.length - 5} more services`);
// Test getting service details
console.log('\nGetting details for S3 service:');
const s3Details = getServiceDetails('s3');
if (s3Details) {
console.log(`Description: ${s3Details.description}`);
console.log('Commands:');
console.log(s3Details.commands.join('\n'));
} else {
console.log('No details found for S3 service');
}
// Test executing a simple AWS CLI command (list S3 buckets)
console.log('\nListing S3 buckets:');
try {
const s3Result = await executeAwsCommand('s3', 'ls');
console.log(s3Result || 'No S3 buckets found');
} catch (error) {
console.error('Error listing S3 buckets:', error);
}
console.log('\nTests completed successfully!');
} catch (error) {
console.error('Test failed:', error);
}
}
testAwsCli();
```
--------------------------------------------------------------------------------
/src/aws-cli.ts:
--------------------------------------------------------------------------------
```typescript
import { exec } from 'child_process';
import { promisify } from 'util';
import { AwsCommandOptions, AwsCommandError } from './types';
const execPromise = promisify(exec);
/**
* Execute an AWS CLI command with optional subcommand and options.
*
* @param command - The AWS service command (e.g., 's3', 'ec2', 'lambda')
* @param subcommand - The subcommand to run (e.g., 'ls', 'describe-instances')
* @param options - Key-value pairs of command options
* @returns Promise with the command output
*/
export async function executeAwsCommand(
command: string,
subcommand?: string,
options: AwsCommandOptions = {}
): Promise<string> {
// Build the AWS CLI command
let awsCommand = `aws ${command}`;
if (subcommand) {
awsCommand += ` ${subcommand}`;
}
// Add options to the command
for (const [key, value] of Object.entries(options)) {
// Handle options with values vs flags
if (value === '') {
awsCommand += ` --${key}`;
} else {
// Properly quote option values
awsCommand += ` --${key} "${value}"`;
}
}
try {
// Execute the AWS CLI command
console.log(`Executing: ${awsCommand}`);
const { stdout, stderr } = await execPromise(awsCommand);
if (stderr) {
console.warn(`AWS CLI warning: ${stderr}`);
}
return stdout.trim();
} catch (error) {
const execError = error as { stderr?: string; message: string };
console.error(`AWS CLI error: ${execError.message}`);
// Include stderr in the error message if available
if (execError.stderr) {
throw new Error(`AWS CLI error: ${execError.stderr.trim()}`);
}
throw error;
}
}
```
--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
```typescript
import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { executeAwsCommand } from "./aws-cli";
import { listServices, getServiceDetails } from "./aws-services";
// Create an MCP server
const server = new McpServer({
name: "AWS CLI MCP Server",
version: "1.0.0"
});
// Add a tool to execute AWS CLI commands
server.tool(
"execute-aws-command",
{
command: z.string().describe("AWS service to use (e.g., s3, ec2, lambda)"),
subcommand: z.string().optional().describe("Command to execute (e.g., ls, describe-instances)"),
options: z.record(z.string(), z.string()).optional().describe("Command options as key-value pairs")
},
async ({ command, subcommand, options }) => {
try {
const result = await executeAwsCommand(command, subcommand, options || {});
return {
content: [{ type: "text", text: result }]
};
} catch (error) {
const errorMessage = error instanceof Error ? error.message : String(error);
return {
content: [{ type: "text", text: `Error: ${errorMessage}` }]
};
}
}
);
// Add a tool to get details about a specific AWS service
server.tool(
"get-service-details",
{
service: z.string().describe("AWS service name (e.g., s3, ec2, lambda)")
},
async ({ service }) => {
const details = getServiceDetails(service);
if (!details) {
return {
content: [{ type: "text", text: `No details available for service: ${service}` }]
};
}
const responseText = `${details.description}\n\nCommon commands:\n${details.commands.join('\n')}`;
return {
content: [{ type: "text", text: responseText }]
};
}
);
// Add a resource to list available AWS services
server.resource(
"aws-services",
new ResourceTemplate("aws-services://list", { list: undefined }),
async (uri) => {
const services = listServices();
return {
contents: [{
uri: uri.href,
text: services.join("\n")
}]
};
}
);
// Check if AWS CLI is installed
async function checkAwsCli(): Promise<boolean> {
try {
await executeAwsCommand('--version');
return true;
} catch (error) {
return false;
}
}
// Start receiving messages on stdin and sending messages on stdout
async function startServer() {
console.log("Starting AWS CLI MCP Server...");
// Check if AWS CLI is installed
const awsCliInstalled = await checkAwsCli();
if (!awsCliInstalled) {
console.error("AWS CLI is not installed or not in the PATH. Please install it to use this server.");
process.exit(1);
}
const transport = new StdioServerTransport();
await server.connect(transport);
console.log("AWS CLI MCP Server is running.");
}
startServer().catch(error => {
console.error("Failed to start server:", error);
process.exit(1);
});
```
--------------------------------------------------------------------------------
/src/aws-services.ts:
--------------------------------------------------------------------------------
```typescript
import { ServiceDetails } from './types';
/**
* Returns a list of commonly used AWS services that can be accessed via the AWS CLI.
* This is not an exhaustive list, but includes the most widely used services.
*
* @returns Array of AWS service names
*/
export function listServices(): string[] {
return [
"s3 - Amazon Simple Storage Service",
"ec2 - Amazon Elastic Compute Cloud",
"lambda - AWS Lambda",
"dynamodb - Amazon DynamoDB",
"cloudformation - AWS CloudFormation",
"iam - AWS Identity and Access Management",
"rds - Amazon Relational Database Service",
"sns - Amazon Simple Notification Service",
"sqs - Amazon Simple Queue Service",
"cloudwatch - Amazon CloudWatch",
"ecs - Amazon Elastic Container Service",
"eks - Amazon Elastic Kubernetes Service",
"apigateway - Amazon API Gateway",
"route53 - Amazon Route 53",
"kms - AWS Key Management Service",
"secretsmanager - AWS Secrets Manager",
"ssm - AWS Systems Manager",
"codepipeline - AWS CodePipeline",
"codebuild - AWS CodeBuild",
"codecommit - AWS CodeCommit"
];
}
/**
* Gets details about a specific AWS service and its common commands.
*
* @param service The AWS service to get details for
* @returns Service details and common commands
*/
export function getServiceDetails(service: string): ServiceDetails | null {
const services: Record<string, ServiceDetails> = {
's3': {
description: 'Amazon Simple Storage Service (S3) is an object storage service that offers industry-leading scalability, data availability, security, and performance.',
commands: [
'ls - List S3 buckets or objects within a bucket',
'cp - Copy files to/from S3',
'mb - Make a new bucket',
'rb - Remove a bucket',
'mv - Move files within S3 or between S3 and local',
'rm - Remove files from S3',
'sync - Sync directories to/from S3'
]
},
'ec2': {
description: 'Amazon Elastic Compute Cloud (EC2) provides scalable computing capacity in the AWS Cloud.',
commands: [
'describe-instances - Get details about your instances',
'start-instances - Start an instance',
'stop-instances - Stop an instance',
'run-instances - Launch a new instance',
'terminate-instances - Terminate an instance',
'describe-images - List available AMIs',
'create-tags - Add or overwrite tags for resources'
]
},
'lambda': {
description: 'AWS Lambda lets you run code without provisioning or managing servers.',
commands: [
'list-functions - List your Lambda functions',
'create-function - Create a new function',
'update-function-code - Update function code',
'invoke - Invoke a function',
'delete-function - Delete a function',
'get-function - Get function configuration and details',
'add-permission - Add permissions to the resource policy'
]
}
};
return services[service] || null;
}
```
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
```json
{
"compilerOptions": {
/* Visit https://aka.ms/tsconfig to read more about this file */
/* Projects */
// "incremental": true, /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
// "composite": true, /* Enable constraints that allow a TypeScript project to be used with project references. */
// "tsBuildInfoFile": "./.tsbuildinfo", /* Specify the path to .tsbuildinfo incremental compilation file. */
// "disableSourceOfProjectReferenceRedirect": true, /* Disable preferring source files instead of declaration files when referencing composite projects. */
// "disableSolutionSearching": true, /* Opt a project out of multi-project reference checking when editing. */
// "disableReferencedProjectLoad": true, /* Reduce the number of projects loaded automatically by TypeScript. */
/* Language and Environment */
"target": "es2016", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
// "lib": [], /* Specify a set of bundled library declaration files that describe the target runtime environment. */
// "jsx": "preserve", /* Specify what JSX code is generated. */
// "libReplacement": true, /* Enable lib replacement. */
// "experimentalDecorators": true, /* Enable experimental support for legacy experimental decorators. */
// "emitDecoratorMetadata": true, /* Emit design-type metadata for decorated declarations in source files. */
// "jsxFactory": "", /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
// "jsxFragmentFactory": "", /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
// "jsxImportSource": "", /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
// "reactNamespace": "", /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
// "noLib": true, /* Disable including any library files, including the default lib.d.ts. */
// "useDefineForClassFields": true, /* Emit ECMAScript-standard-compliant class fields. */
// "moduleDetection": "auto", /* Control what method is used to detect module-format JS files. */
/* Modules */
"module": "commonjs", /* Specify what module code is generated. */
"rootDir": "./src",
// "moduleResolution": "node10", /* Specify how TypeScript looks up a file from a given module specifier. */
// "baseUrl": "./", /* Specify the base directory to resolve non-relative module names. */
// "paths": {}, /* Specify a set of entries that re-map imports to additional lookup locations. */
// "rootDirs": [], /* Allow multiple folders to be treated as one when resolving modules. */
// "typeRoots": [], /* Specify multiple folders that act like './node_modules/@types'. */
// "types": [], /* Specify type package names to be included without being referenced in a source file. */
// "allowUmdGlobalAccess": true, /* Allow accessing UMD globals from modules. */
// "moduleSuffixes": [], /* List of file name suffixes to search when resolving a module. */
// "allowImportingTsExtensions": true, /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
// "rewriteRelativeImportExtensions": true, /* Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files. */
// "resolvePackageJsonExports": true, /* Use the package.json 'exports' field when resolving package imports. */
// "resolvePackageJsonImports": true, /* Use the package.json 'imports' field when resolving imports. */
// "customConditions": [], /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
// "noUncheckedSideEffectImports": true, /* Check side effect imports. */
"resolveJsonModule": true,
// "allowArbitraryExtensions": true, /* Enable importing files with any extension, provided a declaration file is present. */
// "noResolve": true, /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
/* JavaScript Support */
// "allowJs": true, /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
// "checkJs": true, /* Enable error reporting in type-checked JavaScript files. */
// "maxNodeModuleJsDepth": 1, /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
/* Emit */
// "declaration": true, /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
// "declarationMap": true, /* Create sourcemaps for d.ts files. */
// "emitDeclarationOnly": true, /* Only output d.ts files and not JavaScript files. */
"sourceMap": true,
// "inlineSourceMap": true, /* Include sourcemap files inside the emitted JavaScript. */
// "noEmit": true, /* Disable emitting files from a compilation. */
// "outFile": "./", /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
"outDir": "./dist",
// "removeComments": true, /* Disable emitting comments. */
// "importHelpers": true, /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
// "downlevelIteration": true, /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
// "sourceRoot": "", /* Specify the root path for debuggers to find the reference source code. */
// "mapRoot": "", /* Specify the location where debugger should locate map files instead of generated locations. */
// "inlineSources": true, /* Include source code in the sourcemaps inside the emitted JavaScript. */
// "emitBOM": true, /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
// "newLine": "crlf", /* Set the newline character for emitting files. */
// "stripInternal": true, /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
// "noEmitHelpers": true, /* Disable generating custom helper functions like '__extends' in compiled output. */
// "noEmitOnError": true, /* Disable emitting files if any type checking errors are reported. */
// "preserveConstEnums": true, /* Disable erasing 'const enum' declarations in generated code. */
// "declarationDir": "./", /* Specify the output directory for generated declaration files. */
/* Interop Constraints */
// "isolatedModules": true, /* Ensure that each file can be safely transpiled without relying on other imports. */
// "verbatimModuleSyntax": true, /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
// "isolatedDeclarations": true, /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
// "erasableSyntaxOnly": true, /* Do not allow runtime constructs that are not part of ECMAScript. */
// "allowSyntheticDefaultImports": true, /* Allow 'import x from y' when a module doesn't have a default export. */
"esModuleInterop": true, /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
// "preserveSymlinks": true, /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
"forceConsistentCasingInFileNames": true, /* Ensure that casing is correct in imports. */
/* Type Checking */
"strict": true, /* Enable all strict type-checking options. */
// "noImplicitAny": true, /* Enable error reporting for expressions and declarations with an implied 'any' type. */
// "strictNullChecks": true, /* When type checking, take into account 'null' and 'undefined'. */
// "strictFunctionTypes": true, /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
// "strictBindCallApply": true, /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
// "strictPropertyInitialization": true, /* Check for class properties that are declared but not set in the constructor. */
// "strictBuiltinIteratorReturn": true, /* Built-in iterators are instantiated with a 'TReturn' type of 'undefined' instead of 'any'. */
// "noImplicitThis": true, /* Enable error reporting when 'this' is given the type 'any'. */
// "useUnknownInCatchVariables": true, /* Default catch clause variables as 'unknown' instead of 'any'. */
// "alwaysStrict": true, /* Ensure 'use strict' is always emitted. */
// "noUnusedLocals": true, /* Enable error reporting when local variables aren't read. */
// "noUnusedParameters": true, /* Raise an error when a function parameter isn't read. */
// "exactOptionalPropertyTypes": true, /* Interpret optional property types as written, rather than adding 'undefined'. */
// "noImplicitReturns": true, /* Enable error reporting for codepaths that do not explicitly return in a function. */
// "noFallthroughCasesInSwitch": true, /* Enable error reporting for fallthrough cases in switch statements. */
// "noUncheckedIndexedAccess": true, /* Add 'undefined' to a type when accessed using an index. */
// "noImplicitOverride": true, /* Ensure overriding members in derived classes are marked with an override modifier. */
// "noPropertyAccessFromIndexSignature": true, /* Enforces using indexed accessors for keys declared using an indexed type. */
// "allowUnusedLabels": true, /* Disable error reporting for unused labels. */
// "allowUnreachableCode": true, /* Disable error reporting for unreachable code. */
/* Completeness */
// "skipDefaultLibCheck": true, /* Skip type checking .d.ts files that are included with TypeScript. */
"skipLibCheck": true /* Skip type checking all .d.ts files. */
},
"include": [
"src/**/*"
],
"exclude": [
"node_modules",
"dist"
]
}
```