@supernova123/docker-mcp-server 0.1.5 → 0.2.0

package/.dockerignore

@@ -0,0 +1,9 @@
+node_modules
+dist
+.git
+*.md
+!README.md
+tests
+tsconfig.json
+vitest.config.ts
+.DS_Store

package/Dockerfile

@@ -0,0 +1,29 @@
+FROM node:22-slim AS builder
+
+WORKDIR /app
+
+# Copy package files first for better layer caching
+COPY package.json package-lock.json ./
+RUN npm ci --ignore-scripts
+
+# Copy source and build
+COPY tsconfig.json ./
+COPY src/ ./src/
+RUN npm run build
+
+# Production stage
+FROM node:22-slim
+
+WORKDIR /app
+
+# Copy package files and install production deps only
+COPY package.json package-lock.json ./
+RUN npm ci --omit=dev --ignore-scripts
+
+# Copy built output
+COPY --from=builder /app/dist/ ./dist/
+
+# The server communicates via stdio (MCP transport)
+# No EXPOSE needed — stdio transport doesn't listen on a port
+
+ENTRYPOINT ["node", "dist/index.js"]

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/container.js

@@ -107,7 +107,7 @@ export function registerContainerTools(server, docker) {
             return { content: [{ type: "text", text: `Error: ${formatError(error)}` }], isError: true };
         }
     });
-    server.tool("run_container", "Create and start a new Docker container with one command. Supports image, env, ports, volumes, restart policy, and command override.", RunContainerSchema.shape, async (params) => {
+    server.tool("run_container", "Create and start a new Docker container with one command. Supports image, env, ports, volumes, restart policy, and command override. Auto-pulls missing images.", RunContainerSchema.shape, async (params) => {
         try {
             const createOpts = {
                 Image: params.image,
@@ -130,7 +130,28 @@ export function registerContainerTools(server, docker) {
                         : undefined,
                 },
             };
-            const container = await docker.createContainer(createOpts);
+            let container;
+            try {
+                container = await docker.createContainer(createOpts);
+            }
+            catch (createError) {
+                // Auto-pull if image not found (HTTP 404)
+                if (createError?.statusCode === 404 && /no such image|No such image/i.test(createError.message || "")) {
+                    const stream = await docker.pull(params.image);
+                    await new Promise((resolve, reject) => {
+                        docker.modem.followProgress(stream, (err) => {
+                            if (err)
+                                reject(err);
+                            else
+                                resolve();
+                        });
+                    });
+                    container = await docker.createContainer(createOpts);
+                }
+                else {
+                    throw createError;
+                }
+            }
             await container.start();
             return {
                 content: [{ type: "text", text: `Container created and started. ID: ${container.id.substring(0, 12)}` }],

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 { FleetStatusSchema, FleetStatsSchema, WatchEventsSchema, SearchLogsSchema, CheckThresholdsSchema, MonitorDashboardSchema, } from "../types.js";
+export function registerMonitoringTools(server, docker) {
+    // 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) {
+            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, 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", "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 = {};
+            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 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;
+            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("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 = [];
+            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", "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, 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 FleetStatusSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const FleetStatsSchema: 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 CheckThresholdsSchema: 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 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({});
 //# sourceMappingURL=types.js.map

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@supernova123/docker-mcp-server",
-  "version": "0.1.5",
+  "version": "0.2.0",
   "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": {
@@ -53,4 +53,4 @@
     "typescript": "^5.7.0",
     "vitest": "^3.1.0"
   }
-}
+}

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/container.ts

@@ -156,7 +156,7 @@ export function registerContainerTools(server: McpServer, docker: Dockerode): vo
 
   server.tool(
     "run_container",
-    "Create and start a new Docker container with one command. Supports image, env, ports, volumes, restart policy, and command override.",
+    "Create and start a new Docker container with one command. Supports image, env, ports, volumes, restart policy, and command override. Auto-pulls missing images.",
     RunContainerSchema.shape,
     async (params) => {
       try {
@@ -184,7 +184,25 @@ export function registerContainerTools(server: McpServer, docker: Dockerode): vo
           },
         };
 
-        const container = await docker.createContainer(createOpts);
+        let container;
+        try {
+          container = await docker.createContainer(createOpts);
+        } catch (createError: any) {
+          // Auto-pull if image not found (HTTP 404)
+          if (createError?.statusCode === 404 && /no such image|No such image/i.test(createError.message || "")) {
+            const stream = await docker.pull(params.image);
+            await new Promise<void>((resolve, reject) => {
+              docker.modem.followProgress(stream, (err: Error | null) => {
+                if (err) reject(err);
+                else resolve();
+              });
+            });
+            container = await docker.createContainer(createOpts);
+          } else {
+            throw createError;
+          }
+        }
+
         await container.start();
         return {
           content: [{ type: "text", text: `Container created and started. ID: ${container.id.substring(0, 12)}` }],