triagent 0.1.0-alpha13 → 0.1.0-alpha18

package/src/mastra/tools/network.ts

@@ -0,0 +1,253 @@
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+const execAsync = promisify(exec);
+
+export const networkTool = createTool({
+  id: "network",
+  description: `Debug network connectivity and policies in Kubernetes.
+Use this tool to:
+- Test DNS resolution from within pods
+- Check connectivity between services
+- Analyze NetworkPolicies
+- View service endpoints
+- Trace network paths
+
+This tool executes kubectl commands to inspect network-related resources
+and can run network diagnostics inside pods using kubectl exec.`,
+  inputSchema: z.object({
+    operation: z.enum(["dns", "connectivity", "policies", "endpoints", "trace"]).describe(
+      "Operation: dns (resolve names), connectivity (test connection), policies (list NetworkPolicies), endpoints (show service endpoints), trace (network path)"
+    ),
+    source: z.object({
+      pod: z.string().optional().describe("Source pod name for tests"),
+      namespace: z.string().optional().describe("Source namespace"),
+    }).optional().describe("Source for network tests"),
+    target: z.object({
+      host: z.string().optional().describe("Target hostname or IP"),
+      port: z.number().optional().describe("Target port"),
+      service: z.string().optional().describe("Target service name"),
+      namespace: z.string().optional().describe("Target namespace"),
+    }).optional().describe("Target for network tests"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    data: z.string(),
+    error: z.string().optional(),
+  }),
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  execute: (async ({ operation, source, target }: any) => {
+
+    try {
+      switch (operation) {
+        case "dns": {
+          const hostname = target?.host || target?.service;
+          if (!hostname) {
+            return {
+              success: false,
+              data: "",
+              error: "Target host or service is required for DNS lookup",
+            };
+          }
+
+          // Try to resolve DNS from within a pod if specified
+          if (source?.pod && source?.namespace) {
+            const cmd = `kubectl exec -n ${source.namespace} ${source.pod} -- nslookup ${hostname} 2>&1 || kubectl exec -n ${source.namespace} ${source.pod} -- getent hosts ${hostname} 2>&1`;
+            const { stdout, stderr } = await execAsync(cmd, { timeout: 30000 });
+            return {
+              success: true,
+              data: `DNS lookup for ${hostname} from ${source.namespace}/${source.pod}:\n${stdout}${stderr ? `\nErrors: ${stderr}` : ""}`,
+            };
+          }
+
+          // Fallback to coredns query
+          const { stdout } = await execAsync(
+            `kubectl get svc -A -o json | grep -i "${hostname}" || echo "Service not found in cluster"`,
+            { timeout: 30000 }
+          );
+          return {
+            success: true,
+            data: `DNS/Service lookup for ${hostname}:\n${stdout}`,
+          };
+        }
+
+        case "connectivity": {
+          if (!source?.pod || !source?.namespace) {
+            return {
+              success: false,
+              data: "",
+              error: "Source pod and namespace are required for connectivity test",
+            };
+          }
+
+          const targetHost = target?.host || target?.service;
+          const targetPort = target?.port || 80;
+
+          if (!targetHost) {
+            return {
+              success: false,
+              data: "",
+              error: "Target host or service is required",
+            };
+          }
+
+          // Build full service name if namespace provided
+          const fullTarget = target?.namespace && target?.service
+            ? `${target.service}.${target.namespace}.svc.cluster.local`
+            : targetHost;
+
+          // Try different connectivity tools
+          const tests = [
+            `kubectl exec -n ${source.namespace} ${source.pod} -- nc -zv ${fullTarget} ${targetPort} 2>&1`,
+            `kubectl exec -n ${source.namespace} ${source.pod} -- wget -q --spider --timeout=5 http://${fullTarget}:${targetPort} 2>&1`,
+            `kubectl exec -n ${source.namespace} ${source.pod} -- curl -s -o /dev/null -w "%{http_code}" --connect-timeout 5 http://${fullTarget}:${targetPort} 2>&1`,
+          ];
+
+          const results: string[] = [`Connectivity test from ${source.namespace}/${source.pod} to ${fullTarget}:${targetPort}\n`];
+
+          for (const test of tests) {
+            try {
+              const { stdout, stderr } = await execAsync(test, { timeout: 15000 });
+              if (stdout.trim() || stderr.trim()) {
+                results.push(`✓ ${stdout.trim()}${stderr ? ` ${stderr.trim()}` : ""}`);
+                break;
+              }
+            } catch (e) {
+              results.push(`✗ Connection failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+          }
+
+          return {
+            success: true,
+            data: results.join("\n"),
+          };
+        }
+
+        case "policies": {
+          const namespace = source?.namespace || target?.namespace;
+          const nsArg = namespace ? `-n ${namespace}` : "-A";
+
+          const { stdout: policies } = await execAsync(
+            `kubectl get networkpolicy ${nsArg} -o wide 2>&1`,
+            { timeout: 30000 }
+          );
+
+          let details = "";
+          if (namespace) {
+            try {
+              const { stdout } = await execAsync(
+                `kubectl get networkpolicy ${nsArg} -o yaml 2>&1`,
+                { timeout: 30000 }
+              );
+              // Extract just the important parts
+              const policyNames = stdout.match(/name:\s+(\S+)/g) || [];
+              const podSelectors = stdout.match(/podSelector:[\s\S]*?(?=ingress:|egress:|spec:|---)/g) || [];
+              details = `\nPolicy details:\n${policyNames.join("\n")}`;
+            } catch {
+              // Ignore details errors
+            }
+          }
+
+          return {
+            success: true,
+            data: `NetworkPolicies${namespace ? ` in ${namespace}` : " (all namespaces)"}:\n${policies}${details}`,
+          };
+        }
+
+        case "endpoints": {
+          const service = target?.service;
+          const namespace = target?.namespace || "default";
+
+          if (!service) {
+            // List all endpoints
+            const { stdout } = await execAsync(
+              `kubectl get endpoints -A -o wide 2>&1`,
+              { timeout: 30000 }
+            );
+            return {
+              success: true,
+              data: `All endpoints:\n${stdout}`,
+            };
+          }
+
+          const { stdout: endpoints } = await execAsync(
+            `kubectl get endpoints ${service} -n ${namespace} -o yaml 2>&1`,
+            { timeout: 30000 }
+          );
+
+          const { stdout: svc } = await execAsync(
+            `kubectl get svc ${service} -n ${namespace} -o wide 2>&1`,
+            { timeout: 30000 }
+          );
+
+          return {
+            success: true,
+            data: `Service: ${service} in ${namespace}\n\n${svc}\n\nEndpoints:\n${endpoints}`,
+          };
+        }
+
+        case "trace": {
+          const targetHost = target?.host || target?.service;
+          if (!targetHost) {
+            return {
+              success: false,
+              data: "",
+              error: "Target host or service is required for trace",
+            };
+          }
+
+          const results: string[] = [`Network trace to ${targetHost}:\n`];
+
+          // Get service details if it's a service name
+          if (target?.service) {
+            const ns = target.namespace || "default";
+            try {
+              const { stdout: svc } = await execAsync(
+                `kubectl get svc ${target.service} -n ${ns} -o jsonpath='{.spec.clusterIP}:{.spec.ports[0].port}' 2>&1`,
+                { timeout: 10000 }
+              );
+              results.push(`Service ClusterIP: ${svc}`);
+
+              const { stdout: endpoints } = await execAsync(
+                `kubectl get endpoints ${target.service} -n ${ns} -o jsonpath='{.subsets[*].addresses[*].ip}' 2>&1`,
+                { timeout: 10000 }
+              );
+              results.push(`Backend pods: ${endpoints || "None"}`);
+            } catch {
+              results.push("Could not get service details");
+            }
+          }
+
+          // If we have a source pod, trace from there
+          if (source?.pod && source?.namespace) {
+            try {
+              const { stdout } = await execAsync(
+                `kubectl exec -n ${source.namespace} ${source.pod} -- traceroute -n -m 10 ${targetHost} 2>&1 || kubectl exec -n ${source.namespace} ${source.pod} -- tracepath ${targetHost} 2>&1`,
+                { timeout: 60000 }
+              );
+              results.push(`\nTraceroute from ${source.namespace}/${source.pod}:\n${stdout}`);
+            } catch (e) {
+              results.push(`\nTraceroute not available: ${e instanceof Error ? e.message : String(e)}`);
+            }
+          }
+
+          return {
+            success: true,
+            data: results.join("\n"),
+          };
+        }
+
+        default:
+          return { success: false, data: "", error: `Unknown operation: ${operation}` };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        data: "",
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }) as any,
+});

package/src/mastra/tools/prometheus.ts

@@ -0,0 +1,221 @@
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+import { getPrometheusClient } from "../../integrations/prometheus/client.js";
+import { getGrafanaClient } from "../../integrations/grafana/client.js";
+
+export const prometheusTool = createTool({
+  id: "prometheus",
+  description: `Query Prometheus metrics and alerts. Use this tool to:
+- Query current metric values with PromQL
+- Query metric ranges over time
+- Get active alerts
+- Check scrape targets health
+
+Example queries:
+- CPU usage: container_cpu_usage_seconds_total{pod=~"myapp.*"}
+- Memory: container_memory_usage_bytes{namespace="production"}
+- Request rate: rate(http_requests_total[5m])
+- Error rate: sum(rate(http_requests_total{status=~"5.."}[5m])) / sum(rate(http_requests_total[5m]))`,
+  inputSchema: z.object({
+    operation: z.enum(["query", "query_range", "alerts", "targets", "dashboards"]).describe(
+      "Operation: query (instant), query_range (time series), alerts (active alerts), targets (scrape health), dashboards (Grafana dashboards)"
+    ),
+    query: z.string().optional().describe("PromQL query for query/query_range operations"),
+    start: z.string().optional().describe("Start time for query_range (ISO 8601 or relative like '1h')"),
+    end: z.string().optional().describe("End time for query_range (ISO 8601 or 'now')"),
+    step: z.string().optional().describe("Step interval for query_range (e.g., '1m', '5m')"),
+    dashboardSearch: z.string().optional().describe("Search term for Grafana dashboards"),
+  }),
+  outputSchema: z.object({
+    success: z.boolean(),
+    data: z.string(),
+    error: z.string().optional(),
+  }),
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  execute: (async ({ operation, query, start, end, step, dashboardSearch }: any) => {
+
+    try {
+      const prometheusClient = getPrometheusClient();
+      const grafanaClient = getGrafanaClient();
+
+      switch (operation) {
+        case "query": {
+          if (!prometheusClient) {
+            return {
+              success: false,
+              data: "",
+              error: "Prometheus not configured. Set prometheus.url in config.",
+            };
+          }
+          if (!query) {
+            return { success: false, data: "", error: "Query is required for 'query' operation" };
+          }
+          const result = await prometheusClient.query(query);
+          return {
+            success: result.status === "success",
+            data: prometheusClient.formatQueryResult(result),
+            error: result.error,
+          };
+        }
+
+        case "query_range": {
+          if (!prometheusClient) {
+            return {
+              success: false,
+              data: "",
+              error: "Prometheus not configured. Set prometheus.url in config.",
+            };
+          }
+          if (!query || !start || !end) {
+            return {
+              success: false,
+              data: "",
+              error: "Query, start, and end are required for 'query_range' operation",
+            };
+          }
+
+          // Convert relative times to ISO format
+          const startTime = parseRelativeTime(start);
+          const endTime = end === "now" ? new Date().toISOString() : parseRelativeTime(end);
+          const stepInterval = step || "1m";
+
+          const result = await prometheusClient.queryRange(query, startTime, endTime, stepInterval);
+          return {
+            success: result.status === "success",
+            data: prometheusClient.formatQueryResult(result),
+            error: result.error,
+          };
+        }
+
+        case "alerts": {
+          if (!prometheusClient) {
+            return {
+              success: false,
+              data: "",
+              error: "Prometheus not configured. Set prometheus.url in config.",
+            };
+          }
+          const alertsData = await prometheusClient.getAlerts();
+          const alerts = alertsData.alerts || [];
+
+          if (alerts.length === 0) {
+            return { success: true, data: "No active alerts" };
+          }
+
+          const lines: string[] = [`Active alerts (${alerts.length}):\n`];
+          for (const alert of alerts) {
+            const labels = Object.entries(alert.labels)
+              .map(([k, v]) => `${k}="${v}"`)
+              .join(", ");
+            lines.push(`[${alert.state.toUpperCase()}] {${labels}}`);
+            if (alert.annotations.summary) {
+              lines.push(`  Summary: ${alert.annotations.summary}`);
+            }
+            if (alert.annotations.description) {
+              lines.push(`  Description: ${alert.annotations.description}`);
+            }
+            lines.push("");
+          }
+
+          return { success: true, data: lines.join("\n") };
+        }
+
+        case "targets": {
+          if (!prometheusClient) {
+            return {
+              success: false,
+              data: "",
+              error: "Prometheus not configured. Set prometheus.url in config.",
+            };
+          }
+          const targetsData = await prometheusClient.getTargets();
+          const targets = targetsData.activeTargets || [];
+
+          const grouped = new Map<string, typeof targets>();
+          for (const target of targets) {
+            const pool = target.scrapePool;
+            if (!grouped.has(pool)) {
+              grouped.set(pool, []);
+            }
+            grouped.get(pool)!.push(target);
+          }
+
+          const lines: string[] = [`Scrape targets (${targets.length} total):\n`];
+          for (const [pool, poolTargets] of grouped) {
+            const upCount = poolTargets.filter((t) => t.health === "up").length;
+            lines.push(`${pool}: ${upCount}/${poolTargets.length} up`);
+            for (const target of poolTargets) {
+              const icon = target.health === "up" ? "✓" : "✗";
+              lines.push(`  ${icon} ${target.scrapeUrl}`);
+              if (target.lastError) {
+                lines.push(`    Error: ${target.lastError}`);
+              }
+            }
+            lines.push("");
+          }
+
+          return { success: true, data: lines.join("\n") };
+        }
+
+        case "dashboards": {
+          if (!grafanaClient) {
+            return {
+              success: false,
+              data: "",
+              error: "Grafana not configured. Set grafana.url and grafana.apiKey in config.",
+            };
+          }
+          const dashboards = await grafanaClient.searchDashboards(dashboardSearch);
+
+          if (dashboards.length === 0) {
+            return { success: true, data: "No dashboards found" };
+          }
+
+          const lines: string[] = [`Found ${dashboards.length} dashboards:\n`];
+          for (const dash of dashboards) {
+            const tags = dash.tags.length > 0 ? ` [${dash.tags.join(", ")}]` : "";
+            const folder = dash.folderTitle ? ` (${dash.folderTitle})` : "";
+            lines.push(`- ${dash.title}${folder}${tags}`);
+            lines.push(`  URL: ${grafanaClient.getDashboardUrl(dash.uid)}`);
+          }
+
+          return { success: true, data: lines.join("\n") };
+        }
+
+        default:
+          return { success: false, data: "", error: `Unknown operation: ${operation}` };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        data: "",
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }) as any,
+});
+
+function parseRelativeTime(timeStr: string): string {
+  // If it's already ISO format, return as-is
+  if (timeStr.includes("T") || timeStr.includes("-")) {
+    return timeStr;
+  }
+
+  // Parse relative time like "1h", "30m", "2d"
+  const match = timeStr.match(/^(\d+)([smhdw])$/);
+  if (!match) {
+    return timeStr;
+  }
+
+  const [, amount, unit] = match;
+  const now = new Date();
+  const ms = parseInt(amount, 10) * {
+    s: 1000,
+    m: 60 * 1000,
+    h: 60 * 60 * 1000,
+    d: 24 * 60 * 60 * 1000,
+    w: 7 * 24 * 60 * 60 * 1000,
+  }[unit as "s" | "m" | "h" | "d" | "w"]!;
+
+  return new Date(now.getTime() - ms).toISOString();
+}