Files
cp1-agents/mcp-servers/aws-discovery.server.yaml
Jonathan Boniface f659564208 Platform scripts, MCP servers, deployment and docs for the KAB runs
- Scripts to run workflows from a YAML context or run inputs (kab_run_workflow.py, with
  --input name=@file), store per-project discovery connections, bootstrap agent MCP keys,
  refresh the KAB token, publish reports and build estate snapshots.
- Hyperscaler discovery servers extended in place; cloud-knowledge folded into them.
- deploy/crucible-kab-dev.yaml: the Discovery package agent and the Assessment agents.
- Platform issue write-ups and current-wiring notes under docs/platform-issues/.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 22:13:25 +00:00

342 lines
17 KiB
YAML

# Read-only discovery of a customer's AWS estate. Render with scripts/render_mcp_server.py.
# Credentials arrive per call from the Vault Service. Store them per project, never tenant-wide.
server_id: aws-discovery
name: AWS Discovery
description: Read-only discovery of a customer's AWS estate - servers, workloads, Kubernetes clusters, networks,
data stores, policies and Trusted Advisor findings.
version: 0.1.2
port: 8112
verify_tool: aws_check_connection
shared_code:
- _common/tool_support.py
- _common/aws_support.py
extra_requirements:
- boto3==1.43.122
connection_fields:
- name: access_key_id
title: Access key ID
description: The broker identity that assumes the read-only role.
required: true
secret: false
- name: secret_access_key
title: Secret access key
description: The broker identity's secret key.
required: true
secret: true
- name: role_arn
title: Role ARN
description: The customer's read-only role.
required: true
secret: false
- name: external_id
title: External ID
description: The external id on the role's trust policy.
required: true
secret: true
- name: regions
title: Regions
description: Comma-separated regions that may be read. The first is the default.
required: true
secret: false
- name: account_ids
title: Account IDs
description: Comma-separated member accounts that may be read.
required: false
secret: false
- name: member_role_name
title: Member role name
description: The read-only role's name in member accounts.
required: false
secret: false
- name: aggregator_name
title: Config aggregator
description: An AWS Config aggregator for organisation-wide queries.
required: false
secret: false
tools:
- name: aws_check_connection
display_name: Check connection
description: 'Test the stored connection: assume the role and read its identity. Returns no customer data.'
parameters: []
ai_implementation: |
async def aws_check_connection(arguments: Dict[str, Any]) -> Dict[str, Any]:
try:
who = await _aws_call(arguments, "sts", "get_caller_identity")
except Exception as error:
return {"ok": False, "message": _upstream_failed("aws", error)["error"]["message"]}
return {"ok": True, "account": who.get("Account"), "message": "Assumed the read-only role."}
- name: aws_list_accounts
display_name: List accounts
description: List the organisation's accounts or organizational units. Needs the management or a delegated administrator
account.
parameters:
- name: kind
type: string
description: 'One of: accounts, roots.'
required: false
- &id001
name: page_size
type: integer
description: Items per page, up to 200. Default 50.
required: false
- &id002
name: page_token
type: string
description: next_page_token from the previous reply.
required: false
ai_implementation: |
async def aws_list_accounts(arguments: Dict[str, Any]) -> Dict[str, Any]:
kinds = {"accounts": ("organizations", "list_accounts", "Accounts", "NextToken", "NextToken", {}), "roots": ("organizations", "list_roots", "Roots", "NextToken", "NextToken", {})}
return await _aws_kind("aws_list_accounts", arguments, kinds, "accounts")
- name: aws_list_resources
display_name: List resources
description: List resources of one type that AWS Config has recorded.
parameters:
- name: resource_type
type: string
description: A Config type, such as AWS::EC2::Instance.
required: true
- &id003
name: account_id
type: string
description: 'An account from the connection''s list. Default: the connection''s own.'
required: false
- &id004
name: region
type: string
description: 'A region from the connection''s list. Default: the first.'
required: false
- *id001
- *id002
ai_implementation: |
async def aws_list_resources(arguments: Dict[str, Any]) -> Dict[str, Any]:
resource_type = str(arguments.get("resource_type") or "")
if not re.fullmatch(r"AWS::[A-Za-z0-9]+::[A-Za-z0-9]+", resource_type):
return _refuse("invalid_argument", "resource_type must be a Config type, such as AWS::EC2::Instance")
kinds = {"config": ("config", "list_discovered_resources", "resourceIdentifiers", "nextToken", "nextToken", {"resourceType": resource_type})}
return await _aws_kind("aws_list_resources", {**arguments, "kind": "config"}, kinds, "config")
- name: aws_query_resources
display_name: Query resources
description: Run a read-only AWS Config advanced query. Uses the organisation aggregator when the connection names
one.
parameters:
- name: query
type: string
description: A Config SELECT expression.
required: true
- *id003
- *id004
- *id001
- *id002
ai_implementation: |
async def aws_query_resources(arguments: Dict[str, Any]) -> Dict[str, Any]:
query = str(arguments.get("query") or "").strip()
if not query.upper().startswith("SELECT ") or len(query) > 4000:
return _refuse("invalid_argument", "query must be a SELECT, up to 4000 characters")
aggregator = get_connection().get("aggregator_name")
if aggregator:
kinds = {"q": ("config", "select_aggregate_resource_config", "Results", "NextToken", "NextToken", {"Expression": query, "ConfigurationAggregatorName": aggregator})}
else:
kinds = {"q": ("config", "select_resource_config", "Results", "NextToken", "NextToken", {"Expression": query})}
result = await _aws_kind("aws_query_resources", {**arguments, "kind": "q"}, kinds, "q")
if result.get("success"):
result["data"]["items"] = [_scrub(_aws_document(i)) for i in result["data"]["items"]]
return result
- name: aws_get_resource_metadata
display_name: Get resource metadata
description: Read-only provider metadata for one resource, from AWS Config.
parameters:
- name: resource_type
type: string
description: A Config type.
required: true
- name: resource_id
type: string
description: The resource id.
required: true
- name: scope_entry_id
type: string
description: The scope entry this answers, echoed in the reply.
required: false
- *id003
- *id004
ai_implementation: |
async def aws_get_resource_metadata(arguments: Dict[str, Any]) -> Dict[str, Any]:
account, region, refused = _aws_target(arguments)
if refused:
return refused
try:
body = await _aws_call(arguments, "config", "get_resource_config_history", region, resourceType=arguments.get("resource_type"), resourceId=arguments.get("resource_id"), limit=1)
except Exception as error:
return _upstream_failed("aws", error)
items = body.get("configurationItems", [])
if not items:
return _refuse("not_found", "AWS Config holds no record of this resource")
return _one_result("aws", "aws_get_resource_metadata", arguments, _aws_document(items[0]))
- name: aws_list_servers
display_name: List servers
description: List EC2 instances, Auto Scaling groups or EBS volumes.
parameters:
- name: kind
type: string
description: 'One of: instances, auto_scaling_groups, volumes.'
required: false
- *id003
- *id004
- *id001
- *id002
ai_implementation: |
async def aws_list_servers(arguments: Dict[str, Any]) -> Dict[str, Any]:
return await _aws_kind("aws_list_servers", arguments, AWS_SERVERS, "instances")
- name: aws_list_workloads
display_name: List workloads
description: List Lambda functions, ECS clusters, App Runner services or Elastic Beanstalk environments. Environment
variables are removed.
parameters:
- name: kind
type: string
description: 'One of: lambda_functions, ecs_clusters, app_runner_services, elastic_beanstalk_environments.'
required: false
- *id003
- *id004
- *id001
- *id002
ai_implementation: |
async def aws_list_workloads(arguments: Dict[str, Any]) -> Dict[str, Any]:
return await _aws_kind("aws_list_workloads", arguments, AWS_WORKLOADS, "lambda_functions")
- name: aws_list_kubernetes_clusters
display_name: List Kubernetes clusters
description: List EKS clusters with version, node groups and networking. Stops at the cloud control plane.
parameters:
- *id003
- *id004
- *id001
- *id002
ai_implementation: |
async def aws_list_kubernetes_clusters(arguments: Dict[str, Any]) -> Dict[str, Any]:
async def read(name, region):
cluster = (await _aws_call(arguments, "eks", "describe_cluster", region, name=name))["cluster"]
groups = await _aws_call(arguments, "eks", "list_nodegroups", region, clusterName=name)
return {**cluster, "nodegroups": groups.get("nodegroups", [])}
return await _aws_each("aws_list_kubernetes_clusters", arguments, ("eks", "list_clusters", "clusters", "nextToken", "nextToken", {}), read)
- name: aws_get_network_topology
display_name: Get network topology
description: List VPCs, subnets, route tables, security groups, NAT or internet gateways, transit gateways, peerings,
endpoints or load balancers.
parameters:
- name: kind
type: string
description: 'One of: vpcs, subnets, route_tables, security_groups, nat_gateways, internet_gateways, transit_gateways,
vpc_peering, vpc_endpoints, load_balancers.'
required: false
- *id003
- *id004
- *id001
- *id002
ai_implementation: |
async def aws_get_network_topology(arguments: Dict[str, Any]) -> Dict[str, Any]:
return await _aws_kind("aws_get_network_topology", arguments, AWS_NETWORK, "vpcs")
- name: aws_list_data_stores
display_name: List data stores
description: List RDS instances, DynamoDB tables or S3 buckets. Metadata only, never rows or objects.
parameters:
- name: kind
type: string
description: 'One of: rds_instances, dynamodb_tables, s3_buckets.'
required: false
- *id003
- *id004
- *id001
- *id002
ai_implementation: |
async def aws_list_data_stores(arguments: Dict[str, Any]) -> Dict[str, Any]:
return await _aws_kind("aws_list_data_stores", arguments, AWS_DATA, "rds_instances")
- name: aws_list_organization_policies
display_name: List organization policies
description: List Organizations policies with their documents, or Config rule compliance.
parameters:
- name: kind
type: string
description: 'One of: service_control_policies, resource_control_policies, tag_policies, backup_policies, config_rule_compliance.'
required: false
- *id003
- *id004
- *id001
- *id002
ai_implementation: "async def aws_list_organization_policies(arguments: Dict[str, Any]) -> Dict[str, Any]:\n \
\ kind = arguments.get(\"kind\") or \"service_control_policies\"\n if kind == \"config_rule_compliance\"\
:\n kinds = {kind: (\"config\", \"describe_compliance_by_config_rule\", \"ComplianceByConfigRules\",\
\ \"NextToken\", \"NextToken\", {})}\n return await _aws_kind(\"aws_list_organization_policies\", arguments,\
\ kinds, kind)\n if kind not in AWS_ORG_POLICY_TYPES:\n return _refuse(\"unknown_kind\", \"kind must\
\ be one of: \" + \", \".join(AWS_ORG_POLICY_TYPES) + \", config_rule_compliance\")\n \n async def read(entry,\
\ region):\n policy = (await _aws_call(arguments, \"organizations\", \"describe_policy\", region, PolicyId=entry[\"\
Id\"]))[\"Policy\"]\n targets = await _aws_call(arguments, \"organizations\", \"list_targets_for_policy\"\
, region, PolicyId=entry[\"Id\"])\n return {\"policy_id\": entry[\"Id\"], \"name\": entry.get(\"Name\"\
), \"type\": entry.get(\"Type\"), \"layer\": \"organisation\", \"aws_managed\": entry.get(\"AwsManaged\"), \"\
attached_to\": targets.get(\"Targets\", []), \"document\": _aws_document(policy.get(\"Content\"))}\n return\
\ await _aws_each(\"aws_list_organization_policies\", arguments, (\"organizations\", \"list_policies\", \"Policies\"\
, \"NextToken\", \"NextToken\", {\"Filter\": AWS_ORG_POLICY_TYPES[kind]}), read)\n"
- name: aws_list_resource_policies
display_name: List resource policies
description: 'List resource-based policies: S3 buckets, KMS keys, Lambda functions, SQS queues, SNS topics, or
IAM role trust policies. People are anonymised.'
parameters:
- name: kind
type: string
description: 'One of: s3_buckets, kms_keys, lambda_functions, sqs_queues, sns_topics, iam_role_trust.'
required: false
- *id003
- *id004
- *id001
- *id002
ai_implementation: "async def aws_list_resource_policies(arguments: Dict[str, Any]) -> Dict[str, Any]:\n kind\
\ = arguments.get(\"kind\") or \"s3_buckets\"\n \n def shaped(name, document, resource_type):\n \
\ return {\"name\": name, \"type\": resource_type, \"layer\": \"resource\", \"document\": _aws_document(document)}\n\
\ \n async def bucket(entry, region):\n body = await _aws_call(arguments, \"s3\", \"get_bucket_policy\"\
, region, Bucket=entry[\"Name\"])\n return shaped(entry[\"Name\"], body.get(\"Policy\"), \"s3_bucket\"\
)\n \n async def key(entry, region):\n body = await _aws_call(arguments, \"kms\", \"get_key_policy\"\
, region, KeyId=entry[\"KeyId\"], PolicyName=\"default\")\n return shaped(entry[\"KeyId\"], body.get(\"\
Policy\"), \"kms_key\")\n \n async def function(entry, region):\n body = await _aws_call(arguments,\
\ \"lambda\", \"get_policy\", region, FunctionName=entry[\"FunctionName\"])\n return shaped(entry[\"\
FunctionName\"], body.get(\"Policy\"), \"lambda_function\")\n \n async def queue(url, region):\n \
\ body = await _aws_call(arguments, \"sqs\", \"get_queue_attributes\", region, QueueUrl=url, AttributeNames=[\"\
Policy\"])\n return shaped(url, body.get(\"Attributes\", {}).get(\"Policy\"), \"sqs_queue\")\n \n\
\ async def topic(entry, region):\n body = await _aws_call(arguments, \"sns\", \"get_topic_attributes\"\
, region, TopicArn=entry[\"TopicArn\"])\n return shaped(entry[\"TopicArn\"], body.get(\"Attributes\"\
, {}).get(\"Policy\"), \"sns_topic\")\n \n async def role(entry, region):\n return shaped(entry[\"\
RoleName\"], entry.get(\"AssumeRolePolicyDocument\"), \"iam_role_trust\")\n \n kinds = {\"s3_buckets\"\
: ((\"s3\", \"list_buckets\", \"Buckets\", \"ContinuationToken\", \"ContinuationToken\", {}), bucket),\n \
\ \"kms_keys\": ((\"kms\", \"list_keys\", \"Keys\", \"Marker\", \"NextMarker\", {}), key),\n \
\ \"lambda_functions\": ((\"lambda\", \"list_functions\", \"Functions\", \"Marker\", \"NextMarker\", {}),\
\ function),\n \"sqs_queues\": ((\"sqs\", \"list_queues\", \"QueueUrls\", \"NextToken\", \"NextToken\"\
, {}), queue),\n \"sns_topics\": ((\"sns\", \"list_topics\", \"Topics\", \"NextToken\", \"NextToken\"\
, {}), topic),\n \"iam_role_trust\": ((\"iam\", \"list_roles\", \"Roles\", \"Marker\", \"Marker\"\
, {}), role)}\n if kind not in kinds:\n return _refuse(\"unknown_kind\", \"kind must be one of: \"\
\ + \", \".join(kinds))\n return await _aws_each(\"aws_list_resource_policies\", arguments, kinds[kind][0],\
\ kinds[kind][1])\n"
- name: aws_list_recommendations
display_name: List recommendations
description: List Trusted Advisor recommendations, each with a common Well-Architected pillar, or the customer's
existing Well-Architected Tool reviews.
parameters:
- name: kind
type: string
description: 'One of: trusted_advisor, well_architected_reviews.'
required: false
- *id003
- *id004
- *id001
- *id002
ai_implementation: "async def aws_list_recommendations(arguments: Dict[str, Any]) -> Dict[str, Any]:\n kind\
\ = arguments.get(\"kind\") or \"trusted_advisor\"\n if kind == \"well_architected_reviews\":\n async\
\ def read(entry, region):\n lenses = await _aws_call(arguments, \"wellarchitected\", \"list_lens_reviews\"\
, region, WorkloadId=entry[\"WorkloadId\"])\n return {\"workload\": entry, \"lens_reviews\": lenses.get(\"\
LensReviewSummaries\", [])}\n return await _aws_each(\"aws_list_recommendations\", arguments, (\"wellarchitected\"\
, \"list_workloads\", \"WorkloadSummaries\", \"NextToken\", \"NextToken\", {}), read)\n if kind != \"trusted_advisor\"\
:\n return _refuse(\"unknown_kind\", \"kind must be trusted_advisor or well_architected_reviews\")\n\
\ \n async def read(entry, region):\n pillars = entry.get(\"pillars\") or []\n return {**entry,\
\ \"pillar\": [AWS_PILLARS.get(p, \"other\") for p in pillars], \"provider_category\": pillars}\n return\
\ await _aws_each(\"aws_list_recommendations\", arguments, (\"trustedadvisor\", \"list_recommendations\", \"\
recommendationSummaries\", \"nextToken\", \"nextToken\", {}), read)\n"