@jaypie/mcp 0.2.12 → 0.3.1

package/dist/index.js

@@ -10,13 +10,15 @@ import * as fs from 'node:fs/promises';
 import matter from 'gray-matter';
 import * as https from 'node:https';
 import { Llm } from '@jaypie/llm';
+import { spawn } from 'node:child_process';
+import * as os from 'node:os';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { randomUUID } from 'node:crypto';
 
 /**
  * Datadog API integration module
  */
-const nullLogger = {
+const nullLogger$1 = {
     info: () => { },
     error: () => { },
 };
@@ -69,7 +71,7 @@ function buildDatadogQuery(options) {
 /**
  * Search Datadog logs
  */
-async function searchDatadogLogs(credentials, options = {}, logger = nullLogger) {
+async function searchDatadogLogs(credentials, options = {}, logger = nullLogger$1) {
     const effectiveQuery = buildDatadogQuery(options);
     const effectiveFrom = options.from || "now-15m";
     const effectiveTo = options.to || "now";
@@ -182,7 +184,7 @@ async function searchDatadogLogs(credentials, options = {}, logger = nullLogger)
  * Aggregate Datadog logs using the Analytics API
  * Groups logs by specified fields and computes aggregations
  */
-async function aggregateDatadogLogs(credentials, options, logger = nullLogger) {
+async function aggregateDatadogLogs(credentials, options, logger = nullLogger$1) {
     const effectiveQuery = buildDatadogQuery(options);
     const effectiveFrom = options.from || "now-15m";
     const effectiveTo = options.to || "now";
@@ -317,7 +319,7 @@ async function aggregateDatadogLogs(credentials, options, logger = nullLogger) {
 /**
  * List Datadog monitors with optional filtering
  */
-async function listDatadogMonitors(credentials, options = {}, logger = nullLogger) {
+async function listDatadogMonitors(credentials, options = {}, logger = nullLogger$1) {
     logger.info("Fetching Datadog monitors");
     const queryParams = new URLSearchParams();
     if (options.tags && options.tags.length > 0) {
@@ -415,7 +417,7 @@ async function listDatadogMonitors(credentials, options = {}, logger = nullLogge
 /**
  * List Datadog Synthetic tests
  */
-async function listDatadogSynthetics(credentials, options = {}, logger = nullLogger) {
+async function listDatadogSynthetics(credentials, options = {}, logger = nullLogger$1) {
     logger.info("Fetching Datadog Synthetic tests");
     return new Promise((resolve) => {
         const requestOptions = {
@@ -502,7 +504,7 @@ async function listDatadogSynthetics(credentials, options = {}, logger = nullLog
 /**
  * Get recent results for a specific Synthetic test
  */
-async function getDatadogSyntheticResults(credentials, publicId, logger = nullLogger) {
+async function getDatadogSyntheticResults(credentials, publicId, logger = nullLogger$1) {
     logger.info(`Fetching results for Synthetic test: ${publicId}`);
     return new Promise((resolve) => {
         const requestOptions = {
@@ -587,7 +589,7 @@ async function getDatadogSyntheticResults(credentials, publicId, logger = nullLo
 /**
  * Query Datadog metrics
  */
-async function queryDatadogMetrics(credentials, options, logger = nullLogger) {
+async function queryDatadogMetrics(credentials, options, logger = nullLogger$1) {
     logger.info(`Querying metrics: ${options.query}`);
     logger.info(`Time range: ${options.from} to ${options.to}`);
     const queryParams = new URLSearchParams({
@@ -680,7 +682,7 @@ async function queryDatadogMetrics(credentials, options, logger = nullLogger) {
 /**
  * Search Datadog RUM events
  */
-async function searchDatadogRum(credentials, options = {}, logger = nullLogger) {
+async function searchDatadogRum(credentials, options = {}, logger = nullLogger$1) {
     const effectiveQuery = options.query || "*";
     const effectiveFrom = options.from || "now-15m";
     const effectiveTo = options.to || "now";
@@ -885,7 +887,328 @@ function listLlmProviders() {
     };
 }
 
-const BUILD_VERSION_STRING = "@jaypie/mcp@0.2.12#512ddebf"
+/**
+ * AWS CLI integration module
+ * Provides a structured interface for common AWS operations via the AWS CLI
+ */
+const nullLogger = {
+    info: () => { },
+    error: () => { },
+};
+/**
+ * Parse AWS CLI error messages into user-friendly descriptions
+ */
+function parseAwsError(stderr, service, command) {
+    if (stderr.includes("ExpiredToken") || stderr.includes("Token has expired")) {
+        return "AWS credentials have expired. Run 'aws sso login' or refresh your credentials.";
+    }
+    if (stderr.includes("NoCredentialProviders") ||
+        stderr.includes("Unable to locate credentials")) {
+        return "No AWS credentials found. Configure credentials with 'aws configure' or 'aws sso login'.";
+    }
+    if (stderr.includes("AccessDenied") || stderr.includes("Access Denied")) {
+        return `Access denied for ${service}:${command}. Check your IAM permissions.`;
+    }
+    if (stderr.includes("ResourceNotFoundException")) {
+        return `Resource not found. Check that the specified resource exists in the correct region.`;
+    }
+    if (stderr.includes("ValidationException")) {
+        const match = stderr.match(/ValidationException[^:]*:\s*(.+)/);
+        return match
+            ? `Validation error: ${match[1].trim()}`
+            : "Validation error in request parameters.";
+    }
+    if (stderr.includes("ThrottlingException") ||
+        stderr.includes("Rate exceeded")) {
+        return "AWS API rate limit exceeded. Wait a moment and try again.";
+    }
+    if (stderr.includes("InvalidParameterValue")) {
+        const match = stderr.match(/InvalidParameterValue[^:]*:\s*(.+)/);
+        return match
+            ? `Invalid parameter: ${match[1].trim()}`
+            : "Invalid parameter value provided.";
+    }
+    return stderr.trim();
+}
+/**
+ * Parse relative time strings like 'now-1h' to Unix timestamps
+ */
+function parseRelativeTime(timeStr) {
+    const now = Date.now();
+    if (timeStr === "now") {
+        return now;
+    }
+    // Handle relative time like 'now-15m', 'now-1h', 'now-1d'
+    const relativeMatch = timeStr.match(/^now-(\d+)([smhd])$/);
+    if (relativeMatch) {
+        const value = parseInt(relativeMatch[1], 10);
+        const unit = relativeMatch[2];
+        const multipliers = {
+            s: 1000,
+            m: 60 * 1000,
+            h: 60 * 60 * 1000,
+            d: 24 * 60 * 60 * 1000,
+        };
+        return now - value * multipliers[unit];
+    }
+    // Handle ISO 8601 format
+    const parsed = Date.parse(timeStr);
+    if (!isNaN(parsed)) {
+        return parsed;
+    }
+    // Default to the current time if parsing fails
+    return now;
+}
+/**
+ * Execute an AWS CLI command and return parsed JSON output
+ */
+async function executeAwsCommand(service, command, args, options = {}, logger = nullLogger) {
+    const fullArgs = [service, command, ...args, "--output", "json"];
+    if (options.profile) {
+        fullArgs.push("--profile", options.profile);
+    }
+    if (options.region) {
+        fullArgs.push("--region", options.region);
+    }
+    logger.info(`Executing: aws ${fullArgs.join(" ")}`);
+    return new Promise((resolve) => {
+        const proc = spawn("aws", fullArgs);
+        let stdout = "";
+        let stderr = "";
+        proc.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        proc.on("close", (code) => {
+            if (code !== 0) {
+                logger.error(`AWS CLI error: ${stderr}`);
+                resolve({
+                    success: false,
+                    error: parseAwsError(stderr, service, command),
+                });
+                return;
+            }
+            // Handle empty output (some commands return nothing on success)
+            if (!stdout.trim()) {
+                resolve({ success: true });
+                return;
+            }
+            try {
+                const data = JSON.parse(stdout);
+                resolve({ success: true, data });
+            }
+            catch {
+                // Some commands return plain text
+                resolve({ success: true, data: stdout.trim() });
+            }
+        });
+        proc.on("error", (error) => {
+            if (error.message.includes("ENOENT")) {
+                resolve({
+                    success: false,
+                    error: "AWS CLI not found. Install it from https://aws.amazon.com/cli/",
+                });
+            }
+            else {
+                resolve({ success: false, error: error.message });
+            }
+        });
+    });
+}
+/**
+ * List available AWS profiles from ~/.aws/config and ~/.aws/credentials
+ */
+async function listAwsProfiles(logger = nullLogger) {
+    const profiles = [];
+    const homeDir = os.homedir();
+    try {
+        // Parse ~/.aws/config
+        const configPath = path.join(homeDir, ".aws", "config");
+        try {
+            const configContent = await fs.readFile(configPath, "utf-8");
+            const profileRegex = /\[profile\s+([^\]]+)\]|\[default\]/g;
+            let match;
+            while ((match = profileRegex.exec(configContent)) !== null) {
+                const name = match[1] || "default";
+                profiles.push({
+                    name,
+                    source: "config",
+                });
+            }
+            logger.info(`Found ${profiles.length} profiles in config`);
+        }
+        catch {
+            logger.info("No ~/.aws/config file found");
+        }
+        // Parse ~/.aws/credentials
+        const credentialsPath = path.join(homeDir, ".aws", "credentials");
+        try {
+            const credentialsContent = await fs.readFile(credentialsPath, "utf-8");
+            const profileRegex = /\[([^\]]+)\]/g;
+            let match;
+            while ((match = profileRegex.exec(credentialsContent)) !== null) {
+                const name = match[1];
+                // Only add if not already in the list
+                if (!profiles.find((p) => p.name === name)) {
+                    profiles.push({
+                        name,
+                        source: "credentials",
+                    });
+                }
+            }
+            logger.info(`Total profiles after credentials: ${profiles.length}`);
+        }
+        catch {
+            logger.info("No ~/.aws/credentials file found");
+        }
+        return { success: true, data: profiles };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        logger.error(`Error listing profiles: ${errorMessage}`);
+        return { success: false, error: errorMessage };
+    }
+}
+// Step Functions operations
+async function listStepFunctionExecutions(options, logger = nullLogger) {
+    const args = ["--state-machine-arn", options.stateMachineArn];
+    if (options.statusFilter) {
+        args.push("--status-filter", options.statusFilter);
+    }
+    if (options.maxResults) {
+        args.push("--max-results", String(options.maxResults));
+    }
+    return executeAwsCommand("stepfunctions", "list-executions", args, { profile: options.profile, region: options.region }, logger);
+}
+async function stopStepFunctionExecution(options, logger = nullLogger) {
+    const args = ["--execution-arn", options.executionArn];
+    if (options.cause) {
+        args.push("--cause", options.cause);
+    }
+    return executeAwsCommand("stepfunctions", "stop-execution", args, { profile: options.profile, region: options.region }, logger);
+}
+// Lambda operations
+async function listLambdaFunctions(options = {}, logger = nullLogger) {
+    const args = [];
+    if (options.maxResults) {
+        args.push("--max-items", String(options.maxResults));
+    }
+    const result = await executeAwsCommand("lambda", "list-functions", args, { profile: options.profile, region: options.region }, logger);
+    // Filter by prefix if specified
+    if (result.success && result.data && options.functionNamePrefix) {
+        result.data.Functions = result.data.Functions.filter((f) => f.FunctionName.startsWith(options.functionNamePrefix));
+    }
+    return result;
+}
+async function getLambdaFunction(options, logger = nullLogger) {
+    return executeAwsCommand("lambda", "get-function", ["--function-name", options.functionName], { profile: options.profile, region: options.region }, logger);
+}
+// CloudWatch Logs operations
+async function filterLogEvents(options, logger = nullLogger) {
+    const args = ["--log-group-name", options.logGroupName];
+    if (options.filterPattern) {
+        args.push("--filter-pattern", options.filterPattern);
+    }
+    if (options.startTime) {
+        const startMs = parseRelativeTime(options.startTime);
+        args.push("--start-time", String(startMs));
+    }
+    if (options.endTime) {
+        const endMs = parseRelativeTime(options.endTime);
+        args.push("--end-time", String(endMs));
+    }
+    {
+        args.push("--limit", String(options.limit));
+    }
+    return executeAwsCommand("logs", "filter-log-events", args, { profile: options.profile, region: options.region }, logger);
+}
+// S3 operations
+async function listS3Objects(options, logger = nullLogger) {
+    const args = ["--bucket", options.bucket];
+    if (options.prefix) {
+        args.push("--prefix", options.prefix);
+    }
+    if (options.maxResults) {
+        args.push("--max-items", String(options.maxResults));
+    }
+    return executeAwsCommand("s3api", "list-objects-v2", args, { profile: options.profile, region: options.region }, logger);
+}
+// CloudFormation operations
+async function describeStack(options, logger = nullLogger) {
+    return executeAwsCommand("cloudformation", "describe-stacks", ["--stack-name", options.stackName], { profile: options.profile, region: options.region }, logger);
+}
+// DynamoDB operations
+async function describeDynamoDBTable(options, logger = nullLogger) {
+    return executeAwsCommand("dynamodb", "describe-table", ["--table-name", options.tableName], { profile: options.profile, region: options.region }, logger);
+}
+async function scanDynamoDB(options, logger = nullLogger) {
+    const args = ["--table-name", options.tableName];
+    if (options.filterExpression) {
+        args.push("--filter-expression", options.filterExpression);
+    }
+    if (options.expressionAttributeValues) {
+        args.push("--expression-attribute-values", options.expressionAttributeValues);
+    }
+    {
+        args.push("--limit", String(options.limit));
+    }
+    return executeAwsCommand("dynamodb", "scan", args, { profile: options.profile, region: options.region }, logger);
+}
+async function queryDynamoDB(options, logger = nullLogger) {
+    const args = [
+        "--table-name",
+        options.tableName,
+        "--key-condition-expression",
+        options.keyConditionExpression,
+        "--expression-attribute-values",
+        options.expressionAttributeValues,
+    ];
+    if (options.indexName) {
+        args.push("--index-name", options.indexName);
+    }
+    if (options.filterExpression) {
+        args.push("--filter-expression", options.filterExpression);
+    }
+    if (options.limit) {
+        args.push("--limit", String(options.limit));
+    }
+    if (options.scanIndexForward === false) {
+        args.push("--no-scan-index-forward");
+    }
+    return executeAwsCommand("dynamodb", "query", args, { profile: options.profile, region: options.region }, logger);
+}
+async function getDynamoDBItem(options, logger = nullLogger) {
+    return executeAwsCommand("dynamodb", "get-item", ["--table-name", options.tableName, "--key", options.key], { profile: options.profile, region: options.region }, logger);
+}
+// SQS operations
+async function listSQSQueues(options = {}, logger = nullLogger) {
+    const args = [];
+    if (options.queueNamePrefix) {
+        args.push("--queue-name-prefix", options.queueNamePrefix);
+    }
+    return executeAwsCommand("sqs", "list-queues", args, { profile: options.profile, region: options.region }, logger);
+}
+async function getSQSQueueAttributes(options, logger = nullLogger) {
+    return executeAwsCommand("sqs", "get-queue-attributes", ["--queue-url", options.queueUrl, "--attribute-names", "All"], { profile: options.profile, region: options.region }, logger);
+}
+async function receiveSQSMessage(options, logger = nullLogger) {
+    const args = ["--queue-url", options.queueUrl];
+    {
+        args.push("--max-number-of-messages", String(options.maxNumberOfMessages));
+    }
+    {
+        args.push("--visibility-timeout", String(options.visibilityTimeout));
+    }
+    args.push("--attribute-names", "All");
+    return executeAwsCommand("sqs", "receive-message", args, { profile: options.profile, region: options.region }, logger);
+}
+async function purgeSQSQueue(options, logger = nullLogger) {
+    return executeAwsCommand("sqs", "purge-queue", ["--queue-url", options.queueUrl], { profile: options.profile, region: options.region }, logger);
+}
+
+const BUILD_VERSION_STRING = "@jaypie/mcp@0.3.1#4e71c6ce"
     ;
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = path.dirname(__filename$1);
@@ -1780,6 +2103,853 @@ function createMcpServer(options = {}) {
         };
     });
     log.info("Registered tool: llm_list_providers");
+    // AWS CLI Tools
+    // AWS List Profiles
+    server.tool("aws_list_profiles", "List available AWS profiles from ~/.aws/config and credentials.", {}, async () => {
+        log.info("Tool called: aws_list_profiles");
+        const result = await listAwsProfiles(log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error listing profiles: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        const profiles = result.data || [];
+        if (profiles.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "No AWS profiles found. Configure profiles in ~/.aws/config or ~/.aws/credentials.",
+                    },
+                ],
+            };
+        }
+        const formatted = profiles
+            .map((p) => `- ${p.name} (${p.source})`)
+            .join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `Found ${profiles.length} AWS profiles:`,
+                        "",
+                        formatted,
+                        "",
+                        "Use the 'profile' parameter in other AWS tools to specify which profile to use.",
+                    ].join("\n"),
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: aws_list_profiles");
+    // Step Functions: List Executions
+    server.tool("aws_stepfunctions_list_executions", "List Step Function executions for a state machine. Useful for finding stuck or running executions.", {
+        stateMachineArn: z.string().describe("ARN of the state machine"),
+        statusFilter: z
+            .enum([
+            "RUNNING",
+            "SUCCEEDED",
+            "FAILED",
+            "TIMED_OUT",
+            "ABORTED",
+            "PENDING_REDRIVE",
+        ])
+            .optional()
+            .describe("Filter by execution status"),
+        profile: z.string().optional().describe("AWS profile to use"),
+        region: z.string().optional().describe("AWS region"),
+        maxResults: z
+            .number()
+            .optional()
+            .describe("Max results (1-1000, default 100)"),
+    }, async ({ stateMachineArn, statusFilter, profile, region, maxResults }) => {
+        log.info("Tool called: aws_stepfunctions_list_executions");
+        const result = await listStepFunctionExecutions({
+            stateMachineArn,
+            statusFilter,
+            profile,
+            region,
+            maxResults,
+        }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        const executions = result.data?.executions || [];
+        if (executions.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No ${statusFilter || ""} executions found for state machine.`,
+                    },
+                ],
+            };
+        }
+        const formatted = executions
+            .map((e) => `- ${e.name} (${e.status}) started ${e.startDate}`)
+            .join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `Found ${executions.length} executions:`,
+                        "",
+                        formatted,
+                        "",
+                        "Use aws_stepfunctions_stop_execution to stop running executions.",
+                    ].join("\n"),
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: aws_stepfunctions_list_executions");
+    // Step Functions: Stop Execution
+    server.tool("aws_stepfunctions_stop_execution", "Stop a running Step Function execution. Use with caution - this will abort the workflow.", {
+        executionArn: z.string().describe("ARN of the execution to stop"),
+        cause: z
+            .string()
+            .optional()
+            .describe("Description of why the execution was stopped"),
+        profile: z.string().optional().describe("AWS profile to use"),
+        region: z.string().optional().describe("AWS region"),
+    }, async ({ executionArn, cause, profile, region }) => {
+        log.info("Tool called: aws_stepfunctions_stop_execution");
+        const result = await stopStepFunctionExecution({
+            executionArn,
+            cause,
+            profile,
+            region,
+        }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error stopping execution: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Execution stopped successfully at ${result.data?.stopDate || "unknown time"}.`,
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: aws_stepfunctions_stop_execution");
+    // Lambda: List Functions
+    server.tool("aws_lambda_list_functions", "List Lambda functions in the account. Filter by function name prefix.", {
+        functionNamePrefix: z
+            .string()
+            .optional()
+            .describe("Filter by function name prefix"),
+        profile: z.string().optional().describe("AWS profile to use"),
+        region: z.string().optional().describe("AWS region"),
+        maxResults: z.number().optional().describe("Max results to return"),
+    }, async ({ functionNamePrefix, profile, region, maxResults }) => {
+        log.info("Tool called: aws_lambda_list_functions");
+        const result = await listLambdaFunctions({
+            functionNamePrefix,
+            profile,
+            region,
+            maxResults,
+        }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        const functions = result.data?.Functions || [];
+        if (functions.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: functionNamePrefix
+                            ? `No functions found with prefix "${functionNamePrefix}".`
+                            : "No Lambda functions found in this account/region.",
+                    },
+                ],
+            };
+        }
+        const formatted = functions
+            .map((f) => `- ${f.FunctionName} (${f.Runtime || "unknown runtime"}, ${f.MemorySize}MB)`)
+            .join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `Found ${functions.length} Lambda functions:`,
+                        "",
+                        formatted,
+                        "",
+                        "Use aws_lambda_get_function for details on a specific function.",
+                    ].join("\n"),
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: aws_lambda_list_functions");
+    // Lambda: Get Function
+    server.tool("aws_lambda_get_function", "Get configuration and details for a specific Lambda function.", {
+        functionName: z.string().describe("Function name or ARN"),
+        profile: z.string().optional().describe("AWS profile to use"),
+        region: z.string().optional().describe("AWS region"),
+    }, async ({ functionName, profile, region }) => {
+        log.info("Tool called: aws_lambda_get_function");
+        const result = await getLambdaFunction({
+            functionName,
+            profile,
+            region,
+        }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result.data, null, 2),
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: aws_lambda_get_function");
+    // CloudWatch Logs: Filter Log Events
+    server.tool("aws_logs_filter_log_events", "Search CloudWatch Logs for a log group. Filter by pattern and time range.", {
+        logGroupName: z
+            .string()
+            .describe("Log group name (e.g., /aws/lambda/my-function)"),
+        filterPattern: z
+            .string()
+            .optional()
+            .describe("CloudWatch filter pattern (e.g., 'ERROR', '{ $.level = \"error\" }')"),
+        startTime: z
+            .string()
+            .optional()
+            .describe("Start time (ISO 8601 or relative like 'now-1h'). Defaults to 'now-15m'."),
+        endTime: z
+            .string()
+            .optional()
+            .describe("End time (ISO 8601 or 'now'). Defaults to 'now'."),
+        profile: z.string().optional().describe("AWS profile to use"),
+        region: z.string().optional().describe("AWS region"),
+        limit: z
+            .number()
+            .optional()
+            .describe("Max events to return (default 100)"),
+    }, async ({ logGroupName, filterPattern, startTime, endTime, profile, region, limit, }) => {
+        log.info("Tool called: aws_logs_filter_log_events");
+        const result = await filterLogEvents({
+            logGroupName,
+            filterPattern,
+            startTime: startTime || "now-15m",
+            endTime: endTime || "now",
+            limit: limit || 100,
+            profile,
+            region,
+        }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        const events = result.data?.events || [];
+        if (events.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No log events found matching the filter in ${logGroupName}.`,
+                    },
+                ],
+            };
+        }
+        const formatted = events
+            .map((e) => {
+            const timestamp = new Date(e.timestamp).toISOString();
+            return `[${timestamp}] ${e.message}`;
+        })
+            .join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [`Found ${events.length} log events:`, "", formatted].join("\n"),
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: aws_logs_filter_log_events");
+    // S3: List Objects
+    server.tool("aws_s3_list_objects", "List objects in an S3 bucket with optional prefix filtering.", {
+        bucket: z.string().describe("S3 bucket name"),
+        prefix: z.string().optional().describe("Object key prefix filter"),
+        profile: z.string().optional().describe("AWS profile to use"),
+        region: z.string().optional().describe("AWS region"),
+        maxResults: z.number().optional().describe("Max results to return"),
+    }, async ({ bucket, prefix, profile, region, maxResults }) => {
+        log.info("Tool called: aws_s3_list_objects");
+        const result = await listS3Objects({
+            bucket,
+            prefix,
+            profile,
+            region,
+            maxResults,
+        }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        const objects = result.data?.Contents || [];
+        if (objects.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: prefix
+                            ? `No objects found with prefix "${prefix}" in bucket ${bucket}.`
+                            : `Bucket ${bucket} is empty.`,
+                    },
+                ],
+            };
+        }
+        const formatted = objects
+            .map((o) => {
+            const size = o.Size < 1024
+                ? `${o.Size}B`
+                : o.Size < 1024 * 1024
+                    ? `${(o.Size / 1024).toFixed(1)}KB`
+                    : `${(o.Size / (1024 * 1024)).toFixed(1)}MB`;
+            return `- ${o.Key} (${size}, ${o.LastModified})`;
+        })
+            .join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `Found ${objects.length} objects in ${bucket}:`,
+                        "",
+                        formatted,
+                    ].join("\n"),
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: aws_s3_list_objects");
+    // CloudFormation: Describe Stack
+    server.tool("aws_cloudformation_describe_stack", "Get details and status of a CloudFormation stack.", {
+        stackName: z.string().describe("Stack name or ARN"),
+        profile: z.string().optional().describe("AWS profile to use"),
+        region: z.string().optional().describe("AWS region"),
+    }, async ({ stackName, profile, region }) => {
+        log.info("Tool called: aws_cloudformation_describe_stack");
+        const result = await describeStack({
+            stackName,
+            profile,
+            region,
+        }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        const stack = result.data?.Stacks?.[0];
+        if (!stack) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Stack "${stackName}" not found.`,
+                    },
+                ],
+            };
+        }
+        const outputs = stack.Outputs?.map((o) => `  - ${o.OutputKey}: ${o.OutputValue}`).join("\n");
+        const params = stack.Parameters?.map((p) => `  - ${p.ParameterKey}: ${p.ParameterValue}`).join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `Stack: ${stack.StackName}`,
+                        `Status: ${stack.StackStatus}`,
+                        stack.StackStatusReason
+                            ? `Reason: ${stack.StackStatusReason}`
+                            : null,
+                        `Created: ${stack.CreationTime}`,
+                        stack.LastUpdatedTime
+                            ? `Last Updated: ${stack.LastUpdatedTime}`
+                            : null,
+                        stack.Description ? `Description: ${stack.Description}` : null,
+                        "",
+                        outputs ? `Outputs:\n${outputs}` : null,
+                        params ? `Parameters:\n${params}` : null,
+                    ]
+                        .filter(Boolean)
+                        .join("\n"),
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: aws_cloudformation_describe_stack");
+    // DynamoDB: Describe Table
+    server.tool("aws_dynamodb_describe_table", "Get metadata about a DynamoDB table including key schema, indexes, and provisioned capacity.", {
+        tableName: z.string().describe("DynamoDB table name"),
+        profile: z.string().optional().describe("AWS profile to use"),
+        region: z.string().optional().describe("AWS region"),
+    }, async ({ tableName, profile, region }) => {
+        log.info("Tool called: aws_dynamodb_describe_table");
+        const result = await describeDynamoDBTable({
+            tableName,
+            profile,
+            region,
+        }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result.data?.Table, null, 2),
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: aws_dynamodb_describe_table");
+    // DynamoDB: Scan
+    server.tool("aws_dynamodb_scan", "Scan a DynamoDB table. Use sparingly on large tables - prefer query when possible.", {
+        tableName: z.string().describe("DynamoDB table name"),
+        filterExpression: z
+            .string()
+            .optional()
+            .describe("Filter expression (e.g., 'status = :s')"),
+        expressionAttributeValues: z
+            .string()
+            .optional()
+            .describe('JSON object of attribute values (e.g., \'{\\":s\\":{\\"S\\":\\"active\\"}}\')'),
+        limit: z.number().optional().describe("Max items to return (default 25)"),
+        profile: z.string().optional().describe("AWS profile to use"),
+        region: z.string().optional().describe("AWS region"),
+    }, async ({ tableName, filterExpression, expressionAttributeValues, limit, profile, region, }) => {
+        log.info("Tool called: aws_dynamodb_scan");
+        const result = await scanDynamoDB({
+            tableName,
+            filterExpression,
+            expressionAttributeValues,
+            limit: limit || 25,
+            profile,
+            region,
+        }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        const items = result.data?.Items || [];
+        if (items.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No items found in table ${tableName}.`,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `Found ${items.length} items:`,
+                        "",
+                        JSON.stringify(items, null, 2),
+                    ].join("\n"),
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: aws_dynamodb_scan");
+    // DynamoDB: Query
+    server.tool("aws_dynamodb_query", "Query a DynamoDB table by partition key. More efficient than scan for targeted lookups.", {
+        tableName: z.string().describe("DynamoDB table name"),
+        keyConditionExpression: z
+            .string()
+            .describe("Key condition (e.g., 'pk = :pk')"),
+        expressionAttributeValues: z
+            .string()
+            .describe("JSON object of attribute values"),
+        indexName: z.string().optional().describe("GSI or LSI name to query"),
+        filterExpression: z
+            .string()
+            .optional()
+            .describe("Additional filter expression"),
+        limit: z.number().optional().describe("Max items to return"),
+        scanIndexForward: z
+            .boolean()
+            .optional()
+            .describe("Sort ascending (true) or descending (false)"),
+        profile: z.string().optional().describe("AWS profile to use"),
+        region: z.string().optional().describe("AWS region"),
+    }, async ({ tableName, keyConditionExpression, expressionAttributeValues, indexName, filterExpression, limit, scanIndexForward, profile, region, }) => {
+        log.info("Tool called: aws_dynamodb_query");
+        const result = await queryDynamoDB({
+            tableName,
+            keyConditionExpression,
+            expressionAttributeValues,
+            indexName,
+            filterExpression,
+            limit,
+            scanIndexForward,
+            profile,
+            region,
+        }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        const items = result.data?.Items || [];
+        if (items.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No items found matching the query.`,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `Found ${items.length} items:`,
+                        "",
+                        JSON.stringify(items, null, 2),
+                    ].join("\n"),
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: aws_dynamodb_query");
+    // DynamoDB: Get Item
+    server.tool("aws_dynamodb_get_item", "Get a single item from a DynamoDB table by its primary key.", {
+        tableName: z.string().describe("DynamoDB table name"),
+        key: z
+            .string()
+            .describe('JSON object of the primary key (e.g., \'{\\"pk\\":{\\"S\\":\\"user#123\\"},\\"sk\\":{\\"S\\":\\"profile\\"}}\')'),
+        profile: z.string().optional().describe("AWS profile to use"),
+        region: z.string().optional().describe("AWS region"),
+    }, async ({ tableName, key, profile, region }) => {
+        log.info("Tool called: aws_dynamodb_get_item");
+        const result = await getDynamoDBItem({
+            tableName,
+            key,
+            profile,
+            region,
+        }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        if (!result.data?.Item) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Item not found with the specified key.`,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result.data.Item, null, 2),
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: aws_dynamodb_get_item");
+    // SQS: List Queues
+    server.tool("aws_sqs_list_queues", "List SQS queues in the account. Filter by queue name prefix.", {
+        queueNamePrefix: z
+            .string()
+            .optional()
+            .describe("Filter by queue name prefix"),
+        profile: z.string().optional().describe("AWS profile to use"),
+        region: z.string().optional().describe("AWS region"),
+    }, async ({ queueNamePrefix, profile, region }) => {
+        log.info("Tool called: aws_sqs_list_queues");
+        const result = await listSQSQueues({
+            queueNamePrefix,
+            profile,
+            region,
+        }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        const queues = result.data?.QueueUrls || [];
+        if (queues.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: queueNamePrefix
+                            ? `No queues found with prefix "${queueNamePrefix}".`
+                            : "No SQS queues found in this account/region.",
+                    },
+                ],
+            };
+        }
+        const formatted = queues.map((url) => `- ${url}`).join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `Found ${queues.length} queues:`,
+                        "",
+                        formatted,
+                        "",
+                        "Use aws_sqs_get_queue_attributes for details on a specific queue.",
+                    ].join("\n"),
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: aws_sqs_list_queues");
+    // SQS: Get Queue Attributes
+    server.tool("aws_sqs_get_queue_attributes", "Get attributes for an SQS queue including approximate message count, visibility timeout, and dead-letter config.", {
+        queueUrl: z.string().describe("SQS queue URL"),
+        profile: z.string().optional().describe("AWS profile to use"),
+        region: z.string().optional().describe("AWS region"),
+    }, async ({ queueUrl, profile, region }) => {
+        log.info("Tool called: aws_sqs_get_queue_attributes");
+        const result = await getSQSQueueAttributes({
+            queueUrl,
+            profile,
+            region,
+        }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        const attrs = result.data?.Attributes;
+        if (!attrs) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No attributes found for queue.`,
+                    },
+                ],
+            };
+        }
+        const formatted = Object.entries(attrs)
+            .map(([key, value]) => `- ${key}: ${value}`)
+            .join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [`Queue Attributes:`, "", formatted].join("\n"),
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: aws_sqs_get_queue_attributes");
+    // SQS: Receive Message
+    server.tool("aws_sqs_receive_message", "Receive messages from an SQS queue for inspection. Messages are returned to the queue after visibility timeout.", {
+        queueUrl: z.string().describe("SQS queue URL"),
+        maxNumberOfMessages: z
+            .number()
+            .optional()
+            .describe("Max messages to receive (1-10, default 1)"),
+        visibilityTimeout: z
+            .number()
+            .optional()
+            .describe("Seconds to hide message (default 30)"),
+        profile: z.string().optional().describe("AWS profile to use"),
+        region: z.string().optional().describe("AWS region"),
+    }, async ({ queueUrl, maxNumberOfMessages, visibilityTimeout, profile, region, }) => {
+        log.info("Tool called: aws_sqs_receive_message");
+        const result = await receiveSQSMessage({
+            queueUrl,
+            maxNumberOfMessages: maxNumberOfMessages || 1,
+            visibilityTimeout: visibilityTimeout || 30,
+            profile,
+            region,
+        }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        const messages = result.data?.Messages || [];
+        if (messages.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No messages available in the queue.`,
+                    },
+                ],
+            };
+        }
+        const formatted = messages
+            .map((m, i) => {
+            return [
+                `Message ${i + 1}:`,
+                `  ID: ${m.MessageId}`,
+                `  Body: ${m.Body}`,
+                m.Attributes
+                    ? `  Attributes: ${JSON.stringify(m.Attributes)}`
+                    : null,
+            ]
+                .filter(Boolean)
+                .join("\n");
+        })
+            .join("\n\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `Received ${messages.length} messages (will be returned to queue after visibility timeout):`,
+                        "",
+                        formatted,
+                    ].join("\n"),
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: aws_sqs_receive_message");
+    // SQS: Purge Queue
+    server.tool("aws_sqs_purge_queue", "Delete all messages from an SQS queue. Use with caution - this is irreversible.", {
+        queueUrl: z.string().describe("SQS queue URL"),
+        profile: z.string().optional().describe("AWS profile to use"),
+        region: z.string().optional().describe("AWS region"),
+    }, async ({ queueUrl, profile, region }) => {
+        log.info("Tool called: aws_sqs_purge_queue");
+        const result = await purgeSQSQueue({
+            queueUrl,
+            profile,
+            region,
+        }, log);
+        if (!result.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${result.error}`,
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Queue purged successfully. All messages have been deleted.`,
+                },
+            ],
+        };
+    });
+    log.info("Registered tool: aws_sqs_purge_queue");
     log.info("MCP server configuration complete");
     return server;
 }