@supernova123/docker-mcp-server 0.1.6 → 0.2.1

package/README.md

@@ -24,8 +24,19 @@ There are 11+ Docker MCP servers on npm. Most are stale, GPL-licensed, or only c
 | **Auto-restart** | ✅ set_restart_policy | ❌ | ❌ |
 | **Compose lifecycle** | ✅ up/down/ps/logs/restart | ❌ | ❌ |
 | **Log streaming** | ✅ tail + timestamp filter | Basic | Basic |
+| **Fleet monitoring** | ✅ 6 fleet tools (status, stats, events, logs, thresholds, dashboard) | ❌ | ❌ |
 | **Agent positioning** | ✅ Built for agents | Generic Docker | Registry API |
 
+## Use Cases
+
+**Agent-managed deployments:** Your agent deploys a new version, checks health, waits for readiness, then switches traffic. If the health check fails, it auto-rolls back.
+
+**Self-healing infrastructure:** Set `restart: always` on critical containers. Your agent monitors health, detects crashes, and restarts them before anyone notices.
+
+**Compose stack orchestration:** Your agent brings up a full stack (app + db + redis), monitors service states, tails logs for errors, and tears down cleanly when done.
+
+**Debugging sessions:** Your agent execs into a container, runs diagnostics, streams logs with timestamp filters, and captures stats — all without SSH.
+
 ## Quick Start
 
 One command to run:
@@ -86,6 +97,16 @@ claude mcp add docker -- npx -y @supernova123/docker-mcp-server
 | `compose_logs` | Tail Compose service logs |
 | `compose_restart` | Restart Compose services |
 
+### Fleet Monitoring
+| Tool | Description |
+|------|-------------|
+| `fleet_status` | Health status of all running containers (state, health, uptime, restart count) |
+| `fleet_stats` | Resource usage (CPU%, memory%, network I/O) for all running containers |
+| `watch_events` | Collect Docker events (start, stop, die, restart, health) over a time window |
+| `search_logs` | Search logs across multiple containers with regex/grep pattern |
+| `check_thresholds` | Check containers against CPU/memory/restart thresholds, return violations |
+| `monitor_dashboard` | Single-call fleet summary: health, top consumers, recent events, violations |
+
 ### Health & Self-Healing
 | Tool | Description |
 |------|-------------|

package/dist/server.js

@@ -6,10 +6,11 @@ import { registerHealthTools } from "./tools/health.js";
 import { registerLogsTools } from "./tools/logs.js";
 import { registerExecTools } from "./tools/exec.js";
 import { registerNetworkTools } from "./tools/network.js";
+import { registerMonitoringTools } from "./tools/monitoring.js";
 export function createServer(docker) {
     const server = new McpServer({
         name: "docker-mcp-server",
-        version: "0.1.0",
+        version: "0.2.0",
     });
     // Register all tool categories
     registerContainerTools(server, docker);
@@ -19,6 +20,7 @@ export function createServer(docker) {
     registerLogsTools(server, docker);
     registerExecTools(server, docker);
     registerNetworkTools(server, docker);
+    registerMonitoringTools(server, docker);
     return server;
 }
 //# sourceMappingURL=server.js.map

package/dist/tools/monitoring.d.ts

@@ -0,0 +1,4 @@
+import Dockerode from "dockerode";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerMonitoringTools(server: McpServer, docker: Dockerode): void;
+//# sourceMappingURL=monitoring.d.ts.map

package/dist/tools/monitoring.js

@@ -0,0 +1,309 @@
+import { ContainerHealthStatusSchema, ContainerResourceUsageSchema, WatchEventsSchema, SearchLogsSchema, ResourceAlertCheckSchema, MonitorDashboardSchema, } from "../types.js";
+export function registerMonitoringTools(server, docker) {
+    // 1. fleet_status — health status of all running containers
+    server.tool("container_health_status", "Check health status, uptime, and restart count for all running Docker containers. Returns JSON with container name, state, health probe status, and restart count.", ContainerHealthStatusSchema.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) {
+            return {
+                content: [{ type: "text", text: `Error: ${err.message}` }],
+                isError: true,
+            };
+        }
+    });
+    // 2. fleet_stats — resource usage for all running containers
+    server.tool("container_resource_usage", "Monitor CPU, memory, and network I/O across all running Docker containers. Returns sorted resource usage metrics with percentage breakdowns.", ContainerResourceUsageSchema.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, n) => sum + (n.rx_bytes ?? 0), 0);
+                const netTx = Object.values(stats.networks ?? {}).reduce((sum, n) => 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, b) => {
+                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) {
+            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", "Stream Docker container events (start, stop, die, restart, health_status) over a configurable time window. Filter by specific container or event type.", WatchEventsSchema.shape, async (params) => {
+        try {
+            const durationMs = (params.duration || 30) * 1000;
+            const filter = {};
+            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 = [];
+            const stream = await docker.getEvents(filter);
+            await new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    resolve();
+                }, durationMs);
+                stream.on("data", (chunk) => {
+                    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) {
+            return {
+                content: [{ type: "text", text: `Error: ${err.message}` }],
+                isError: true,
+            };
+        }
+    });
+    // 4. search_logs — search logs across multiple containers
+    server.tool("search_logs", "Search Docker container logs across multiple containers using regex pattern matching. Returns matching log lines with container name and timestamp.", SearchLogsSchema.shape, async (params) => {
+        try {
+            const targetContainers = params.containers || [];
+            let containers;
+            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 = [];
+            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) {
+            return {
+                content: [{ type: "text", text: `Error: ${err.message}` }],
+                isError: true,
+            };
+        }
+    });
+    // 5. check_thresholds — check all containers against thresholds
+    server.tool("resource_alert_check", "Alert when Docker containers exceed resource thresholds (CPU%, memory%, restart count). Returns violations with specific metrics that triggered alerts.", ResourceAlertCheckSchema.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 = [];
+            for (const c of containers) {
+                const info = await docker.getContainer(c.Id).inspect();
+                const issues = [];
+                // 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) {
+            return {
+                content: [{ type: "text", text: `Error: ${err.message}` }],
+                isError: true,
+            };
+        }
+    });
+    // 6. monitor_dashboard — single-call fleet summary
+    server.tool("monitor_dashboard", "Comprehensive Docker fleet dashboard in a single API call. Returns health status, top resource consumers, recent events, and threshold violations.", 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, b) => b.cpu_percent - a.cpu_percent).slice(0, 5);
+            // Recent events (last 5 minutes) - use simple approach
+            const recentEvents = [];
+            try {
+                const sinceTs = Math.floor((Date.now() - 5 * 60 * 1000) / 1000);
+                const eventStream = await docker.getEvents({ since: sinceTs });
+                await new Promise((resolve) => {
+                    const timeout = setTimeout(() => { resolve(); }, 2000);
+                    eventStream.on("data", (chunk) => {
+                        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) => 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) {
+            return {
+                content: [{ type: "text", text: `Error: ${err.message}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=monitoring.js.map

package/dist/types.d.ts

@@ -306,4 +306,61 @@ export declare const ListVolumesSchema: z.ZodObject<{
 }, {
     filter?: string | undefined;
 }>;
+export declare const ContainerHealthStatusSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const ContainerResourceUsageSchema: z.ZodObject<{
+    sort_by: z.ZodOptional<z.ZodEnum<["cpu", "memory", "network"]>>;
+}, "strip", z.ZodTypeAny, {
+    sort_by?: "cpu" | "memory" | "network" | undefined;
+}, {
+    sort_by?: "cpu" | "memory" | "network" | undefined;
+}>;
+export declare const WatchEventsSchema: z.ZodObject<{
+    container: z.ZodOptional<z.ZodString>;
+    event_type: z.ZodOptional<z.ZodEnum<["start", "stop", "die", "restart", "health_status", "oom", "all"]>>;
+    since: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    since?: string | undefined;
+    container?: string | undefined;
+    event_type?: "all" | "start" | "stop" | "die" | "restart" | "health_status" | "oom" | undefined;
+    duration?: number | undefined;
+}, {
+    since?: string | undefined;
+    container?: string | undefined;
+    event_type?: "all" | "start" | "stop" | "die" | "restart" | "health_status" | "oom" | undefined;
+    duration?: number | undefined;
+}>;
+export declare const SearchLogsSchema: z.ZodObject<{
+    pattern: z.ZodString;
+    containers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    tail: z.ZodOptional<z.ZodNumber>;
+    since: z.ZodOptional<z.ZodString>;
+    ignore_case: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    pattern: string;
+    tail?: number | undefined;
+    since?: string | undefined;
+    containers?: string[] | undefined;
+    ignore_case?: boolean | undefined;
+}, {
+    pattern: string;
+    tail?: number | undefined;
+    since?: string | undefined;
+    containers?: string[] | undefined;
+    ignore_case?: boolean | undefined;
+}>;
+export declare const ResourceAlertCheckSchema: z.ZodObject<{
+    cpu_percent: z.ZodOptional<z.ZodNumber>;
+    memory_percent: z.ZodOptional<z.ZodNumber>;
+    restart_count: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    cpu_percent?: number | undefined;
+    memory_percent?: number | undefined;
+    restart_count?: number | undefined;
+}, {
+    cpu_percent?: number | undefined;
+    memory_percent?: number | undefined;
+    restart_count?: number | undefined;
+}>;
+export declare const MonitorDashboardSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
 //# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -125,4 +125,28 @@ 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 ContainerHealthStatusSchema = z.object({});
+export const ContainerResourceUsageSchema = 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 ResourceAlertCheckSchema = 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({});
 //# sourceMappingURL=types.js.map

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@supernova123/docker-mcp-server",
-  "version": "0.1.6",
+  "version": "0.2.1",
   "mcpName": "io.github.friendlygeorge/docker-mcp-server",
-  "description": "MCP server for Docker — container management, health checks, auto-restart, Compose lifecycle, and log streaming for Claude, Cursor, and AI agents",
+  "description": "MCP server for Docker \u2014 container management, health checks, auto-restart, Compose lifecycle, and log streaming for Claude, Cursor, and AI agents",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -18,19 +18,31 @@
   "keywords": [
     "mcp",
     "mcp-server",
+    "model-context-protocol",
     "docker",
     "docker-mcp",
     "container",
+    "containers",
     "compose",
+    "docker-compose",
     "health-check",
+    "health-monitoring",
+    "container-health",
     "devops",
+    "infrastructure",
+    "orchestration",
     "ai-agent",
-    "model-context-protocol",
+    "ai-agents",
     "claude",
     "cursor",
     "chatgpt",
     "claude-desktop",
-    "ai"
+    "monitoring",
+    "resource-monitoring",
+    "log-search",
+    "container-logs",
+    "docker-events",
+    "fleet-management"
   ],
   "author": "Nova",
   "license": "MIT",

package/src/server.ts

@@ -7,11 +7,12 @@ import { registerHealthTools } from "./tools/health.js";
 import { registerLogsTools } from "./tools/logs.js";
 import { registerExecTools } from "./tools/exec.js";
 import { registerNetworkTools } from "./tools/network.js";
+import { registerMonitoringTools } from "./tools/monitoring.js";
 
 export function createServer(docker: Dockerode): McpServer {
   const server = new McpServer({
     name: "docker-mcp-server",
-    version: "0.1.0",
+    version: "0.2.0",
   });
 
   // Register all tool categories
@@ -22,6 +23,7 @@ export function createServer(docker: Dockerode): McpServer {
   registerLogsTools(server, docker);
   registerExecTools(server, docker);
   registerNetworkTools(server, docker);
+  registerMonitoringTools(server, docker);
 
   return server;
 }

package/src/tools/monitoring.ts

@@ -0,0 +1,369 @@
+import Dockerode from "dockerode";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import {
+  ContainerHealthStatusSchema,
+  ContainerResourceUsageSchema,
+  WatchEventsSchema,
+  SearchLogsSchema,
+  ResourceAlertCheckSchema,
+  MonitorDashboardSchema,
+} from "../types.js";
+
+export function registerMonitoringTools(server: McpServer, docker: Dockerode): void {
+  // 1. fleet_status — health status of all running containers
+  server.tool(
+    "container_health_status",
+    "Check health status, uptime, and restart count for all running Docker containers. Returns JSON with container name, state, health probe status, and restart count.",
+    ContainerHealthStatusSchema.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(
+    "container_resource_usage",
+    "Monitor CPU, memory, and network I/O across all running Docker containers. Returns sorted resource usage metrics with percentage breakdowns.",
+    ContainerResourceUsageSchema.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",
+    "Stream Docker container events (start, stop, die, restart, health_status) over a configurable time window. Filter by specific 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 Docker container logs across multiple containers using regex pattern matching. Returns matching log 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(
+    "resource_alert_check",
+    "Alert when Docker containers exceed resource thresholds (CPU%, memory%, restart count). Returns violations with specific metrics that triggered alerts.",
+    ResourceAlertCheckSchema.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",
+    "Comprehensive Docker fleet dashboard in a single API call. Returns health status, top resource consumers, recent events, and threshold violations.",
+    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 ContainerHealthStatusSchema = z.object({});
+
+export const ContainerResourceUsageSchema = 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 ResourceAlertCheckSchema = 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({});

package/tests/monitoring.test.ts

@@ -0,0 +1,411 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+// Mock Dockerode before importing the module under test
+const mockListContainers = vi.fn();
+const mockInspect = vi.fn();
+const mockStats = vi.fn();
+const mockGetEvents = vi.fn();
+const mockLogs = vi.fn();
+
+vi.mock("dockerode", () => {
+  return {
+    default: vi.fn().mockImplementation(() => ({
+      listContainers: mockListContainers,
+      getContainer: vi.fn().mockReturnValue({
+        inspect: mockInspect,
+        stats: mockStats,
+        logs: mockLogs,
+      }),
+      getEvents: mockGetEvents,
+    })),
+  };
+});
+
+import { registerMonitoringTools } from "../src/tools/monitoring.js";
+
+// Minimal MCP server mock (same pattern as container.test.ts)
+function createMockServer() {
+  const tools: Record<string, { description: string; handler: Function }> = {};
+  return {
+    tool: (name: string, description: string, _schema: unknown, handler: Function) => {
+      tools[name] = { description, handler };
+    },
+    tools,
+  };
+}
+
+// Helper: mock container list
+function mockContainers(ids: string[], names: string[]) {
+  mockListContainers.mockResolvedValue(
+    ids.map((id, i) => ({
+      Id: id,
+      Names: [names[i] || `/container-${i}`],
+      Image: "nginx:latest",
+      State: "running",
+      Status: "Up 1 hour",
+    }))
+  );
+}
+
+// Helper: mock inspect result
+function mockInspectResult(overrides: Record<string, any> = {}) {
+  return {
+    Id: "abc123",
+    State: {
+      Running: true,
+      StartedAt: "2026-06-15T10:00:00Z",
+      Health: { Status: "healthy" },
+    },
+    RestartCount: 0,
+    Name: "/test-container",
+    ...overrides,
+  };
+}
+
+// Helper: mock stats result
+function mockStatsResult(overrides: Record<string, any> = {}) {
+  return {
+    cpu_stats: {
+      cpu_usage: { total_usage: 1000000 },
+      system_cpu_usage: 10000000,
+      online_cpus: 2,
+    },
+    precpu_stats: {
+      cpu_usage: { total_usage: 900000 },
+      system_cpu_usage: 9500000,
+    },
+    memory_stats: {
+      usage: 100 * 1024 * 1024, // 100MB
+      limit: 1024 * 1024 * 1024, // 1GB
+    },
+    networks: {
+      eth0: { rx_bytes: 1024 * 1024, tx_bytes: 512 * 1024 },
+    },
+    ...overrides,
+  };
+}
+
+describe("Monitoring Tools", () => {
+  let server: ReturnType<typeof createMockServer>;
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    server = createMockServer();
+    // Create a fresh docker-like object with direct mock references
+    const docker = {
+      listContainers: mockListContainers,
+      getContainer: (id: string) => ({
+        inspect: mockInspect,
+        stats: mockStats,
+        logs: mockLogs,
+      }),
+      getEvents: mockGetEvents,
+    } as any;
+    registerMonitoringTools(server, docker);
+  });
+
+  describe("container_health_status", () => {
+    it("returns health status for all running containers", async () => {
+      mockContainers(["abc123", "def456"], ["web", "db"]);
+      mockInspect
+        .mockResolvedValueOnce(mockInspectResult({ RestartCount: 2 }))
+        .mockResolvedValueOnce(mockInspectResult({ RestartCount: 0, State: { Running: true, StartedAt: "2026-06-15T11:00:00Z", Health: { Status: "unhealthy" } } }));
+
+      const result = await server.tools["container_health_status"].handler({});
+      const data = JSON.parse(result.content[0].text);
+
+      expect(data).toHaveLength(2);
+      expect(data[0].name).toBe("web");
+      expect(data[0].id).toBe("abc123");
+      expect(data[0].health).toBe("healthy");
+      expect(data[0].restartCount).toBe(2);
+      expect(data[1].health).toBe("unhealthy");
+    });
+
+    it("handles containers with no healthcheck", async () => {
+      mockContainers(["abc123"], ["no-health"]);
+      mockInspect.mockResolvedValue(mockInspectResult({
+        State: { Running: true, StartedAt: "2026-06-15T10:00:00Z" },
+      }));
+
+      const result = await server.tools["container_health_status"].handler({});
+      const data = JSON.parse(result.content[0].text);
+
+      expect(data[0].health).toBe("no-healthcheck");
+    });
+
+    it("returns error on Docker failure", async () => {
+      mockListContainers.mockRejectedValue(new Error("Docker daemon not running"));
+      const result = await server.tools["container_health_status"].handler({});
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain("Docker daemon not running");
+    });
+  });
+
+  describe("container_resource_usage", () => {
+    it("returns resource usage sorted by CPU by default", async () => {
+      mockContainers(["abc123", "def456"], ["low-cpu", "high-cpu"]);
+      mockStats
+        .mockResolvedValueOnce(mockStatsResult({
+          cpu_stats: { cpu_usage: { total_usage: 100000 }, system_cpu_usage: 10000000, online_cpus: 2 },
+          precpu_stats: { cpu_usage: { total_usage: 90000 }, system_cpu_usage: 9500000 },
+        }))
+        .mockResolvedValueOnce(mockStatsResult({
+          cpu_stats: { cpu_usage: { total_usage: 500000 }, system_cpu_usage: 10000000, online_cpus: 2 },
+          precpu_stats: { cpu_usage: { total_usage: 100000 }, system_cpu_usage: 9500000 },
+        }));
+
+      const result = await server.tools["container_resource_usage"].handler({});
+      const data = JSON.parse(result.content[0].text);
+
+      expect(data).toHaveLength(2);
+      // high-cpu should be first (sorted by CPU desc)
+      expect(data[0].name).toBe("high-cpu");
+      expect(data[0].cpu_percent).toBeGreaterThan(data[1].cpu_percent);
+      expect(data[0].memory_usage_mb).toBeGreaterThan(0);
+      expect(data[0].network_rx_mb).toBeGreaterThanOrEqual(0);
+    });
+
+    it("sorts by memory when requested", async () => {
+      mockContainers(["abc123", "def456"], ["low-mem", "high-mem"]);
+      mockStats
+        .mockResolvedValueOnce(mockStatsResult({
+          memory_stats: { usage: 50 * 1024 * 1024, limit: 1024 * 1024 * 1024 },
+        }))
+        .mockResolvedValueOnce(mockStatsResult({
+          memory_stats: { usage: 900 * 1024 * 1024, limit: 1024 * 1024 * 1024 },
+        }));
+
+      const result = await server.tools["container_resource_usage"].handler({ sort_by: "memory" });
+      const data = JSON.parse(result.content[0].text);
+
+      expect(data[0].name).toBe("high-mem");
+      expect(data[0].memory_percent).toBeGreaterThan(data[1].memory_percent);
+    });
+
+    it("returns error on Docker failure", async () => {
+      mockListContainers.mockRejectedValue(new Error("Cannot connect"));
+      const result = await server.tools["container_resource_usage"].handler({});
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain("Cannot connect");
+    });
+  });
+
+  describe("watch_events", () => {
+    it("collects events within time window", async () => {
+      const { Readable } = await import("stream");
+      const event1 = JSON.stringify({ Type: "container", Action: "start", Actor: { Attributes: { name: "web" }, ID: "abc123" }, time: Math.floor(Date.now() / 1000) });
+      const event2 = JSON.stringify({ Type: "container", Action: "stop", Actor: { Attributes: { name: "web" }, ID: "abc123" }, time: Math.floor(Date.now() / 1000) });
+
+      const stream = new Readable({
+        read() {
+          this.push(event1 + "\n");
+          this.push(event2 + "\n");
+          this.push(null); // end stream
+        },
+      });
+      mockGetEvents.mockResolvedValue(stream);
+
+      const result = await server.tools["watch_events"].handler({ duration: 5 });
+      const data = JSON.parse(result.content[0].text);
+
+      expect(data).toHaveLength(2);
+      expect(data[0].type).toBe("container");
+      expect(data[0].action).toBe("start");
+      expect(data[0].container).toBe("web");
+    });
+
+    it("returns message when no events captured", async () => {
+      const { Readable } = await import("stream");
+      const stream = new Readable({ read() { this.push(null); } });
+      mockGetEvents.mockResolvedValue(stream);
+
+      const result = await server.tools["watch_events"].handler({ duration: 1 });
+      expect(result.content[0].text).toBe("No events captured in the time window.");
+    });
+
+    it("returns error on Docker failure", async () => {
+      mockGetEvents.mockRejectedValue(new Error("Docker socket not found"));
+      const result = await server.tools["watch_events"].handler({});
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain("Docker socket not found");
+    });
+  });
+
+  describe("search_logs", () => {
+    it("searches logs with regex pattern", async () => {
+      mockContainers(["abc123"], ["web"]);
+      mockInspect.mockResolvedValue(mockInspectResult());
+      // Docker logs return Buffer with 8-byte header per line
+      const logLines = Buffer.from("2026-06-15 ERROR connection refused\n2026-06-15 INFO server started\n2026-06-15 ERROR timeout\n");
+      mockLogs.mockResolvedValue(logLines);
+
+      const result = await server.tools["search_logs"].handler({ pattern: "ERROR" });
+      const data = JSON.parse(result.content[0].text);
+
+      expect(data).toHaveLength(2);
+      expect(data[0].container).toBe("web");
+      expect(data[0].line).toContain("ERROR");
+    });
+
+    it("searches across multiple containers when no specific containers given", async () => {
+      mockContainers(["abc123", "def456"], ["web", "db"]);
+      mockInspect
+        .mockResolvedValueOnce(mockInspectResult())
+        .mockResolvedValueOnce(mockInspectResult());
+      mockLogs
+        .mockResolvedValueOnce(Buffer.from("2026-06-15 ERROR web error\n"))
+        .mockResolvedValueOnce(Buffer.from("2026-06-15 INFO db ready\n"));
+
+      const result = await server.tools["search_logs"].handler({ pattern: "ERROR" });
+      const data = JSON.parse(result.content[0].text);
+
+      expect(data).toHaveLength(1);
+      expect(data[0].container).toBe("web");
+    });
+
+    it("returns no matches message when pattern not found", async () => {
+      mockContainers(["abc123"], ["web"]);
+      mockInspect.mockResolvedValue(mockInspectResult());
+      mockLogs.mockResolvedValue(Buffer.from("2026-06-15 INFO all good\n"));
+
+      const result = await server.tools["search_logs"].handler({ pattern: "CRITICAL" });
+      expect(result.content[0].text).toBe("No matches found.");
+    });
+
+    it("supports case-insensitive matching", async () => {
+      mockContainers(["abc123"], ["web"]);
+      mockInspect.mockResolvedValue(mockInspectResult());
+      mockLogs.mockResolvedValue(Buffer.from("2026-06-15 Error lowercase\n"));
+
+      const result = await server.tools["search_logs"].handler({ pattern: "error", ignore_case: true });
+      const data = JSON.parse(result.content[0].text);
+
+      expect(data).toHaveLength(1);
+    });
+
+    it("returns error on Docker failure", async () => {
+      mockListContainers.mockRejectedValue(new Error("Cannot connect"));
+      const result = await server.tools["search_logs"].handler({ pattern: "ERROR" });
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain("Cannot connect");
+    });
+  });
+
+  describe("resource_alert_check", () => {
+    it("returns violations when containers exceed thresholds", async () => {
+      mockContainers(["abc123"], ["high-cpu"]);
+      mockInspect.mockResolvedValue(mockInspectResult({ RestartCount: 10 }));
+      mockStats.mockResolvedValue(mockStatsResult({
+        cpu_stats: { cpu_usage: { total_usage: 9000000 }, system_cpu_usage: 10000000, online_cpus: 2 },
+        precpu_stats: { cpu_usage: { total_usage: 1000000 }, system_cpu_usage: 9500000 },
+      }));
+
+      const result = await server.tools["resource_alert_check"].handler({ cpu_percent: 80, restart_count: 5 });
+      const data = JSON.parse(result.content[0].text);
+
+      expect(data.violations).toHaveLength(1);
+      expect(data.violations[0].container).toBe("high-cpu");
+      expect(data.violations[0].issues.length).toBeGreaterThan(0);
+      expect(data.violations[0].issues.some((i: string) => i.includes("restarts"))).toBe(true);
+      expect(data.violations[0].issues.some((i: string) => i.includes("cpu"))).toBe(true);
+    });
+
+    it("returns all-clear when within thresholds", async () => {
+      mockContainers(["abc123"], ["healthy"]);
+      mockInspect.mockResolvedValue(mockInspectResult({ RestartCount: 0 }));
+      mockStats.mockResolvedValue(mockStatsResult({
+        cpu_stats: { cpu_usage: { total_usage: 100000 }, system_cpu_usage: 10000000, online_cpus: 2 },
+        precpu_stats: { cpu_usage: { total_usage: 90000 }, system_cpu_usage: 9500000 },
+      }));
+
+      const result = await server.tools["resource_alert_check"].handler({});
+      const data = JSON.parse(result.content[0].text);
+
+      expect(data.message).toContain("All containers within thresholds");
+      expect(data.checked).toBe(1);
+    });
+
+    it("uses default thresholds when not specified", async () => {
+      mockContainers(["abc123"], ["ok"]);
+      mockInspect.mockResolvedValue(mockInspectResult({ RestartCount: 4 })); // < 5 default
+      mockStats.mockResolvedValue(mockStatsResult({
+        cpu_stats: { cpu_usage: { total_usage: 100000 }, system_cpu_usage: 10000000, online_cpus: 2 },
+        precpu_stats: { cpu_usage: { total_usage: 90000 }, system_cpu_usage: 9500000 },
+      }));
+
+      const result = await server.tools["resource_alert_check"].handler({});
+      const data = JSON.parse(result.content[0].text);
+
+      expect(data.message).toContain("All containers within thresholds");
+    });
+
+    it("returns error on Docker failure", async () => {
+      mockListContainers.mockRejectedValue(new Error("Daemon down"));
+      const result = await server.tools["resource_alert_check"].handler({});
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain("Daemon down");
+    });
+  });
+
+  describe("monitor_dashboard", () => {
+    it("returns comprehensive fleet summary", async () => {
+      mockContainers(["abc123", "def456"], ["web", "db"]);
+      mockInspect
+        .mockResolvedValueOnce(mockInspectResult({ RestartCount: 0 }))
+        .mockResolvedValueOnce(mockInspectResult({ RestartCount: 3, State: { Running: true, StartedAt: "2026-06-15T10:00:00Z", Health: { Status: "unhealthy" } } }));
+      mockStats
+        .mockResolvedValueOnce(mockStatsResult({
+          cpu_stats: { cpu_usage: { total_usage: 200000 }, system_cpu_usage: 10000000, online_cpus: 2 },
+          precpu_stats: { cpu_usage: { total_usage: 100000 }, system_cpu_usage: 9500000 },
+        }))
+        .mockResolvedValueOnce(mockStatsResult({
+          cpu_stats: { cpu_usage: { total_usage: 5000000 }, system_cpu_usage: 10000000, online_cpus: 2 },
+          precpu_stats: { cpu_usage: { total_usage: 1000000 }, system_cpu_usage: 9500000 },
+        }));
+
+      // Mock events (empty stream)
+      const { Readable } = await import("stream");
+      const eventStream = new Readable({ read() { this.push(null); } });
+      mockGetEvents.mockResolvedValue(eventStream);
+
+      const result = await server.tools["monitor_dashboard"].handler({});
+      const data = JSON.parse(result.content[0].text);
+
+      expect(data.summary.total_containers).toBe(2);
+      expect(data.summary.running).toBe(2);
+      expect(data.summary.unhealthy).toBe(1);
+      expect(data.health).toHaveLength(2);
+      expect(data.top_cpu_consumers).toHaveLength(2);
+      // db should be first (higher CPU)
+      expect(data.top_cpu_consumers[0].name).toBe("db");
+    });
+
+    it("handles empty fleet", async () => {
+      mockListContainers.mockResolvedValue([]);
+      const { Readable } = await import("stream");
+      const eventStream = new Readable({ read() { this.push(null); } });
+      mockGetEvents.mockResolvedValue(eventStream);
+
+      const result = await server.tools["monitor_dashboard"].handler({});
+      const data = JSON.parse(result.content[0].text);
+
+      expect(data.summary.total_containers).toBe(0);
+      expect(data.summary.running).toBe(0);
+      expect(data.health).toHaveLength(0);
+    });
+
+    it("returns error on Docker failure", async () => {
+      mockListContainers.mockRejectedValue(new Error("Connection refused"));
+      const result = await server.tools["monitor_dashboard"].handler({});
+
+      expect(result.isError).toBe(true);
+      expect(result.content[0].text).toContain("Connection refused");
+    });
+  });
+});