@jaypie/mcp 0.3.2 → 0.3.4

package/dist/aws-B3dW_-bD.js

@@ -0,0 +1,1202 @@
+import * as https from 'node:https';
+import { Llm } from '@jaypie/llm';
+import { spawn } from 'node:child_process';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+/**
+ * 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];
+    log.info(`Making debug LLM call to ${provider} with model ${model}`);
+    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) {
+        log.error(`Error calling ${provider}:`, 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));
+    }
+    if (options.limit) {
+        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);
+    }
+    if (options.limit) {
+        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];
+    if (options.maxNumberOfMessages) {
+        args.push("--max-number-of-messages", String(options.maxNumberOfMessages));
+    }
+    if (options.visibilityTimeout) {
+        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);
+}
+
+export { aggregateDatadogLogs as a, getDatadogSyntheticResults as b, listDatadogSynthetics as c, searchDatadogRum as d, debugLlmCall as e, listLlmProviders as f, getDatadogCredentials as g, listAwsProfiles as h, listStepFunctionExecutions as i, stopStepFunctionExecution as j, listLambdaFunctions as k, listDatadogMonitors as l, getLambdaFunction as m, filterLogEvents as n, listS3Objects as o, describeStack as p, queryDatadogMetrics as q, describeDynamoDBTable as r, searchDatadogLogs as s, scanDynamoDB as t, queryDynamoDB as u, getDynamoDBItem as v, listSQSQueues as w, getSQSQueueAttributes as x, receiveSQSMessage as y, purgeSQSQueue as z };
+//# sourceMappingURL=aws-B3dW_-bD.js.map