@supernova123/docker-mcp-server 0.3.0 → 0.3.2

package/src/tools/container.ts

@@ -10,7 +10,7 @@ import {
   RecreateContainerSchema,
   RunContainerSchema,
 } from "../types.js";
-import { formatContainer, formatError } from "../docker.js";
+import { formatContainer, formatError, withRetry } from "../docker.js";
 
 export function registerContainerTools(server: McpServer, docker: Dockerode): void {
   server.tool(
@@ -20,14 +20,17 @@ export function registerContainerTools(server: McpServer, docker: Dockerode): vo
     { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
     async (params) => {
       try {
-        const containers = await docker.listContainers({
-          all: params.all ?? false,
-          filters: JSON.stringify({
-            ...(params.label ? { label: params.label } : {}),
-            ...(params.name ? { name: [`/${params.name}`] } : {}),
-            ...(params.state ? { status: [params.state] } : {}),
+        const containers = await withRetry(
+          () => docker.listContainers({
+            all: params.all ?? false,
+            filters: JSON.stringify({
+              ...(params.label ? { label: params.label } : {}),
+              ...(params.name ? { name: [`/${params.name}`] } : {}),
+              ...(params.state ? { status: [params.state] } : {}),
+            }),
           }),
-        });
+          { label: "list_containers" }
+        );
         const results = containers.map(formatContainer);
         return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
       } catch (error) {
@@ -60,7 +63,7 @@ export function registerContainerTools(server: McpServer, docker: Dockerode): vo
     async (params) => {
       try {
         const container = docker.getContainer(params.container_id);
-        await container.start();
+        await withRetry(() => container.start(), { label: "start_container" });
         return { content: [{ type: "text", text: `Container ${params.container_id} started.` }] };
       } catch (error) {
         return { content: [{ type: "text", text: `Error: ${formatError(error)}` }], isError: true };
@@ -76,7 +79,7 @@ export function registerContainerTools(server: McpServer, docker: Dockerode): vo
     async (params) => {
       try {
         const container = docker.getContainer(params.container_id);
-        await container.stop({ t: params.timeout ?? 10 });
+        await withRetry(() => container.stop({ t: params.timeout ?? 10 }), { label: "stop_container" });
         return { content: [{ type: "text", text: `Container ${params.container_id} stopped.` }] };
       } catch (error: any) {
         // 304 means container is already stopped — treat as success
@@ -96,7 +99,7 @@ export function registerContainerTools(server: McpServer, docker: Dockerode): vo
     async (params) => {
       try {
         const container = docker.getContainer(params.container_id);
-        await container.restart({ t: params.timeout ?? 10 });
+        await withRetry(() => container.restart({ t: params.timeout ?? 10 }), { label: "restart_container" });
         return { content: [{ type: "text", text: `Container ${params.container_id} restarted.` }] };
       } catch (error) {
         return { content: [{ type: "text", text: `Error: ${formatError(error)}` }], isError: true };

package/src/tools/health.ts

@@ -1,7 +1,7 @@
 import Dockerode from "dockerode";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { CheckHealthSchema, WatchHealthSchema, SetRestartPolicySchema } from "../types.js";
-import { formatError } from "../docker.js";
+import { formatError, withRetry } from "../docker.js";
 
 export function registerHealthTools(server: McpServer, docker: Dockerode): void {
   server.tool(

package/src/tools/image.ts

@@ -6,7 +6,7 @@ import {
   BuildImageSchema,
   RemoveImageSchema,
 } from "../types.js";
-import { formatImage, formatError } from "../docker.js";
+import { formatImage, formatError, withRetry } from "../docker.js";
 
 export function registerImageTools(server: McpServer, docker: Dockerode): void {
   server.tool(
@@ -16,10 +16,10 @@ export function registerImageTools(server: McpServer, docker: Dockerode): void {
     { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
     async (params) => {
       try {
-        const images = await docker.listImages({
+        const images = await withRetry(() => docker.listImages({
           all: params.all ?? false,
           filters: params.filter ? JSON.stringify({ reference: [params.filter] }) : undefined,
-        });
+        }), { label: "list_images" });
         const results = images.map(formatImage);
         return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
       } catch (error) {

package/src/tools/logs.ts

@@ -1,7 +1,7 @@
 import Dockerode from "dockerode";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamLogsSchema, ContainerStatsSchema } from "../types.js";
-import { formatError, formatBytes, sanitizeOutput } from "../docker.js";
+import { formatError, sanitizeOutput, withRetry, formatBytes } from "../docker.js";
 
 export function registerLogsTools(server: McpServer, docker: Dockerode): void {
   server.tool(
@@ -12,13 +12,13 @@ export function registerLogsTools(server: McpServer, docker: Dockerode): void {
     async (params) => {
       try {
         const container = docker.getContainer(params.container_id);
-        const logs = await container.logs({
+        const logs = await withRetry(() => container.logs({
           stdout: true,
           stderr: true,
           tail: params.tail ?? 100,
           since: params.since ? Math.floor(new Date(params.since).getTime() / 1000) : undefined,
           follow: false as const,
-        });
+        }), { label: "container_logs" });
         // Dockerode returns a Buffer with multiplexed stream headers
         // Use 100KB cap for logs to keep LLM context small
         const output = sanitizeOutput(logs.toString("utf-8"), 100_000);

package/src/tools/network.ts

@@ -1,7 +1,7 @@
 import Dockerode from "dockerode";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { ListNetworksSchema, ListVolumesSchema } from "../types.js";
-import { formatError } from "../docker.js";
+import { formatError, withRetry } from "../docker.js";
 
 export function registerNetworkTools(server: McpServer, docker: Dockerode): void {
   server.tool(
@@ -11,9 +11,9 @@ export function registerNetworkTools(server: McpServer, docker: Dockerode): void
     { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
     async (params) => {
       try {
-        const networks = await docker.listNetworks({
+        const networks = await withRetry(() => docker.listNetworks({
           filters: params.filter ? JSON.stringify({ name: [params.filter] }) : undefined,
-        });
+        }), { label: "list_networks" });
         const results = networks.map((n) => ({
           id: n.Id.substring(0, 12),
           name: n.Name,

package/src/tools/volume.ts

@@ -6,7 +6,7 @@ import {
   RemoveVolumeSchema,
   PruneVolumesSchema,
 } from "../types.js";
-import { formatError } from "../docker.js";
+import { formatError, withRetry } from "../docker.js";
 
 export function registerVolumeTools(server: McpServer, docker: Dockerode): void {
   server.tool(
@@ -16,12 +16,12 @@ export function registerVolumeTools(server: McpServer, docker: Dockerode): void
     { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
     async (params) => {
       try {
-        const result = await docker.createVolume({
+        const result = await withRetry(() => docker.createVolume({
           Name: params.name,
           Driver: params.driver || "local",
           Labels: params.labels,
           DriverOpts: params.options,
-        });
+        }), { label: "create_volume" });
         return {
           content: [{
             type: "text",
@@ -122,4 +122,4 @@ export function registerVolumeTools(server: McpServer, docker: Dockerode): void
       }
     }
   );
-}
+}

package/tests/retry.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, vi } from "vitest";
+import { withRetry, DockerTimeoutError, DockerConnectionError, DockerPermissionError } from "../src/docker.js";
+
+describe("withRetry", () => {
+  it("returns result on first attempt (no retry needed)", async () => {
+    const fn = vi.fn().mockResolvedValue("success");
+    const result = await withRetry(fn, { maxRetries: 3, baseDelayMs: 10 });
+    expect(result).toBe("success");
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it("retries on transient ECONNRESET error", async () => {
+    const fn = vi.fn()
+      .mockRejectedValueOnce(new Error("read ECONNRESET"))
+      .mockResolvedValue("recovered");
+    const result = await withRetry(fn, { maxRetries: 3, baseDelayMs: 10, label: "test" });
+    expect(result).toBe("recovered");
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it("retries on timeout error", async () => {
+    const fn = vi.fn()
+      .mockRejectedValueOnce(new DockerTimeoutError("timed out"))
+      .mockResolvedValue("recovered");
+    const result = await withRetry(fn, { maxRetries: 3, baseDelayMs: 10 });
+    expect(result).toBe("recovered");
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it("does NOT retry on 404 Not Found", async () => {
+    const fn = vi.fn().mockRejectedValue(new Error("HTTP 404: Not Found"));
+    await expect(withRetry(fn, { maxRetries: 3, baseDelayMs: 10 }))
+      .rejects.toThrow("HTTP 404: Not Found");
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it("does NOT retry on permission denied", async () => {
+    const fn = vi.fn().mockRejectedValue(new Error("Permission denied"));
+    await expect(withRetry(fn, { maxRetries: 3, baseDelayMs: 10 }))
+      .rejects.toThrow("Permission denied");
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it("does NOT retry on DockerConnectionError", async () => {
+    const fn = vi.fn().mockRejectedValue(new DockerConnectionError("cannot connect"));
+    await expect(withRetry(fn, { maxRetries: 3, baseDelayMs: 10 }))
+      .rejects.toThrow("cannot connect");
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it("does NOT retry on DockerPermissionError", async () => {
+    const fn = vi.fn().mockRejectedValue(new DockerPermissionError("access denied"));
+    await expect(withRetry(fn, { maxRetries: 3, baseDelayMs: 10 }))
+      .rejects.toThrow("access denied");
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it("retries on 500 Internal Server Error", async () => {
+    const fn = vi.fn()
+      .mockRejectedValueOnce(new Error("HTTP 500: Internal Server Error"))
+      .mockResolvedValue("recovered");
+    const result = await withRetry(fn, { maxRetries: 3, baseDelayMs: 10 });
+    expect(result).toBe("recovered");
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it("exhausts retries and throws last error", async () => {
+    const fn = vi.fn().mockRejectedValue(new Error("read ECONNRESET"));
+    await expect(withRetry(fn, { maxRetries: 2, baseDelayMs: 10 }))
+      .rejects.toThrow("read ECONNRESET");
+    expect(fn).toHaveBeenCalledTimes(3); // initial + 2 retries
+  });
+
+  it("retries on socket hang up", async () => {
+    const fn = vi.fn()
+      .mockRejectedValueOnce(new Error("socket hang up"))
+      .mockResolvedValue("ok");
+    const result = await withRetry(fn, { maxRetries: 3, baseDelayMs: 10 });
+    expect(result).toBe("ok");
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+});

package/src/docker.ts.bak

@@ -1,85 +0,0 @@
-import Dockerode from "dockerode";
-
-export interface DockerClientOptions {
-  socketPath?: string;
-  host?: string;
-  port?: number;
-}
-
-export function createDockerClient(options?: DockerClientOptions): Dockerode {
-  if (options?.socketPath) {
-    return new Dockerode({ socketPath: options.socketPath });
-  }
-  if (options?.host && options?.port) {
-    return new Dockerode({ host: options.host, port: options.port });
-  }
-  // Default: local socket
-  return new Dockerode({ socketPath: "/var/run/docker.sock" });
-}
-
-export function formatError(error: unknown): string {
-  if (error instanceof Error) return error.message;
-  if (typeof error === "string") return error;
-  return String(error);
-}
-
-export function formatContainer(container: Dockerode.ContainerInfo): Record<string, unknown> {
-  return {
-    id: container.Id.substring(0, 12),
-    name: container.Names[0]?.replace(/^\//, ""),
-    image: container.Image,
-    state: container.State,
-    status: container.Status,
-    created: new Date(container.Created * 1000).toISOString(),
-    ports: container.Ports.map((p) => ({
-      private: p.PrivatePort,
-      public: p.PublicPort,
-      type: p.Type,
-    })),
-    labels: container.Labels,
-    mounts: container.Mounts.map((m) => ({
-      type: m.Type,
-      source: m.Source,
-      destination: m.Destination,
-      mode: m.Mode,
-      rw: m.RW,
-    })),
-  };
-}
-
-export function formatImage(image: Dockerode.ImageInfo): Record<string, unknown> {
-  return {
-    id: image.Id.substring(0, 19),
-    tags: image.RepoTags || ["<none>:<none>"],
-    size: image.Size,
-    created: new Date(image.Created).toISOString(),
-  };
-}
-
-/**
- * Sanitize tool output: strip ANSI escapes, invisible Unicode, and truncate.
- * Prevents prompt injection via output and caps LLM context cost.
- */
-export function sanitizeOutput(text: string, maxLength = 1_000_000): string {
-  // Strip ANSI escape codes (CSI, OSC, simple sequences)
-  text = text.replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, "");
-  text = text.replace(/\x1b\][^\x07]*\x07/g, ""); // OSC terminated by BEL
-  text = text.replace(/\x1b[@-Z\\-_]/g, "");       // Single-char escapes
-  // Strip invisible Unicode (Tag chars, bidi overrides, zero-width)
-  text = text.replace(/[\uE0001-\uE007F\u200B-\u200F\u202A-\u202E\u2060-\u206F\uFEFF]/g, "");
-  // Strip Docker stream-frame headers (8-byte prefix per frame)
-  text = text.replace(/^[\x00-\x0f]{8}/gm, "");
-  // Truncate to cap memory and LLM context cost
-  if (text.length > maxLength) {
-    return text.slice(0, maxLength) + `\n... [output truncated at ${maxLength} chars]`;
-  }
-  return text;
-}
-
-export function formatBytes(bytes: number): string {
-  if (bytes === 0) return "0 B";
-  const k = 1024;
-  const sizes = ["B", "KB", "MB", "GB", "TB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
-}