@supernova123/docker-mcp-server 0.3.0 → 0.3.2

package/dist/docker.d.ts

@@ -5,6 +5,45 @@ export interface DockerClientOptions {
     port?: number;
 }
 export declare function createDockerClient(options?: DockerClientOptions): Dockerode;
+/**
+ * Structured error types for programmatic error classification.
+ * Helps AI clients decide whether to retry (retryable) or report (permanent).
+ */
+export declare class DockerConnectionError extends Error {
+    retryable: boolean;
+    constructor(message: string);
+}
+export declare class DockerTimeoutError extends Error {
+    retryable: boolean;
+    constructor(message: string);
+}
+export declare class DockerPermissionError extends Error {
+    retryable: boolean;
+    constructor(message: string);
+}
+/**
+ * Check Docker daemon connectivity at startup.
+ * Returns a structured error if Docker is unreachable.
+ */
+export declare function checkDockerConnection(docker: Dockerode): Promise<{
+    ok: boolean;
+    error?: string;
+}>;
+/**
+ * Run a Docker API call with a configurable timeout.
+ * Returns structured error on timeout instead of hanging indefinitely.
+ */
+export declare function withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise<T>;
+/**
+ * Retry a Docker API call with exponential backoff.
+ * Retries on transient errors (ECONNRESET, ETIMEDOUT, 5xx).
+ * Does NOT retry on 4xx errors (bad request, not found, permission denied).
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, options?: {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    label?: string;
+}): Promise<T>;
 export declare function formatError(error: unknown): string;
 export declare function formatContainer(container: Dockerode.ContainerInfo): Record<string, unknown>;
 export declare function formatImage(image: Dockerode.ImageInfo): Record<string, unknown>;

package/dist/docker.js

@@ -9,7 +9,156 @@ export function createDockerClient(options) {
     // Default: local socket
     return new Dockerode({ socketPath: "/var/run/docker.sock" });
 }
+/**
+ * Structured error types for programmatic error classification.
+ * Helps AI clients decide whether to retry (retryable) or report (permanent).
+ */
+export class DockerConnectionError extends Error {
+    retryable = false;
+    constructor(message) {
+        super(message);
+        this.name = "DockerConnectionError";
+    }
+}
+export class DockerTimeoutError extends Error {
+    retryable = true;
+    constructor(message) {
+        super(message);
+        this.name = "DockerTimeoutError";
+    }
+}
+export class DockerPermissionError extends Error {
+    retryable = false;
+    constructor(message) {
+        super(message);
+        this.name = "DockerPermissionError";
+    }
+}
+/**
+ * Check Docker daemon connectivity at startup.
+ * Returns a structured error if Docker is unreachable.
+ */
+export async function checkDockerConnection(docker) {
+    try {
+        await docker.ping();
+        return { ok: true };
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes("EACCES") || msg.includes("Permission denied")) {
+            return {
+                ok: false,
+                error: `DockerConnectionError: Cannot access Docker socket — ${msg}. Fix: add user to docker group (sudo usermod -aG docker $USER) or run as root.`,
+            };
+        }
+        if (msg.includes("ENOENT") || msg.includes("no such file")) {
+            return {
+                ok: false,
+                error: `DockerConnectionError: Docker socket not found at /var/run/docker.sock — ${msg}. Fix: install Docker (https://docs.docker.com/engine/install/) and ensure the daemon is running.`,
+            };
+        }
+        return {
+            ok: false,
+            error: `DockerConnectionError: Cannot connect to Docker daemon — ${msg}. Fix: ensure Docker is running (systemctl status docker).`,
+        };
+    }
+}
+/**
+ * Run a Docker API call with a configurable timeout.
+ * Returns structured error on timeout instead of hanging indefinitely.
+ */
+export async function withTimeout(promise, ms, label) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new DockerTimeoutError(`Docker API call "${label}" timed out after ${ms}ms`)), ms)),
+    ]);
+}
+/**
+ * Retry a Docker API call with exponential backoff.
+ * Retries on transient errors (ECONNRESET, ETIMEDOUT, 5xx).
+ * Does NOT retry on 4xx errors (bad request, not found, permission denied).
+ */
+export async function withRetry(fn, options = {}) {
+    const { maxRetries = 3, baseDelayMs = 1000, label = "Docker API call" } = options;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            // Don't retry on non-transient errors
+            if (!isRetryableError(error)) {
+                throw error;
+            }
+            // Don't retry on last attempt
+            if (attempt === maxRetries) {
+                throw error;
+            }
+            // Exponential backoff: 1s, 2s, 4s
+            const delay = baseDelayMs * Math.pow(2, attempt);
+            process.stderr.write(`[retry] ${label} failed (attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${delay}ms...\n`);
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+    }
+    throw lastError;
+}
+/**
+ * Determine if an error is transient and worth retrying.
+ * Retries on: connection resets, timeouts, 5xx status codes.
+ * Does NOT retry on: 4xx (client errors), permission denied, not found.
+ */
+function isRetryableError(error) {
+    if (!(error instanceof Error))
+        return false;
+    const msg = error.message.toLowerCase();
+    // Connection-level transient errors
+    if (msg.includes("econnreset") || msg.includes("econnrefused"))
+        return true;
+    if (msg.includes("etimedout") || msg.includes("socket hang up"))
+        return true;
+    if (msg.includes("epipe") || msg.includes("eai_again"))
+        return true;
+    // Docker API 5xx errors (server-side)
+    if (msg.includes("status code 5"))
+        return true;
+    if (msg.includes("internal server error"))
+        return true;
+    if (msg.includes("bad gateway"))
+        return true;
+    if (msg.includes("service unavailable"))
+        return true;
+    // Docker daemon busy (transient)
+    if (msg.includes("daemon is busy"))
+        return true;
+    if (msg.includes("too many requests"))
+        return true;
+    // 4xx errors are NOT retryable (client errors)
+    if (msg.includes("status code 4"))
+        return false;
+    if (msg.includes("not found"))
+        return false;
+    if (msg.includes("permission denied"))
+        return false;
+    if (msg.includes("bad request"))
+        return false;
+    // Permission/connection errors are NOT retryable
+    if (error.name === "DockerConnectionError")
+        return false;
+    if (error.name === "DockerPermissionError")
+        return false;
+    // Timeout errors ARE retryable (might be transient)
+    if (error.name === "DockerTimeoutError")
+        return true;
+    return false;
+}
 export function formatError(error) {
+    if (error instanceof DockerConnectionError)
+        return `${error.name}: ${error.message}`;
+    if (error instanceof DockerTimeoutError)
+        return `${error.name}: ${error.message}`;
+    if (error instanceof DockerPermissionError)
+        return `${error.name}: ${error.message}`;
     if (error instanceof Error)
         return error.message;
     if (typeof error === "string")

package/dist/index.js

@@ -1,10 +1,18 @@
 #!/usr/bin/env node
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { createDockerClient } from "./docker.js";
+import { createDockerClient, checkDockerConnection } from "./docker.js";
 import { createServer } from "./server.js";
+const DEFAULT_TIMEOUT_MS = 30_000;
 async function main() {
     const docker = createDockerClient();
-    const server = createServer(docker);
+    // Startup health check: verify Docker daemon is reachable
+    const health = await checkDockerConnection(docker);
+    if (!health.ok) {
+        process.stderr.write(`${health.error}\n`);
+        process.exit(1);
+    }
+    process.stderr.write("Docker daemon reachable\n");
+    const server = createServer(docker, { timeoutMs: DEFAULT_TIMEOUT_MS });
     const transport = new StdioServerTransport();
     await server.connect(transport);
     process.stderr.write("Docker MCP Server running on stdio\n");

package/dist/server.d.ts

@@ -1,4 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import Dockerode from "dockerode";
-export declare function createServer(docker: Dockerode): McpServer;
+export interface ServerOptions {
+    timeoutMs?: number;
+}
+export declare function createServer(docker: Dockerode, options?: ServerOptions): McpServer;
 //# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -8,10 +8,10 @@ import { registerExecTools } from "./tools/exec.js";
 import { registerNetworkTools } from "./tools/network.js";
 import { registerVolumeTools } from "./tools/volume.js";
 import { registerMonitoringTools } from "./tools/monitoring.js";
-export function createServer(docker) {
+export function createServer(docker, options) {
     const server = new McpServer({
         name: "docker-mcp-server",
-        version: "0.3.0",
+        version: "0.3.2",
     });
     // Register all tool categories
     registerContainerTools(server, docker);

package/dist/tools/container.js

@@ -1,16 +1,16 @@
 import { ListContainersSchema, InspectContainerSchema, StartContainerSchema, StopContainerSchema, RestartContainerSchema, RemoveContainerSchema, RecreateContainerSchema, RunContainerSchema, } from "../types.js";
-import { formatContainer, formatError } from "../docker.js";
+import { formatContainer, formatError, withRetry } from "../docker.js";
 export function registerContainerTools(server, docker) {
     server.tool("list_containers", "List Docker containers with optional filters (state, label, name). Returns container IDs, names, images, states, ports, and labels.", ListContainersSchema.shape, { readOnlyHint: true, idempotentHint: true, openWorldHint: false }, async (params) => {
         try {
-            const containers = await docker.listContainers({
+            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) }] };
         }
@@ -31,7 +31,7 @@ export function registerContainerTools(server, docker) {
     server.tool("start_container", "Start a stopped Docker container by ID or name.", StartContainerSchema.shape, { idempotentHint: true, openWorldHint: false }, 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) {
@@ -41,7 +41,7 @@ export function registerContainerTools(server, docker) {
     server.tool("stop_container", "Stop a running Docker container by ID or name with optional timeout.", StopContainerSchema.shape, { destructiveHint: true, openWorldHint: false }, 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) {
@@ -55,7 +55,7 @@ export function registerContainerTools(server, docker) {
     server.tool("restart_container", "Restart a Docker container by ID or name with optional timeout. This tears down the running process and starts a new one — use stop_container for a graceful shutdown or remove_container to delete entirely. The timeout parameter (default 10s) controls how long to wait before force-killing. Returns a confirmation string on success. Idempotent: restarting an already-stopped container starts it again. Returns an error string if the container does not exist or is not running.", RestartContainerSchema.shape, { destructiveHint: true, idempotentHint: true, openWorldHint: false }, 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) {

package/dist/tools/image.js

@@ -1,12 +1,12 @@
 import { ListImagesSchema, PullImageSchema, BuildImageSchema, RemoveImageSchema, } from "../types.js";
-import { formatImage, formatError } from "../docker.js";
+import { formatImage, formatError, withRetry } from "../docker.js";
 export function registerImageTools(server, docker) {
     server.tool("list_images", "List Docker images with optional filters. Returns image IDs, tags, sizes, and creation dates.", ListImagesSchema.shape, { 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) }] };
         }

package/dist/tools/logs.js

@@ -1,16 +1,16 @@
 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, docker) {
     server.tool("stream_logs", "Get logs from a single Docker container by ID or name. Use stream_logs for one container; use compose_logs for multi-service Compose stacks. Supports tail count (default 100 lines), since timestamp for filtering, and follow mode. Returns UTF-8 log text with multiplexed stream headers stripped, or 'No logs found.' when the container has no output. Read-only and safe to call repeatedly. Returns an error string if the container does not exist.", StreamLogsSchema.shape, { readOnlyHint: true, idempotentHint: true, openWorldHint: false }, 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,
-            });
+            }), { 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/dist/tools/network.js

@@ -1,11 +1,11 @@
 import { ListNetworksSchema, ListVolumesSchema } from "../types.js";
-import { formatError } from "../docker.js";
+import { formatError, withRetry } from "../docker.js";
 export function registerNetworkTools(server, docker) {
     server.tool("list_networks", "List Docker networks with optional filter. Returns network IDs, names, drivers, and scopes.", ListNetworksSchema.shape, { 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/dist/tools/volume.js

@@ -1,14 +1,14 @@
 import { CreateVolumeSchema, InspectVolumeSchema, RemoveVolumeSchema, PruneVolumesSchema, } from "../types.js";
-import { formatError } from "../docker.js";
+import { formatError, withRetry } from "../docker.js";
 export function registerVolumeTools(server, docker) {
     server.tool("create_volume", "Create a Docker volume with optional driver, labels, and options. Returns volume name, driver, and mountpoint.", CreateVolumeSchema.shape, { 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",

package/dist/types.d.ts

@@ -5,15 +5,15 @@ export declare const ListContainersSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     state: z.ZodOptional<z.ZodEnum<["running", "stopped", "paused", "exited", "created", "restarting"]>>;
 }, "strip", z.ZodTypeAny, {
+    label?: string[] | undefined;
     name?: string | undefined;
     state?: "created" | "running" | "stopped" | "paused" | "exited" | "restarting" | undefined;
     all?: boolean | undefined;
-    label?: string[] | undefined;
 }, {
+    label?: string[] | undefined;
     name?: string | undefined;
     state?: "created" | "running" | "stopped" | "paused" | "exited" | "restarting" | undefined;
     all?: boolean | undefined;
-    label?: string[] | undefined;
 }>;
 export declare const InspectContainerSchema: z.ZodObject<{
     container_id: z.ZodString;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supernova123/docker-mcp-server",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "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",
   "type": "module",

package/src/docker.ts

@@ -17,7 +17,171 @@ export function createDockerClient(options?: DockerClientOptions): Dockerode {
   return new Dockerode({ socketPath: "/var/run/docker.sock" });
 }
 
+/**
+ * Structured error types for programmatic error classification.
+ * Helps AI clients decide whether to retry (retryable) or report (permanent).
+ */
+export class DockerConnectionError extends Error {
+  retryable = false;
+  constructor(message: string) {
+    super(message);
+    this.name = "DockerConnectionError";
+  }
+}
+
+export class DockerTimeoutError extends Error {
+  retryable = true;
+  constructor(message: string) {
+    super(message);
+    this.name = "DockerTimeoutError";
+  }
+}
+
+export class DockerPermissionError extends Error {
+  retryable = false;
+  constructor(message: string) {
+    super(message);
+    this.name = "DockerPermissionError";
+  }
+}
+
+/**
+ * Check Docker daemon connectivity at startup.
+ * Returns a structured error if Docker is unreachable.
+ */
+export async function checkDockerConnection(
+  docker: Dockerode
+): Promise<{ ok: boolean; error?: string }> {
+  try {
+    await docker.ping();
+    return { ok: true };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    if (msg.includes("EACCES") || msg.includes("Permission denied")) {
+      return {
+        ok: false,
+        error: `DockerConnectionError: Cannot access Docker socket — ${msg}. Fix: add user to docker group (sudo usermod -aG docker $USER) or run as root.`,
+      };
+    }
+    if (msg.includes("ENOENT") || msg.includes("no such file")) {
+      return {
+        ok: false,
+        error: `DockerConnectionError: Docker socket not found at /var/run/docker.sock — ${msg}. Fix: install Docker (https://docs.docker.com/engine/install/) and ensure the daemon is running.`,
+      };
+    }
+    return {
+      ok: false,
+      error: `DockerConnectionError: Cannot connect to Docker daemon — ${msg}. Fix: ensure Docker is running (systemctl status docker).`,
+    };
+  }
+}
+
+/**
+ * Run a Docker API call with a configurable timeout.
+ * Returns structured error on timeout instead of hanging indefinitely.
+ */
+export async function withTimeout<T>(
+  promise: Promise<T>,
+  ms: number,
+  label: string
+): Promise<T> {
+  return Promise.race([
+    promise,
+    new Promise<never>((_, reject) =>
+      setTimeout(
+        () => reject(new DockerTimeoutError(`Docker API call "${label}" timed out after ${ms}ms`)),
+        ms
+      )
+    ),
+  ]);
+}
+
+
+/**
+ * Retry a Docker API call with exponential backoff.
+ * Retries on transient errors (ECONNRESET, ETIMEDOUT, 5xx).
+ * Does NOT retry on 4xx errors (bad request, not found, permission denied).
+ */
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  options: { maxRetries?: number; baseDelayMs?: number; label?: string } = {}
+): Promise<T> {
+  const { maxRetries = 3, baseDelayMs = 1000, label = "Docker API call" } = options;
+  let lastError: unknown;
+  
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      
+      // Don't retry on non-transient errors
+      if (!isRetryableError(error)) {
+        throw error;
+      }
+      
+      // Don't retry on last attempt
+      if (attempt === maxRetries) {
+        throw error;
+      }
+      
+      // Exponential backoff: 1s, 2s, 4s
+      const delay = baseDelayMs * Math.pow(2, attempt);
+      process.stderr.write(
+        `[retry] ${label} failed (attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${delay}ms...\n`
+      );
+      await new Promise(resolve => setTimeout(resolve, delay));
+    }
+  }
+  
+  throw lastError;
+}
+
+/**
+ * Determine if an error is transient and worth retrying.
+ * Retries on: connection resets, timeouts, 5xx status codes.
+ * Does NOT retry on: 4xx (client errors), permission denied, not found.
+ */
+function isRetryableError(error: unknown): boolean {
+  if (!(error instanceof Error)) return false;
+  
+  const msg = error.message.toLowerCase();
+  
+  // Connection-level transient errors
+  if (msg.includes("econnreset") || msg.includes("econnrefused")) return true;
+  if (msg.includes("etimedout") || msg.includes("socket hang up")) return true;
+  if (msg.includes("epipe") || msg.includes("eai_again")) return true;
+  
+  // Docker API 5xx errors (server-side)
+  if (msg.includes("status code 5")) return true;
+  if (msg.includes("internal server error")) return true;
+  if (msg.includes("bad gateway")) return true;
+  if (msg.includes("service unavailable")) return true;
+  
+  // Docker daemon busy (transient)
+  if (msg.includes("daemon is busy")) return true;
+  if (msg.includes("too many requests")) return true;
+  
+  // 4xx errors are NOT retryable (client errors)
+  if (msg.includes("status code 4")) return false;
+  if (msg.includes("not found")) return false;
+  if (msg.includes("permission denied")) return false;
+  if (msg.includes("bad request")) return false;
+  
+  // Permission/connection errors are NOT retryable
+  if (error.name === "DockerConnectionError") return false;
+  if (error.name === "DockerPermissionError") return false;
+  
+  // Timeout errors ARE retryable (might be transient)
+  if (error.name === "DockerTimeoutError") return true;
+  
+  return false;
+}
+
 export function formatError(error: unknown): string {
+  if (error instanceof DockerConnectionError) return `${error.name}: ${error.message}`;
+  if (error instanceof DockerTimeoutError) return `${error.name}: ${error.message}`;
+  if (error instanceof DockerPermissionError) return `${error.name}: ${error.message}`;
   if (error instanceof Error) return error.message;
   if (typeof error === "string") return error;
   return String(error);
@@ -82,4 +246,4 @@ export function formatBytes(bytes: number): string {
   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];
-}
+}

package/src/index.ts

@@ -1,12 +1,23 @@
 #!/usr/bin/env node
 
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { createDockerClient } from "./docker.js";
+import { createDockerClient, checkDockerConnection } from "./docker.js";
 import { createServer } from "./server.js";
 
+const DEFAULT_TIMEOUT_MS = 30_000;
+
 async function main() {
   const docker = createDockerClient();
-  const server = createServer(docker);
+
+  // Startup health check: verify Docker daemon is reachable
+  const health = await checkDockerConnection(docker);
+  if (!health.ok) {
+    process.stderr.write(`${health.error}\n`);
+    process.exit(1);
+  }
+  process.stderr.write("Docker daemon reachable\n");
+
+  const server = createServer(docker, { timeoutMs: DEFAULT_TIMEOUT_MS });
 
   const transport = new StdioServerTransport();
   await server.connect(transport);

package/src/server.ts

@@ -10,10 +10,14 @@ import { registerNetworkTools } from "./tools/network.js";
 import { registerVolumeTools } from "./tools/volume.js";
 import { registerMonitoringTools } from "./tools/monitoring.js";
 
-export function createServer(docker: Dockerode): McpServer {
+export interface ServerOptions {
+  timeoutMs?: number;
+}
+
+export function createServer(docker: Dockerode, options?: ServerOptions): McpServer {
   const server = new McpServer({
     name: "docker-mcp-server",
-    version: "0.3.0",
+    version: "0.3.2",
   });
 
   // Register all tool categories