@jaypie/mcp 0.3.4 → 0.4.0

package/dist/suite.js

@@ -4,15 +4,1205 @@ import * as path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import matter from 'gray-matter';
 import { gt } from 'semver';
-import { g as getDatadogCredentials, s as searchDatadogLogs, a as aggregateDatadogLogs, l as listDatadogMonitors, b as getDatadogSyntheticResults, c as listDatadogSynthetics, q as queryDatadogMetrics, d as searchDatadogRum, e as debugLlmCall, f as listLlmProviders, h as listAwsProfiles, i as listStepFunctionExecutions, j as stopStepFunctionExecution, k as listLambdaFunctions, m as getLambdaFunction, n as filterLogEvents, o as listS3Objects, p as describeStack, r as describeDynamoDBTable, t as scanDynamoDB, u as queryDynamoDB, v as getDynamoDBItem, w as listSQSQueues, x as getSQSQueueAttributes, y as receiveSQSMessage, z as purgeSQSQueue } from './aws-B3dW_-bD.js';
-import 'node:https';
-import '@jaypie/llm';
-import 'node:child_process';
-import 'node:os';
+import * as https from 'node:https';
+import { Llm } from '@jaypie/llm';
+import { spawn } from 'node:child_process';
+import * as os from 'node:os';
+
+/**
+ * Datadog API integration module
+ */
+const nullLogger$1 = {
+    info: () => { },
+    error: () => { },
+};
+/**
+ * Get Datadog credentials from environment variables
+ */
+function getDatadogCredentials() {
+    const apiKey = process.env.DATADOG_API_KEY || process.env.DD_API_KEY;
+    const appKey = process.env.DATADOG_APP_KEY ||
+        process.env.DATADOG_APPLICATION_KEY ||
+        process.env.DD_APP_KEY ||
+        process.env.DD_APPLICATION_KEY;
+    if (!apiKey || !appKey) {
+        return null;
+    }
+    return { apiKey, appKey };
+}
+/**
+ * Build query string from environment variables and options
+ */
+function buildDatadogQuery(options) {
+    const ddEnv = process.env.DD_ENV;
+    const ddService = process.env.DD_SERVICE;
+    const ddSource = process.env.DD_SOURCE;
+    const ddQuery = process.env.DD_QUERY;
+    const queryParts = [];
+    // Add source (parameter > env var > default 'lambda')
+    const effectiveSource = options.source || ddSource || "lambda";
+    queryParts.push(`source:${effectiveSource}`);
+    // Add env (parameter > env var)
+    const effectiveEnv = options.env || ddEnv;
+    if (effectiveEnv) {
+        queryParts.push(`env:${effectiveEnv}`);
+    }
+    // Add service (parameter > env var)
+    const effectiveService = options.service || ddService;
+    if (effectiveService) {
+        queryParts.push(`service:${effectiveService}`);
+    }
+    // Add base query from DD_QUERY if available
+    if (ddQuery) {
+        queryParts.push(ddQuery);
+    }
+    // Add user-provided query terms
+    if (options.query) {
+        queryParts.push(options.query);
+    }
+    return queryParts.join(" ");
+}
+/**
+ * Search Datadog logs
+ */
+async function searchDatadogLogs(credentials, options = {}, logger = nullLogger$1) {
+    const effectiveQuery = buildDatadogQuery(options);
+    const effectiveFrom = options.from || "now-15m";
+    const effectiveTo = options.to || "now";
+    const effectiveLimit = Math.min(options.limit || 50, 1000);
+    const effectiveSort = options.sort || "-timestamp";
+    logger.info(`Effective query: ${effectiveQuery}`);
+    logger.info(`Search params: from=${effectiveFrom}, to=${effectiveTo}, limit=${effectiveLimit}, sort=${effectiveSort}`);
+    const requestBody = JSON.stringify({
+        filter: {
+            query: effectiveQuery,
+            from: effectiveFrom,
+            to: effectiveTo,
+        },
+        page: {
+            limit: effectiveLimit,
+        },
+        sort: effectiveSort,
+    });
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: "/api/v2/logs/events/search",
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+                "Content-Length": Buffer.byteLength(requestBody),
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    if (res.statusCode === 400) {
+                        errorMessage = `Invalid query syntax. Check your query: "${effectiveQuery}". Datadog error: ${data}`;
+                    }
+                    else if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have logs_read permission.";
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again, or reduce your query scope.";
+                    }
+                    resolve({
+                        success: false,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        logs: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    const logs = (response.data || []).map((log) => {
+                        const attrs = log.attributes || {};
+                        return {
+                            id: log.id,
+                            timestamp: attrs.timestamp,
+                            status: attrs.status,
+                            service: attrs.service,
+                            message: attrs.message,
+                            attributes: attrs.attributes,
+                        };
+                    });
+                    logger.info(`Retrieved ${logs.length} log entries`);
+                    resolve({
+                        success: true,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        logs,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog response:", parseError);
+                    resolve({
+                        success: false,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        logs: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                query: effectiveQuery,
+                timeRange: { from: effectiveFrom, to: effectiveTo },
+                logs: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.write(requestBody);
+        req.end();
+    });
+}
+/**
+ * Aggregate Datadog logs using the Analytics API
+ * Groups logs by specified fields and computes aggregations
+ */
+async function aggregateDatadogLogs(credentials, options, logger = nullLogger$1) {
+    const effectiveQuery = buildDatadogQuery(options);
+    const effectiveFrom = options.from || "now-15m";
+    const effectiveTo = options.to || "now";
+    const groupBy = options.groupBy;
+    const compute = options.compute || [{ aggregation: "count" }];
+    logger.info(`Analytics query: ${effectiveQuery}`);
+    logger.info(`Group by: ${groupBy.join(", ")}`);
+    logger.info(`Time range: ${effectiveFrom} to ${effectiveTo}`);
+    // Build compute array - each item needs aggregation and type
+    const computeItems = compute.map((c) => {
+        const item = {
+            aggregation: c.aggregation,
+            type: "total",
+        };
+        if (c.metric) {
+            item.metric = c.metric;
+        }
+        return item;
+    });
+    // Build group_by with proper sort configuration
+    const groupByItems = groupBy.map((field) => {
+        const item = {
+            facet: field,
+            limit: 100,
+            sort: {
+                type: "measure",
+                order: "desc",
+                aggregation: compute[0]?.aggregation || "count",
+            },
+        };
+        return item;
+    });
+    const requestBody = JSON.stringify({
+        filter: {
+            query: effectiveQuery,
+            from: effectiveFrom,
+            to: effectiveTo,
+        },
+        group_by: groupByItems,
+        compute: computeItems,
+        page: {
+            limit: 100,
+        },
+    });
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: "/api/v2/logs/analytics/aggregate",
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+                "Content-Length": Buffer.byteLength(requestBody),
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog Analytics API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    if (res.statusCode === 400) {
+                        errorMessage = `Invalid query or groupBy fields. Verify facet names exist: ${groupBy.join(", ")}. Datadog error: ${data}`;
+                    }
+                    else if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have logs_read permission.";
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again, or reduce your query scope.";
+                    }
+                    resolve({
+                        success: false,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        groupBy,
+                        buckets: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    const buckets = (response.data?.buckets || []).map((bucket) => ({
+                        by: bucket.by || {},
+                        computes: bucket.computes || {},
+                    }));
+                    logger.info(`Retrieved ${buckets.length} aggregation buckets`);
+                    resolve({
+                        success: true,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        groupBy,
+                        buckets,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog analytics response:", parseError);
+                    resolve({
+                        success: false,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        groupBy,
+                        buckets: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                query: effectiveQuery,
+                timeRange: { from: effectiveFrom, to: effectiveTo },
+                groupBy,
+                buckets: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.write(requestBody);
+        req.end();
+    });
+}
+/**
+ * List Datadog monitors with optional filtering
+ */
+async function listDatadogMonitors(credentials, options = {}, logger = nullLogger$1) {
+    logger.info("Fetching Datadog monitors");
+    const queryParams = new URLSearchParams();
+    if (options.tags && options.tags.length > 0) {
+        queryParams.set("tags", options.tags.join(","));
+    }
+    if (options.monitorTags && options.monitorTags.length > 0) {
+        queryParams.set("monitor_tags", options.monitorTags.join(","));
+    }
+    if (options.name) {
+        queryParams.set("name", options.name);
+    }
+    const queryString = queryParams.toString();
+    const path = `/api/v1/monitor${queryString ? `?${queryString}` : ""}`;
+    logger.info(`Request path: ${path}`);
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path,
+            method: "GET",
+            headers: {
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog Monitors API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have monitors_read permission.";
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again.";
+                    }
+                    resolve({
+                        success: false,
+                        monitors: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    let monitors = response.map((monitor) => ({
+                        id: monitor.id,
+                        name: monitor.name,
+                        type: monitor.type,
+                        status: monitor.overall_state || "Unknown",
+                        message: monitor.message,
+                        tags: monitor.tags || [],
+                        priority: monitor.priority,
+                        query: monitor.query,
+                        overallState: monitor.overall_state,
+                    }));
+                    // Filter by status if specified
+                    if (options.status && options.status.length > 0) {
+                        monitors = monitors.filter((m) => options.status.includes(m.status));
+                    }
+                    logger.info(`Retrieved ${monitors.length} monitors`);
+                    resolve({
+                        success: true,
+                        monitors,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog monitors response:", parseError);
+                    resolve({
+                        success: false,
+                        monitors: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                monitors: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.end();
+    });
+}
+/**
+ * List Datadog Synthetic tests
+ */
+async function listDatadogSynthetics(credentials, options = {}, logger = nullLogger$1) {
+    logger.info("Fetching Datadog Synthetic tests");
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: "/api/v1/synthetics/tests",
+            method: "GET",
+            headers: {
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog Synthetics API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have synthetics_read permission.";
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again.";
+                    }
+                    resolve({
+                        success: false,
+                        tests: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    let tests = (response.tests || []).map((test) => ({
+                        publicId: test.public_id,
+                        name: test.name,
+                        type: test.type,
+                        status: test.status,
+                        tags: test.tags || [],
+                        locations: test.locations || [],
+                        message: test.message,
+                    }));
+                    // Filter by type if specified
+                    if (options.type) {
+                        tests = tests.filter((t) => t.type === options.type);
+                    }
+                    // Filter by tags if specified
+                    if (options.tags && options.tags.length > 0) {
+                        tests = tests.filter((t) => options.tags.some((tag) => t.tags.includes(tag)));
+                    }
+                    logger.info(`Retrieved ${tests.length} synthetic tests`);
+                    resolve({
+                        success: true,
+                        tests,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog synthetics response:", parseError);
+                    resolve({
+                        success: false,
+                        tests: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                tests: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.end();
+    });
+}
+/**
+ * Get recent results for a specific Synthetic test
+ */
+async function getDatadogSyntheticResults(credentials, publicId, logger = nullLogger$1) {
+    logger.info(`Fetching results for Synthetic test: ${publicId}`);
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: `/api/v1/synthetics/tests/${publicId}/results`,
+            method: "GET",
+            headers: {
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog Synthetics Results API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have synthetics_read permission.";
+                    }
+                    else if (res.statusCode === 404) {
+                        errorMessage = `Synthetic test '${publicId}' not found. Use datadog_synthetics (without testId) to list available tests.`;
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again.";
+                    }
+                    resolve({
+                        success: false,
+                        publicId,
+                        results: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    const results = (response.results || []).map((result) => ({
+                        publicId,
+                        resultId: result.result_id,
+                        status: result.status,
+                        checkTime: result.check_time,
+                        passed: result.result?.passed ?? result.status === 0,
+                        location: result.dc_id?.toString(),
+                    }));
+                    logger.info(`Retrieved ${results.length} synthetic results`);
+                    resolve({
+                        success: true,
+                        publicId,
+                        results,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog synthetic results:", parseError);
+                    resolve({
+                        success: false,
+                        publicId,
+                        results: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                publicId,
+                results: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.end();
+    });
+}
+/**
+ * Query Datadog metrics
+ */
+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({
+        query: options.query,
+        from: options.from.toString(),
+        to: options.to.toString(),
+    });
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: `/api/v1/query?${queryParams.toString()}`,
+            method: "GET",
+            headers: {
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog Metrics API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    if (res.statusCode === 400) {
+                        errorMessage = `Invalid metric query. Check format: 'aggregation:metric.name{tags}'. Query: "${options.query}". Datadog error: ${data}`;
+                    }
+                    else if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have metrics_read permission.";
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again, or reduce your time range.";
+                    }
+                    resolve({
+                        success: false,
+                        query: options.query,
+                        timeRange: { from: options.from, to: options.to },
+                        series: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    const series = (response.series || []).map((s) => ({
+                        metric: s.metric,
+                        scope: s.scope,
+                        pointlist: s.pointlist,
+                        unit: s.unit?.[0]?.name,
+                    }));
+                    logger.info(`Retrieved ${series.length} metric series`);
+                    resolve({
+                        success: true,
+                        query: options.query,
+                        timeRange: { from: options.from, to: options.to },
+                        series,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog metrics response:", parseError);
+                    resolve({
+                        success: false,
+                        query: options.query,
+                        timeRange: { from: options.from, to: options.to },
+                        series: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                query: options.query,
+                timeRange: { from: options.from, to: options.to },
+                series: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.end();
+    });
+}
+/**
+ * Search Datadog RUM events
+ */
+async function searchDatadogRum(credentials, options = {}, logger = nullLogger$1) {
+    const effectiveQuery = options.query || "*";
+    const effectiveFrom = options.from || "now-15m";
+    const effectiveTo = options.to || "now";
+    const effectiveLimit = Math.min(options.limit || 50, 1000);
+    const effectiveSort = options.sort || "-timestamp";
+    logger.info(`RUM query: ${effectiveQuery}`);
+    logger.info(`Time range: ${effectiveFrom} to ${effectiveTo}`);
+    const requestBody = JSON.stringify({
+        filter: {
+            query: effectiveQuery,
+            from: effectiveFrom,
+            to: effectiveTo,
+        },
+        page: {
+            limit: effectiveLimit,
+        },
+        sort: effectiveSort,
+    });
+    return new Promise((resolve) => {
+        const requestOptions = {
+            hostname: "api.datadoghq.com",
+            port: 443,
+            path: "/api/v2/rum/events/search",
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "DD-API-KEY": credentials.apiKey,
+                "DD-APPLICATION-KEY": credentials.appKey,
+                "Content-Length": Buffer.byteLength(requestBody),
+            },
+        };
+        const req = https.request(requestOptions, (res) => {
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk.toString();
+            });
+            res.on("end", () => {
+                logger.info(`Response status: ${res.statusCode}`);
+                if (res.statusCode !== 200) {
+                    logger.error(`Datadog RUM API error: ${res.statusCode}`);
+                    let errorMessage = `Datadog API returned status ${res.statusCode}: ${data}`;
+                    // Check for specific "No valid indexes" error which means no RUM app is configured
+                    if (data.includes("No valid indexes")) {
+                        errorMessage =
+                            "No RUM application found. Ensure you have a RUM application configured in Datadog and it has collected data. " +
+                                "You can create a RUM application at https://app.datadoghq.com/rum/list";
+                    }
+                    else if (res.statusCode === 400) {
+                        errorMessage = `Invalid RUM query. Check syntax: "${effectiveQuery}". Datadog error: ${data}`;
+                    }
+                    else if (res.statusCode === 403) {
+                        errorMessage =
+                            "Access denied. Verify your API and Application keys have rum_read permission.";
+                    }
+                    else if (res.statusCode === 429) {
+                        errorMessage =
+                            "Rate limited by Datadog. Wait a moment and try again, or reduce your query scope.";
+                    }
+                    resolve({
+                        success: false,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        events: [],
+                        error: errorMessage,
+                    });
+                    return;
+                }
+                try {
+                    const response = JSON.parse(data);
+                    const events = (response.data || []).map((event) => {
+                        const attrs = event.attributes?.attributes || {};
+                        return {
+                            id: event.id,
+                            type: event.type,
+                            timestamp: event.attributes?.timestamp,
+                            sessionId: attrs.session?.id,
+                            viewUrl: attrs.view?.url,
+                            viewName: attrs.view?.name,
+                            errorMessage: attrs.error?.message,
+                            errorType: attrs.error?.type,
+                            attributes: attrs,
+                        };
+                    });
+                    logger.info(`Retrieved ${events.length} RUM events`);
+                    resolve({
+                        success: true,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        events,
+                    });
+                }
+                catch (parseError) {
+                    logger.error("Failed to parse Datadog RUM response:", parseError);
+                    resolve({
+                        success: false,
+                        query: effectiveQuery,
+                        timeRange: { from: effectiveFrom, to: effectiveTo },
+                        events: [],
+                        error: `Failed to parse response: ${parseError instanceof Error ? parseError.message : "Unknown error"}`,
+                    });
+                }
+            });
+        });
+        req.on("error", (error) => {
+            logger.error("Request error:", error);
+            resolve({
+                success: false,
+                query: effectiveQuery,
+                timeRange: { from: effectiveFrom, to: effectiveTo },
+                events: [],
+                error: `Connection error: ${error.message}`,
+            });
+        });
+        req.write(requestBody);
+        req.end();
+    });
+}
+
+/**
+ * LLM debugging utilities for inspecting raw provider responses
+ */
+// Default models for each provider
+const DEFAULT_MODELS = {
+    anthropic: "claude-sonnet-4-20250514",
+    gemini: "gemini-2.0-flash",
+    openai: "gpt-4o-mini",
+    openrouter: "openai/gpt-4o-mini",
+};
+/**
+ * Make a debug LLM call and return the raw response data for inspection
+ */
+async function debugLlmCall(params, log) {
+    const { provider, message } = params;
+    const model = params.model || DEFAULT_MODELS[provider];
+    try {
+        const llm = new Llm(provider, { model });
+        const result = await llm.operate(message, {
+            user: "[jaypie-mcp] Debug LLM Call",
+        });
+        if (result.error) {
+            return {
+                success: false,
+                provider,
+                model,
+                error: `${result.error.title}: ${result.error.detail || "Unknown error"}`,
+            };
+        }
+        // Calculate total reasoning tokens
+        const reasoningTokens = result.usage.reduce((sum, u) => sum + (u.reasoning || 0), 0);
+        return {
+            success: true,
+            provider,
+            model,
+            content: typeof result.content === "string"
+                ? result.content
+                : JSON.stringify(result.content),
+            reasoning: result.reasoning,
+            reasoningTokens,
+            history: result.history,
+            rawResponses: result.responses,
+            usage: result.usage,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            provider,
+            model,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * List available providers and their default/reasoning models
+ */
+function listLlmProviders() {
+    return {
+        providers: [
+            {
+                name: "openai",
+                defaultModel: DEFAULT_MODELS.openai,
+                reasoningModels: ["o3-mini", "o1-preview", "o1-mini"],
+            },
+            {
+                name: "anthropic",
+                defaultModel: DEFAULT_MODELS.anthropic,
+                reasoningModels: [], // Anthropic doesn't expose reasoning the same way
+            },
+            {
+                name: "gemini",
+                defaultModel: DEFAULT_MODELS.gemini,
+                reasoningModels: [], // Gemini has thoughtsTokenCount but unclear on content
+            },
+            {
+                name: "openrouter",
+                defaultModel: DEFAULT_MODELS.openrouter,
+                reasoningModels: ["openai/o3-mini", "openai/o1-preview"],
+            },
+        ],
+    };
+}
+
+/**
+ * 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);
+}
 
 // ServiceSuite for @jaypie/mcp
 // Provides metadata and direct execution for Jaypie MCP services
-const BUILD_VERSION_STRING = "@jaypie/mcp@0.3.4#a6510094"
+const BUILD_VERSION_STRING = "@jaypie/mcp@0.4.0#988a2bd8"
     ;
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = path.dirname(__filename$1);
@@ -631,7 +1821,7 @@ const llmDebugCall = fabricService({
             provider: input.provider,
             model: input.model,
             message: input.message,
-        }, log);
+        });
         if (!result.success) {
             throw new Error(result.error);
         }