infrawise 0.13.2 → 0.15.0

package/dist/server/index.js

@@ -8,7 +8,7 @@ import { z } from 'zod';
 import { logger } from '../core/index.js';
 const { version } = JSON.parse(readFileSync(join(import.meta.dirname, '../../package.json'), 'utf8'));
 import { summarizeFindings } from '../analyzers/index.js';
-import { getTableNodes, getFunctionNodes, getQueueNodes, getTopicNodes, getSecretNodes, getParameterNodes, getLogGroupNodes, getLambdaNodes, getEventBridgeRuleNodes, getBucketNodes, getAPINodes, getScanEdges, getOutgoingEdges, } from '../graph/index.js';
+import { getTableNodes, getFunctionNodes, getQueueNodes, getTopicNodes, getSecretNodes, getParameterNodes, getLogGroupNodes, getLambdaNodes, getEventBridgeRuleNodes, getBucketNodes, getAPINodes, getStackOutputNodes, getUserPoolNodes, getStreamNodes, getKafkaClusterNodes, getCacheClusterNodes, getScanEdges, getOutgoingEdges, } from '../graph/index.js';
 // ── State ────────────────────────────────────────────────────────────────────
 let currentGraph = { nodes: [], edges: [] };
 let currentFindings = [];
@@ -70,6 +70,7 @@ export function createMcpServer() {
         const lambdas = getLambdaNodes(currentGraph);
         const functions = getFunctionNodes(currentGraph);
         const buckets = getBucketNodes(currentGraph);
+        const userPools = getUserPoolNodes(currentGraph);
         return toText({
             configured,
             ...(configured ? {} : { setupHint: NOT_CONFIGURED_HINT }),
@@ -84,6 +85,9 @@ export function createMcpServer() {
                 logGroups: logGroups.length,
                 lambdas: lambdas.length,
                 buckets: buckets.length,
+                userPools: userPools.length,
+                streams: getStreamNodes(currentGraph).length,
+                cacheClusters: getCacheClusterNodes(currentGraph).length,
                 totalNodes: currentGraph.nodes.length,
                 totalEdges: currentGraph.edges.length,
                 findings: summarizeFindings(currentFindings),
@@ -300,7 +304,7 @@ export function createMcpServer() {
         });
     }));
     mcp.registerTool('get_queue_details', {
-        description: 'Returns all SQS queues with DLQ presence, encryption status, FIFO type (isFifo), visibility timeout, approximate message count, and retention days. When isFifo is true, all SendMessage calls must include a MessageGroupId. Call this when reviewing messaging architecture, investigating a message backlog, checking DLQ coverage, or verifying visibility timeout is set correctly relative to Lambda timeout (should be 6× the Lambda timeout). Use get_infra_overview for a quick queue count only.',
+        description: 'Returns all SQS queues with DLQ presence, encryption status, FIFO type (isFifo), visibility timeout, approximate message count, and retention days. When isFifo is true, all SendMessage calls must include a MessageGroupId. Call this when reviewing messaging architecture, investigating a message backlog, checking DLQ coverage, or verifying visibility timeout is set correctly relative to Lambda timeout (should be 6× the Lambda timeout). Use get_infra_overview for a quick queue count only. When runtime signals are enabled, oldestMessageAgeSec reports the age of the oldest message from CloudWatch.',
         inputSchema: z.object({}),
     }, logged('get_queue_details', async () => {
         const queues = getQueueNodes(currentGraph);
@@ -316,6 +320,7 @@ export function createMcpServer() {
                 visibilityTimeoutSec: q.visibilityTimeoutSec,
                 approximateMessages: q.approximateMessages,
                 retentionDays: q.retentionDays,
+                oldestMessageAgeSec: q.oldestMessageAgeSec,
                 findings: queueFindings
                     .filter((f) => f.metadata.queueName === q.name)
                     .map((f) => ({ severity: f.severity, issue: f.issue })),
@@ -375,7 +380,7 @@ export function createMcpServer() {
         });
     }));
     mcp.registerTool('get_lambda_overview', {
-        description: 'Returns all Lambda functions with runtime, memory (MB), timeout (sec), environment variable key names (values never returned), and event source triggers with the correct handler event shape for each. Call this when auditing Lambda configuration for default memory (128 MB) or high timeouts, or when you need the trigger event shape for a specific function without running analyze_function.',
+        description: 'Returns all Lambda functions with runtime, memory (MB), timeout (sec), environment variable key names (values never returned), and event source triggers with the correct handler event shape for each. Call this when auditing Lambda configuration for default memory (128 MB) or high timeouts, or when you need the trigger event shape for a specific function without running analyze_function. When runtime signals are enabled, recentThrottles and recentErrors report CloudWatch counts for the analysis window.',
         inputSchema: z.object({}),
     }, logged('get_lambda_overview', async () => {
         const lambdas = getLambdaNodes(currentGraph);
@@ -391,6 +396,8 @@ export function createMcpServer() {
                 envVarCount: l.envVarKeys?.length ?? 0,
                 envVarKeys: l.envVarKeys,
                 roleArn: l.roleArn,
+                recentThrottles: l.recentThrottles,
+                recentErrors: l.recentErrors,
                 triggers: (l.triggers ?? []).map((t) => ({
                     type: t.type,
                     source: t.sourceName,
@@ -480,6 +487,140 @@ export function createMcpServer() {
             })),
         });
     }));
+    mcp.registerTool('get_table_schema', {
+        description: 'Returns the full schema for specific tables or collections by name: columns with data types and nullability, primary keys, foreign keys (join paths), indexes, DynamoDB partition/sort keys, and MongoDB estimated document counts. Accepts short names ("orders" matches "public.orders") and is case-insensitive. Call this after get_infra_overview when you need column-level detail to write a SQL query, DynamoDB expression, or MongoDB filter for specific tables — instead of pulling every schema with get_graph_summary. Do NOT call for a table inventory; use get_infra_overview for that. Row data is never included.',
+        inputSchema: z.object({
+            tables: z
+                .array(z.string())
+                .min(1)
+                .max(20)
+                .describe('Table or collection names to fetch schemas for'),
+        }),
+    }, logged('get_table_schema', async ({ tables }) => {
+        const tableNodes = getTableNodes(currentGraph);
+        const indexNamesFor = (nodeId) => currentGraph.edges
+            .filter((e) => e.from === nodeId && e.type === 'uses_index')
+            .map((e) => currentGraph.nodes.find((n) => n.id === e.to))
+            .filter((n) => n?.type === 'index')
+            .map((n) => n.name);
+        const results = tables.map((requested) => {
+            const lower = requested.toLowerCase();
+            const matches = tableNodes.filter((t) => {
+                const name = t.name.toLowerCase();
+                return name === lower || name.split('.').pop() === lower;
+            });
+            if (matches.length === 0) {
+                const suggestions = tableNodes
+                    .filter((t) => t.name.toLowerCase().includes(lower))
+                    .map((t) => t.name)
+                    .slice(0, 5);
+                return { requested, found: false, ...(suggestions.length ? { suggestions } : {}) };
+            }
+            return {
+                requested,
+                found: true,
+                matches: matches.map((t) => ({
+                    name: t.name,
+                    databaseType: t.databaseType,
+                    ...(t.columns ? { columns: t.columns } : {}),
+                    ...(t.primaryKeys?.length ? { primaryKeys: t.primaryKeys } : {}),
+                    ...(t.foreignKeys?.length ? { foreignKeys: t.foreignKeys } : {}),
+                    ...(t.partitionKey ? { partitionKey: t.partitionKey } : {}),
+                    ...(t.sortKey ? { sortKey: t.sortKey } : {}),
+                    ...(t.estimatedCount !== undefined ? { estimatedCount: t.estimatedCount } : {}),
+                    indexes: indexNamesFor(t.id),
+                })),
+            };
+        });
+        return toText({
+            note: 'Row data is never included.',
+            tables: results,
+        });
+    }));
+    mcp.registerTool('get_cache_overview', {
+        description: 'Returns all ElastiCache clusters with engine, version, node type, node count, in-transit and at-rest encryption status, replication group, and automatic failover state. Call this before writing cache client code (TLS is required when transit encryption is on — rediss:// for Redis) or when reviewing cache availability and security posture. Cached data is never read or included.',
+        inputSchema: z.object({}),
+    }, logged('get_cache_overview', async () => {
+        const caches = getCacheClusterNodes(currentGraph);
+        const cacheFindings = currentFindings.filter((f) => f.metadata?.cacheClusterId);
+        return toText({
+            total: caches.length,
+            note: 'Cached data is never included.',
+            caches: caches.map((c) => ({
+                id: c.name,
+                engine: c.engine,
+                engineVersion: c.engineVersion,
+                nodeType: c.nodeType,
+                numNodes: c.numNodes,
+                transitEncryption: c.transitEncryption,
+                atRestEncryption: c.atRestEncryption,
+                replicationGroupId: c.replicationGroupId,
+                automaticFailover: c.automaticFailover,
+                findings: cacheFindings
+                    .filter((f) => f.metadata.cacheClusterId === c.name)
+                    .map((f) => ({ severity: f.severity, issue: f.issue })),
+            })),
+        });
+    }));
+    mcp.registerTool('get_stream_details', {
+        description: 'Returns all Kinesis data streams (status, shard count, retention hours, encryption, capacity mode) and Amazon MSK clusters (state, cluster type, Kafka version, broker count). Call this when writing Kinesis producer or consumer code, checking whether a stream is PROVISIONED or ON_DEMAND before writing PutRecord calls, or reviewing streaming architecture. For Kafka topic-level producer/consumer mappings extracted from application code, use get_topic_details instead.',
+        inputSchema: z.object({}),
+    }, logged('get_stream_details', async () => {
+        const streams = getStreamNodes(currentGraph);
+        const clusters = getKafkaClusterNodes(currentGraph);
+        return toText({
+            totalStreams: streams.length,
+            totalKafkaClusters: clusters.length,
+            streams: streams.map((s) => ({
+                name: s.name,
+                status: s.status,
+                shardCount: s.shardCount,
+                retentionHours: s.retentionHours,
+                encrypted: s.encrypted,
+                mode: s.mode,
+            })),
+            kafkaClusters: clusters.map((c) => ({
+                name: c.name,
+                state: c.state,
+                clusterType: c.clusterType,
+                kafkaVersion: c.kafkaVersion,
+                brokerNodes: c.brokerNodes,
+            })),
+        });
+    }));
+    mcp.registerTool('get_cognito_overview', {
+        description: 'Returns all Cognito user pools with MFA configuration and every app client config: allowed auth flows, OAuth flows/scopes, callback URLs, token validity, and whether the client has a secret (SDK auth calls must send SECRET_HASH when true). Client secret values are never returned. Call this before writing any Cognito sign-in, sign-up, or token-refresh code to use the correct auth flow and client settings. Do NOT call to look up users or tokens — infrawise never reads user data.',
+        inputSchema: z.object({}),
+    }, logged('get_cognito_overview', async () => {
+        const pools = getUserPoolNodes(currentGraph);
+        return toText({
+            total: pools.length,
+            note: 'Client secret values and user data are never included.',
+            userPools: pools.map((p) => ({
+                name: p.name,
+                id: p.poolId,
+                mfaConfiguration: p.mfaConfiguration,
+                clients: p.clients ?? [],
+            })),
+        });
+    }));
+    mcp.registerTool('get_stack_outputs', {
+        description: 'Returns all stack outputs and cross-stack exports parsed from local IaC files: Terraform output blocks and CloudFormation/CDK Outputs sections, with name, description, export name, and the raw value expression. Call this when wiring cross-stack references (Fn::ImportValue, terraform_remote_state) or when you need the exported name of a resource defined in another stack. Do NOT call for live resource attributes — outputs come from local IaC files, not the deployed stack.',
+        inputSchema: z.object({}),
+    }, logged('get_stack_outputs', async () => {
+        const outputs = getStackOutputNodes(currentGraph);
+        return toText({
+            total: outputs.length,
+            outputs: outputs.map((o) => ({
+                name: o.name,
+                description: o.description,
+                exportName: o.exportName,
+                value: o.value,
+                source: o.iacSource,
+                file: o.file,
+            })),
+        });
+    }));
     return mcp;
 }
 // ── Fastify server ────────────────────────────────────────────────────────────
@@ -519,6 +660,11 @@ export function createServer(port = 3000) {
             'get_s3_overview',
             'get_api_routes',
             'get_log_errors',
+            'get_stack_outputs',
+            'get_cognito_overview',
+            'get_stream_details',
+            'get_cache_overview',
+            'get_table_schema',
         ],
     }));
     fastify.post('/mcp', async (request, reply) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infrawise",
-  "version": "0.13.2",
+  "version": "0.15.0",
   "mcpName": "io.github.Sidd27/infrawise",
   "description": "CLI-first infrastructure intelligence platform — analyzes DynamoDB, PostgreSQL, MySQL, MongoDB, SQS, SNS, SSM, Secrets Manager, Lambda, S3, API Gateway, CloudWatch Logs and exposes findings as an MCP server for Claude Code",
   "keywords": [
@@ -76,10 +76,15 @@
   "dependencies": {
     "@aws-sdk/client-api-gateway": "^3.1068.0",
     "@aws-sdk/client-apigatewayv2": "^3.1068.0",
+    "@aws-sdk/client-cloudwatch": "^3.1079.0",
     "@aws-sdk/client-cloudwatch-logs": "^3.1048.0",
+    "@aws-sdk/client-cognito-identity-provider": "^3.1079.0",
     "@aws-sdk/client-dynamodb": "^3.1048.0",
+    "@aws-sdk/client-elasticache": "^3.1079.0",
     "@aws-sdk/client-eventbridge": "^3.1051.0",
     "@aws-sdk/client-iam": "^3.1073.0",
+    "@aws-sdk/client-kafka": "^3.1079.0",
+    "@aws-sdk/client-kinesis": "^3.1079.0",
     "@aws-sdk/client-lambda": "^3.1048.0",
     "@aws-sdk/client-rds": "^3.1048.0",
     "@aws-sdk/client-s3": "^3.1048.0",