@supernova123/docker-mcp-server 0.1.5 → 0.2.0

package/src/tools/monitoring.ts

@@ -0,0 +1,369 @@
+import Dockerode from "dockerode";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import {
+  FleetStatusSchema,
+  FleetStatsSchema,
+  WatchEventsSchema,
+  SearchLogsSchema,
+  CheckThresholdsSchema,
+  MonitorDashboardSchema,
+} from "../types.js";
+
+export function registerMonitoringTools(server: McpServer, docker: Dockerode): void {
+  // 1. fleet_status — health status of all running containers
+  server.tool(
+    "fleet_status",
+    "Get health status of all running containers. Returns name, state, health, uptime, and restart count for each.",
+    FleetStatusSchema.shape,
+    async (params) => {
+      try {
+        const containers = await docker.listContainers({ all: false });
+        const results = await Promise.all(
+          containers.map(async (c) => {
+            const info = await docker.getContainer(c.Id).inspect();
+            return {
+              name: c.Names[0]?.replace(/^\//, "") || c.Id.slice(0, 12),
+              id: c.Id.slice(0, 12),
+              state: c.State,
+              status: c.Status,
+              health: info.State.Health?.Status || "no-healthcheck",
+              uptime: info.State.StartedAt,
+              restartCount: info.RestartCount,
+              image: c.Image,
+            };
+          })
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+        };
+      } catch (err: any) {
+        return {
+          content: [{ type: "text", text: `Error: ${err.message}` }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // 2. fleet_stats — resource usage for all running containers
+  server.tool(
+    "fleet_stats",
+    "Get resource usage (CPU%, memory%, network I/O) for all running containers. Sorted by usage.",
+    FleetStatsSchema.shape,
+    async (params) => {
+      try {
+        const containers = await docker.listContainers({ all: false });
+        const results = await Promise.all(
+          containers.map(async (c) => {
+            const stats = await docker.getContainer(c.Id).stats({ stream: false });
+            const cpuDelta = stats.cpu_stats.cpu_usage.total_usage - (stats.precpu_stats?.cpu_usage?.total_usage ?? 0);
+            const systemDelta = stats.cpu_stats.system_cpu_usage - (stats.precpu_stats?.system_cpu_usage ?? 0);
+            const cpuCount = stats.cpu_stats.online_cpus ?? 1;
+            const cpuPercent = systemDelta > 0 ? (cpuDelta / systemDelta) * cpuCount * 100 : 0;
+            const memUsage = stats.memory_stats?.usage ?? 0;
+            const memLimit = stats.memory_stats?.limit ?? 1;
+            const memPercent = (memUsage / memLimit) * 100;
+            const netRx = Object.values(stats.networks ?? {}).reduce((sum: number, n: any) => sum + (n.rx_bytes ?? 0), 0);
+            const netTx = Object.values(stats.networks ?? {}).reduce((sum: number, n: any) => sum + (n.tx_bytes ?? 0), 0);
+
+            return {
+              name: c.Names[0]?.replace(/^\//, "") || c.Id.slice(0, 12),
+              id: c.Id.slice(0, 12),
+              cpu_percent: Math.round(cpuPercent * 100) / 100,
+              memory_usage_mb: Math.round((memUsage / 1024 / 1024) * 100) / 100,
+              memory_percent: Math.round(memPercent * 100) / 100,
+              network_rx_mb: Math.round((netRx / 1024 / 1024) * 100) / 100,
+              network_tx_mb: Math.round((netTx / 1024 / 1024) * 100) / 100,
+            };
+          })
+        );
+
+        const sortBy = params.sort_by || "cpu";
+        results.sort((a: any, b: any) => {
+          if (sortBy === "cpu") return b.cpu_percent - a.cpu_percent;
+          if (sortBy === "memory") return b.memory_percent - a.memory_percent;
+          return (b.network_rx_mb + b.network_tx_mb) - (a.network_rx_mb + a.network_tx_mb);
+        });
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+        };
+      } catch (err: any) {
+        return {
+          content: [{ type: "text", text: `Error: ${err.message}` }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // 3. watch_events — stream Docker events (simplified: collect events for a duration)
+  server.tool(
+    "watch_events",
+    "Collect Docker events (start, stop, die, restart, health_status) over a time window. Filter by container or event type.",
+    WatchEventsSchema.shape,
+    async (params) => {
+      try {
+        const durationMs = (params.duration || 30) * 1000;
+        const filter: any = {};
+        if (params.container) filter.container = [params.container];
+        if (params.event_type && params.event_type !== "all") filter.event = [params.event_type];
+        if (params.since) filter.since = [params.since];
+
+        const events: any[] = [];
+        const stream = await docker.getEvents(filter as Dockerode.GetEventsOptions) as unknown as NodeJS.ReadableStream;
+
+        await new Promise<void>((resolve) => {
+          const timeout = setTimeout(() => {
+            resolve();
+          }, durationMs);
+
+          stream.on("data", (chunk: Buffer) => {
+            try {
+              const event = JSON.parse(chunk.toString());
+              events.push({
+                type: event.Type,
+                action: event.Action,
+                container: event.Actor?.Attributes?.name || event.Actor?.ID?.slice(0, 12),
+                time: new Date(event.time * 1000).toISOString(),
+              });
+            } catch {}
+          });
+
+          stream.on("error", () => {
+            clearTimeout(timeout);
+            resolve();
+          });
+
+          stream.on("end", () => {
+            clearTimeout(timeout);
+            resolve();
+          });
+        });
+
+        return {
+          content: [{ type: "text", text: events.length ? JSON.stringify(events, null, 2) : "No events captured in the time window." }],
+        };
+      } catch (err: any) {
+        return {
+          content: [{ type: "text", text: `Error: ${err.message}` }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // 4. search_logs — search logs across multiple containers
+  server.tool(
+    "search_logs",
+    "Search logs across multiple containers with regex/grep pattern. Returns matching lines with container name and timestamp.",
+    SearchLogsSchema.shape,
+    async (params) => {
+      try {
+        const targetContainers = params.containers || [];
+        let containers: { id: string; name: string }[];
+
+        if (targetContainers.length > 0) {
+          containers = await Promise.all(
+            targetContainers.map(async (id) => {
+              const info = await docker.getContainer(id).inspect();
+              return { id, name: info.Name.replace(/^\//, "") };
+            })
+          );
+        } else {
+          const list = await docker.listContainers({ all: false });
+          containers = list.map((c) => ({ id: c.Id, name: c.Names[0]?.replace(/^\//, "") || c.Id.slice(0, 12) }));
+        }
+
+        const regex = new RegExp(params.pattern, params.ignore_case ? "i" : "");
+        const matches: any[] = [];
+
+        for (const container of containers) {
+          try {
+            const logStream = await docker.getContainer(container.id).logs({
+              stdout: true,
+              stderr: true,
+              tail: params.tail || 500,
+              since: params.since ? Math.floor(new Date(params.since).getTime() / 1000) : undefined,
+            });
+            const output = logStream.toString("utf-8").replace(/^[\x00-\x0f]{8}/gm, "");
+            const lines = output.split("\n");
+            for (const line of lines) {
+              if (regex.test(line)) {
+                matches.push({ container: container.name, line: line.trim() });
+              }
+            }
+          } catch {}
+        }
+
+        return {
+          content: [{ type: "text", text: matches.length ? JSON.stringify(matches, null, 2) : "No matches found." }],
+        };
+      } catch (err: any) {
+        return {
+          content: [{ type: "text", text: `Error: ${err.message}` }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // 5. check_thresholds — check all containers against thresholds
+  server.tool(
+    "check_thresholds",
+    "Check all containers against defined thresholds (CPU > X%, memory > Y%, restarts > Z). Returns violations.",
+    CheckThresholdsSchema.shape,
+    async (params) => {
+      try {
+        const cpuThreshold = params.cpu_percent ?? 80;
+        const memThreshold = params.memory_percent ?? 80;
+        const restartThreshold = params.restart_count ?? 5;
+        const containers = await docker.listContainers({ all: false });
+        const violations: any[] = [];
+
+        for (const c of containers) {
+          const info = await docker.getContainer(c.Id).inspect();
+          const issues: string[] = [];
+
+          // Check restart count
+          if (info.RestartCount > restartThreshold) {
+            issues.push(`restarts: ${info.RestartCount} > ${restartThreshold}`);
+          }
+
+          // Check CPU and memory
+          try {
+            const stats = await docker.getContainer(c.Id).stats({ stream: false });
+            const cpuDelta = stats.cpu_stats.cpu_usage.total_usage - (stats.precpu_stats?.cpu_usage?.total_usage ?? 0);
+            const systemDelta = stats.cpu_stats.system_cpu_usage - (stats.precpu_stats?.system_cpu_usage ?? 0);
+            const cpuCount = stats.cpu_stats.online_cpus ?? 1;
+            const cpuPercent = systemDelta > 0 ? (cpuDelta / systemDelta) * cpuCount * 100 : 0;
+            const memUsage = stats.memory_stats?.usage ?? 0;
+            const memLimit = stats.memory_stats?.limit ?? 1;
+            const memPercent = (memUsage / memLimit) * 100;
+
+            if (cpuPercent > cpuThreshold) issues.push(`cpu: ${Math.round(cpuPercent)}% > ${cpuThreshold}%`);
+            if (memPercent > memThreshold) issues.push(`memory: ${Math.round(memPercent)}% > ${memThreshold}%`);
+          } catch {}
+
+          if (issues.length > 0) {
+            violations.push({
+              container: c.Names[0]?.replace(/^\//, "") || c.Id.slice(0, 12),
+              id: c.Id.slice(0, 12),
+              issues,
+            });
+          }
+        }
+
+        return {
+          content: [{
+            type: "text",
+            text: violations.length
+              ? JSON.stringify({ violations, checked: containers.length }, null, 2)
+              : JSON.stringify({ message: "All containers within thresholds.", checked: containers.length }),
+          }],
+        };
+      } catch (err: any) {
+        return {
+          content: [{ type: "text", text: `Error: ${err.message}` }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // 6. monitor_dashboard — single-call fleet summary
+  server.tool(
+    "monitor_dashboard",
+    "Single-call fleet summary: health status, top resource consumers, recent events, threshold violations. Designed for agent quick-assessment.",
+    MonitorDashboardSchema.shape,
+    async (params) => {
+      try {
+        const containers = await docker.listContainers({ all: false });
+
+        // Fleet health
+        const health = await Promise.all(
+          containers.map(async (c) => {
+            const info = await docker.getContainer(c.Id).inspect();
+            return {
+              name: c.Names[0]?.replace(/^\//, "") || c.Id.slice(0, 12),
+              state: c.State,
+              health: info.State.Health?.Status || "no-healthcheck",
+              restartCount: info.RestartCount,
+            };
+          })
+        );
+
+        // Resource usage (top 5 by CPU)
+        const stats = await Promise.all(
+          containers.map(async (c) => {
+            try {
+              const s = await docker.getContainer(c.Id).stats({ stream: false });
+              const cpuDelta = s.cpu_stats.cpu_usage.total_usage - (s.precpu_stats?.cpu_usage?.total_usage ?? 0);
+              const systemDelta = s.cpu_stats.system_cpu_usage - (s.precpu_stats?.system_cpu_usage ?? 0);
+              const cpuCount = s.cpu_stats.online_cpus ?? 1;
+              const cpuPercent = systemDelta > 0 ? (cpuDelta / systemDelta) * cpuCount * 100 : 0;
+              const memUsage = s.memory_stats?.usage ?? 0;
+              const memLimit = s.memory_stats?.limit ?? 1;
+              const memPercent = (memUsage / memLimit) * 100;
+              return {
+                name: c.Names[0]?.replace(/^\//, "") || c.Id.slice(0, 12),
+                cpu_percent: Math.round(cpuPercent * 100) / 100,
+                memory_percent: Math.round(memPercent * 100) / 100,
+              };
+            } catch {
+              return null;
+            }
+          })
+        );
+
+        const topConsumers = stats.filter(Boolean).sort((a: any, b: any) => b.cpu_percent - a.cpu_percent).slice(0, 5);
+
+        // Recent events (last 5 minutes) - use simple approach
+        const recentEvents: any[] = [];
+        try {
+          const sinceTs = Math.floor((Date.now() - 5 * 60 * 1000) / 1000);
+          const eventStream = await docker.getEvents({ since: sinceTs }) as unknown as NodeJS.ReadableStream;
+          await new Promise<void>((resolve) => {
+            const timeout = setTimeout(() => { resolve(); }, 2000);
+            eventStream.on("data", (chunk: Buffer) => {
+              try {
+                const e = JSON.parse(chunk.toString());
+                recentEvents.push({
+                  action: e.Action,
+                  container: e.Actor?.Attributes?.name || e.Actor?.ID?.slice(0, 12),
+                  time: new Date(e.time * 1000).toISOString(),
+                });
+              } catch {}
+            });
+            eventStream.on("error", () => { clearTimeout(timeout); resolve(); });
+            eventStream.on("end", () => { clearTimeout(timeout); resolve(); });
+          });
+        } catch {}
+
+        // Threshold violations
+        const violations = stats.filter(Boolean).filter((s: any) => s.cpu_percent > 80 || s.memory_percent > 80);
+
+        const dashboard = {
+          summary: {
+            total_containers: containers.length,
+            running: containers.filter((c) => c.State === "running").length,
+            unhealthy: health.filter((h) => h.health === "unhealthy").length,
+          },
+          health,
+          top_cpu_consumers: topConsumers,
+          recent_events: recentEvents.slice(0, 10),
+          threshold_violations: violations,
+        };
+
+        return {
+          content: [{ type: "text", text: JSON.stringify(dashboard, null, 2) }],
+        };
+      } catch (err: any) {
+        return {
+          content: [{ type: "text", text: `Error: ${err.message}` }],
+          isError: true,
+        };
+      }
+    }
+  );
+}

package/src/types.ts

@@ -150,3 +150,34 @@ export const ListNetworksSchema = z.object({
 export const ListVolumesSchema = z.object({
   filter: z.string().optional().describe("Filter by name or driver"),
 });
+
+
+// Monitoring schemas (v0.2.0)
+export const FleetStatusSchema = z.object({});
+
+export const FleetStatsSchema = z.object({
+  sort_by: z.enum(["cpu", "memory", "network"]).optional().describe("Sort results by metric (default: cpu)"),
+});
+
+export const WatchEventsSchema = z.object({
+  container: z.string().optional().describe("Filter by container name or ID"),
+  event_type: z.enum(["start", "stop", "die", "restart", "health_status", "oom", "all"]).optional().describe("Filter by event type (default: all)"),
+  since: z.string().optional().describe("Show events since timestamp (e.g., '2026-01-01T00:00:00Z')"),
+  duration: z.number().optional().describe("Max seconds to listen (default: 30)"),
+});
+
+export const SearchLogsSchema = z.object({
+  pattern: z.string().describe("Regex or grep pattern to search for"),
+  containers: z.array(z.string()).optional().describe("Specific containers to search (default: all running)"),
+  tail: z.number().optional().describe("Max lines to scan per container (default: 500)"),
+  since: z.string().optional().describe("Only search logs since timestamp"),
+  ignore_case: z.boolean().optional().describe("Case-insensitive search (default: false)"),
+});
+
+export const CheckThresholdsSchema = z.object({
+  cpu_percent: z.number().optional().describe("Alert if CPU usage exceeds this % (default: 80)"),
+  memory_percent: z.number().optional().describe("Alert if memory usage exceeds this % (default: 80)"),
+  restart_count: z.number().optional().describe("Alert if restart count exceeds this (default: 5)"),
+});
+
+export const MonitorDashboardSchema = z.object({});